@tbela99/css-parser 1.1.1-alpha4 → 1.2.0

package/dist/index.d.ts

@@ -142,6 +142,35 @@ declare enum EnumToken {
     TimingFunction = 17,
     TimelineFunction = 16
 }
+declare enum ColorType {
+    SYS = 0,
+    DPSYS = 1,
+    LIT = 2,
+    HEX = 3,
+    RGBA = 4,
+    HSLA = 5,
+    HWB = 6,
+    CMYK = 7,
+    OKLAB = 8,
+    OKLCH = 9,
+    LAB = 10,
+    LCH = 11,
+    COLOR = 12,
+    SRGB = 13,
+    PROPHOTO_RGB = 14,
+    A98_RGB = 15,
+    REC2020 = 16,
+    DISPLAY_P3 = 17,
+    SRGB_LINEAR = 18,
+    XYZ_D50 = 19,
+    XYZ_D65 = 20,
+    LIGHT_DARK = 21,
+    COLOR_MIX = 22,
+    RGB = 4,
+    HSL = 5,
+    XYZ = 20,
+    DEVICE_CMYK = 7
+}
 
 /**
  * minify ast
@@ -203,34 +232,8 @@ declare function renderToken(token: Token, options?: RenderOptions, cache?: {
     [key: string]: any;
 }, reducer?: (acc: string, curr: Token) => string, errors?: ErrorDescription[]): string;
 
-declare enum ColorKind {
-    SYS = 0,
-    DPSYS = 1,
-    LIT = 2,
-    HEX = 3,
-    RGB = 4,
-    RGBA = 5,
-    HSL = 6,
-    HSLA = 7,
-    HWB = 8,
-    DEVICE_CMYK = 9,
-    OKLAB = 10,
-    OKLCH = 11,
-    LAB = 12,
-    LCH = 13,
-    COLOR = 14,
-    SRGB = 15,
-    PROPHOTO_RGB = 16,
-    A98_RGB = 17,
-    REC2020 = 18,
-    DISPLAY_P3 = 19,
-    SRGB_LINEAR = 20,
-    XYZ = 21,
-    XYZ_D50 = 22,
-    XYZ_D65 = 23,
-    LIGHT_DARK = 24,
-    COLOR_MIX = 25
-}
+declare function okLabDistance(okLab1: [number, number, number], okLab2: [number, number, number]): number;
+declare function isOkLabClose(color1: ColorToken, color2: ColorToken, threshold?: number): boolean;
 
 /**
  * parse css string
@@ -625,7 +628,7 @@ export declare interface ColorToken extends BaseToken {
 
     typ: EnumToken.ColorTokenType;
     val: string;
-    kin: ColorKind;
+    kin: ColorType;
     chi?: Token[];
     /* calculated */
     cal?: 'rel' | 'mix';
@@ -938,6 +941,13 @@ interface ValidationToken {
     };
 }
 
+/**
+ * Converts a color token to another color space
+ * @param token
+ * @param to
+ */
+declare function convertColor(token: ColorToken, to: ColorType): ColorToken | null;
+
 export declare interface Position {
 
     ind: number;
@@ -1160,6 +1170,7 @@ interface ValidationOptions {
     validation?: boolean | ValidationLevel;
     lenient?: boolean;
     visited?: WeakMap<Token, Map<string, Set<ValidationToken>>>;
+    isOptional?:boolean | null;
     isRepeatable?:boolean | null;
     isList?:boolean | null;
     occurence?:boolean | null;
@@ -1245,7 +1256,7 @@ export declare interface RenderOptions {
     indent?: string;
     newLine?: string;
     removeComments?: boolean;
-    convertColor?: boolean;
+    convertColor?: boolean | ColorType;
     withParents?: boolean;
     output?: string;
     cwd?: string;
@@ -1355,4 +1366,4 @@ declare function parse(iterator: string, opt?: ParserOptions): Promise<ParseResu
  */
 declare function transform(css: string, options?: TransformOptions): Promise<TransformResult>;
 
-export { EnumToken, ValidationLevel, dirname, expand, load, minify, parse, parseString, parseTokens, render, renderToken, resolve, transform, walk, walkValues };
+export { ColorType, EnumToken, ValidationLevel, convertColor, dirname, expand, isOkLabClose, load, minify, okLabDistance, parse, parseString, parseTokens, render, renderToken, resolve, transform, walk, walkValues };

package/dist/lib/ast/expand.js

@@ -5,7 +5,7 @@ import '../parser/utils/config.js';
 import { EnumToken } from './types.js';
 import { walkValues } from './walk.js';
 import { renderToken } from '../renderer/render.js';
-import '../renderer/color/utils/constants.js';
+import '../syntax/color/utils/constants.js';
 
 /**
  * expand nested css ast
@@ -13,18 +13,22 @@ import '../renderer/color/utils/constants.js';
  */
 function expand(ast) {
     //
-    if (![EnumToken.RuleNodeType, EnumToken.StyleSheetNodeType, EnumToken.AtRuleNodeType].includes(ast.typ)) {
-        return ast;
-    }
-    if (EnumToken.RuleNodeType == ast.typ) {
-        return {
-            typ: EnumToken.StyleSheetNodeType,
-            chi: expandRule(ast)
-        };
-    }
-    if (!('chi' in ast)) {
-        return ast;
-    }
+    // if (![EnumToken.RuleNodeType, EnumToken.StyleSheetNodeType, EnumToken.AtRuleNodeType].includes(ast.typ)) {
+    //
+    //     return ast;
+    // }
+    // if (EnumToken.RuleNodeType == ast.typ) {
+    //
+    //     return <AstRuleStyleSheet>{
+    //         typ: EnumToken.StyleSheetNodeType,
+    //         chi: expandRule(<AstRule>ast)
+    //     }
+    // }
+    //
+    // if (!('chi' in ast)) {
+    //
+    //     return ast;
+    // }
     const result = { ...ast, chi: [] };
     // @ts-ignore
     for (let i = 0; i < ast.chi.length; i++) {
@@ -48,10 +52,11 @@ function expand(ast) {
             // @ts-ignore
             result.chi.push({ ...(hasRule ? expand(node) : node) });
         }
-        else {
-            // @ts-ignore
-            result.chi.push(node);
-        }
+        // else {
+        //
+        //     // @ts-ignore
+        //     result.chi.push(node);
+        // }
     }
     return result;
 }
@@ -65,24 +70,26 @@ function expandRule(node) {
                 const rule = ast.chi[i];
                 if (!rule.sel.includes('&')) {
                     const selRule = splitRule(rule.sel);
-                    if (selRule.length > 1) {
-                        const r = ':is(' + selRule.map(a => a.join('')).join(',') + ')';
-                        rule.sel = splitRule(ast.sel).reduce((a, b) => a.concat([b.join('') + r]), []).join(',');
-                    }
-                    else {
-                        // selRule = splitRule(selRule.reduce((acc, curr) => acc + (acc.length > 0 ? ',' : '') + curr.join(''), ''));
-                        const arSelf = splitRule(ast.sel).filter((r) => r.every((t) => t != ':before' && t != ':after' && !t.startsWith('::'))).reduce((acc, curr) => acc.concat([curr.join('')]), []).join(',');
-                        if (arSelf.length == 0) {
-                            ast.chi.splice(i--, 1);
-                            continue;
-                        }
-                        //
-                        selRule.forEach(arr => combinators.includes(arr[0].charAt(0)) ? arr.unshift(arSelf) : arr.unshift(arSelf, ' '));
-                        rule.sel = selRule.reduce((acc, curr) => {
-                            acc.push(curr.join(''));
-                            return acc;
-                        }, []).join(',');
+                    // if (selRule.length > 1) {
+                    //
+                    //     const r: string = ':is(' + selRule.map(a => a.join('')).join(',') + ')';
+                    //     rule.sel = splitRule(ast.sel).reduce((a: string[], b: string[]): string[] => a.concat([b.join('') + r]), <string[]>[]).join(',');
+                    //
+                    // }
+                    // else {
+                    // selRule = splitRule(selRule.reduce((acc, curr) => acc + (acc.length > 0 ? ',' : '') + curr.join(''), ''));
+                    const arSelf = splitRule(ast.sel).filter((r) => r.every((t) => t != ':before' && t != ':after' && !t.startsWith('::'))).reduce((acc, curr) => acc.concat([curr.join('')]), []).join(',');
+                    if (arSelf.length == 0) {
+                        ast.chi.splice(i--, 1);
+                        continue;
                     }
+                    //
+                    selRule.forEach(arr => combinators.includes(arr[0].charAt(0)) ? arr.unshift(arSelf) : arr.unshift(arSelf, ' '));
+                    rule.sel = selRule.reduce((acc, curr) => {
+                        acc.push(curr.join(''));
+                        return acc;
+                    }, []).join(',');
+                    // }
                 }
                 else {
                     let childSelectorCompound = [];
@@ -108,9 +115,10 @@ function expandRule(node) {
                                         if (s == '&' || parentSelector) {
                                             withCompound.push(s);
                                         }
-                                        else {
-                                            withoutCompound.push(s.slice(1));
-                                        }
+                                        // else {
+                                        //
+                                        //     withoutCompound.push(s.slice(1));
+                                        // }
                                     }
                                 }
                                 else {
@@ -121,9 +129,10 @@ function expandRule(node) {
                                 withCompound.push(s);
                             }
                         }
-                        else {
-                            withoutCompound.push(s);
-                        }
+                        // else {
+                        //
+                        //     withoutCompound.push(s);
+                        // }
                     }
                     const selectors = [];
                     const selector = rules.length > 1 ? ':is(' + rules.map(a => a.join('')).join(',') + ')' : rules[0].join('');
@@ -155,11 +164,13 @@ function expandRule(node) {
                         if (withCompound.length == 1) {
                             selectors.push(replaceCompound(withCompound[0], selector));
                         }
-                        else {
-                            for (const w of withCompound) {
-                                selectors.push(replaceCompound(w, selector));
-                            }
-                        }
+                        // else {
+                        //
+                        //     for (const w of withCompound) {
+                        //
+                        //         selectors.push(replaceCompound(w, selector));
+                        //     }
+                        // }
                     }
                     rule.sel = selectors.reduce((acc, curr) => curr.length == 0 ? acc : acc + (acc.length > 0 ? ',' : '') + curr, '');
                 }
@@ -200,10 +211,11 @@ function expandRule(node) {
                             // @ts-ignore
                             astAtRule.chi.push(...expandRule(r));
                         }
-                        else {
-                            // @ts-ignore
-                            astAtRule.chi.push(r);
-                        }
+                        // else {
+                        //
+                        //     // @ts-ignore
+                        //     astAtRule.chi.push(r);
+                        // }
                     }
                 }
                 // @ts-ignore
@@ -230,21 +242,23 @@ function replaceCompound(input, replace) {
                     if (replacement == null) {
                         replacement = parseString(replace);
                     }
-                    if (tokens[1].typ == EnumToken.IdenTokenType) {
-                        t.value.val = replacement.length == 1 || (!replace.includes(' ') && replace.charAt(0).match(/[:.]/)) ? tokens[1].val + replace : replaceCompoundLiteral(tokens[1].val + '&', replace);
-                        tokens.splice(1, 1);
-                    }
-                    else {
-                        t.value.val = replaceCompoundLiteral(t.value.val, replace);
-                    }
+                    // if (tokens[1].typ == EnumToken.IdenTokenType) {
+                    //
+                    //
+                    //     (t.value as LiteralToken).val = (replacement as Token[]).length == 1 || (!replace.includes(' ') && replace.charAt(0).match(/[:.]/)) ? (tokens[1] as IdentToken).val + replace : replaceCompoundLiteral((tokens[1] as IdentToken).val + '&', replace);
+                    //     tokens.splice(1, 1);
+                    // } else {
+                    t.value.val = replaceCompoundLiteral(t.value.val, replace);
+                    // }
                     continue;
                 }
                 const rule = splitRule(replace);
                 t.value.val = rule.length > 1 ? ':is(' + replace + ')' : replace;
             }
-            else if (t.value.val.length > 1 && t.value.val.charAt(0) == '&') {
-                t.value.val = replaceCompoundLiteral(t.value.val, replace);
-            }
+            // else if ((t.value as LiteralToken).val.length > 1 && (t.value as LiteralToken).val.charAt(0) == '&') {
+            //
+            //     (t.value as LiteralToken).val = replaceCompoundLiteral((t.value as LiteralToken).val, replace);
+            // }
         }
     }
     return tokens.reduce((acc, curr) => acc + renderToken(curr), '');
@@ -257,9 +271,10 @@ function replaceCompoundLiteral(selector, replace) {
             tokens.push('&');
             tokens.push('');
         }
-        else {
-            tokens[tokens.length - 1] += selector.charAt(i);
-        }
+        // else {
+        //
+        //     tokens[tokens.length - 1] += selector.charAt(i);
+        // }
     }
     return tokens.sort((a, b) => {
         if (a == '&') {
@@ -267,9 +282,10 @@ function replaceCompoundLiteral(selector, replace) {
         }
         return b == '&' ? -1 : 0;
     }).reduce((acc, curr) => {
-        if (acc.length > 0 && curr == '&' && (replace.charAt(0) != '.' || replace.includes(' '))) {
-            return acc + ':is(' + replace + ')';
-        }
+        // if (acc.length > 0 && curr == '&' && (replace.charAt(0) != '.' || replace.includes(' '))) {
+        //
+        //     return acc + ':is(' + replace + ')';
+        // }
         return acc + (curr == '&' ? replace : curr);
     }, '');
 }

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

@@ -2,7 +2,7 @@ import { EnumToken } from '../types.js';
 import { walkValues, WalkerValueEvent, WalkerOptionEnum } from '../walk.js';
 import { evaluate } from '../math/expression.js';
 import { renderToken } from '../../renderer/render.js';
-import '../../renderer/color/utils/constants.js';
+import '../../syntax/color/utils/constants.js';
 import '../minify.js';
 import '../../parser/parse.js';
 import '../../parser/tokenize.js';
@@ -57,7 +57,7 @@ class ComputeCalcExpressionFeature {
                     if (slice != null && node.typ == EnumToken.FunctionTokenType && mathFuncs.includes(node.val)) {
                         // @ts-ignore
                         const cp = (node.typ == EnumToken.FunctionTokenType && mathFuncs.includes(node.val) && node.val != 'calc' ? [node] : (node.typ == EnumToken.DeclarationNodeType ? node.val : node.chi)).slice();
-                        const values = evaluate(cp);
+                        evaluate(cp);
                         const key = 'chi' in node ? 'chi' : 'val';
                         const str1 = renderToken({ ...node, [key]: slice });
                         const str2 = renderToken(node); // values.reduce((acc: string, curr: Token): string => acc + renderToken(curr), '');
@@ -65,10 +65,11 @@ class ComputeCalcExpressionFeature {
                             // @ts-ignore
                             node[key] = slice;
                         }
-                        else {
-                            // @ts-ignore
-                            node[key] = values;
-                        }
+                        // else {
+                        //
+                        //     // @ts-ignore
+                        //     node[key] = values;
+                        // }
                         return WalkerOptionEnum.Ignore;
                     }
                     return null;
@@ -84,41 +85,42 @@ class ComputeCalcExpressionFeature {
                             // @ts-ignore
                             const children = parent.typ == EnumToken.DeclarationNodeType ? parent.val : parent.chi;
                             if (values.length == 1 && values[0].typ != EnumToken.BinaryExpressionTokenType) {
-                                if (parent.typ == EnumToken.BinaryExpressionTokenType) {
-                                    if (parent.l == value) {
-                                        parent.l = values[0];
-                                    }
-                                    else {
-                                        parent.r = values[0];
-                                    }
-                                }
-                                else {
-                                    for (let i = 0; i < children.length; i++) {
-                                        if (children[i] == value) {
-                                            // @ts-ignore
-                                            children.splice(i, 1, !(parent.typ == EnumToken.FunctionTokenType && parent.val == 'calc') && typeof values[0].val != 'string' ? {
-                                                typ: EnumToken.FunctionTokenType,
-                                                val: 'calc',
-                                                chi: values
-                                            } : values[0]);
-                                            break;
-                                        }
+                                // if (parent.typ == EnumToken.BinaryExpressionTokenType) {
+                                //
+                                //     if ((parent as BinaryExpressionToken).l == value) {
+                                //
+                                //         (parent as BinaryExpressionToken).l = values[0];
+                                //     } else {
+                                //
+                                //         (parent as BinaryExpressionToken).r = values[0];
+                                //     }
+                                // } else {
+                                for (let i = 0; i < children.length; i++) {
+                                    if (children[i] == value) {
+                                        // @ts-ignore
+                                        children.splice(i, 1, !(parent.typ == EnumToken.FunctionTokenType && parent.val == 'calc') && typeof values[0].val != 'string' ? {
+                                            typ: EnumToken.FunctionTokenType,
+                                            val: 'calc',
+                                            chi: values
+                                        } : values[0]);
+                                        break;
                                     }
                                 }
+                                // }
                             }
                             else {
                                 for (let i = 0; i < children.length; i++) {
                                     if (children[i] == value) {
-                                        if (parent.typ == EnumToken.FunctionTokenType && parent.val == 'calc') {
-                                            children.splice(i, 1, ...values);
-                                        }
-                                        else {
-                                            children.splice(i, 1, {
-                                                typ: EnumToken.FunctionTokenType,
-                                                val: 'calc',
-                                                chi: values
-                                            });
-                                        }
+                                        // if (parent.typ == EnumToken.FunctionTokenType && (parent as FunctionToken).val == 'calc') {
+                                        //
+                                        //     children.splice(i, 1, ...values);
+                                        // } else {
+                                        children.splice(i, 1, {
+                                            typ: EnumToken.FunctionTokenType,
+                                            val: 'calc',
+                                            chi: values
+                                        });
+                                        // }
                                         break;
                                     }
                                 }

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

@@ -1,7 +1,7 @@
 import { EnumToken } from '../types.js';
 import { walkValues } from '../walk.js';
 import { renderToken } from '../../renderer/render.js';
-import '../../renderer/color/utils/constants.js';
+import '../../syntax/color/utils/constants.js';
 import { splitRule } from '../minify.js';
 import '../../parser/parse.js';
 import '../../parser/tokenize.js';
@@ -106,18 +106,25 @@ class InlineCssVariablesFeature {
                         replace(node, variableScope);
                     }
                 }
-                else {
-                    const info = variableScope.get(node.nam);
-                    info.globalScope = isRoot;
-                    if (!isRoot) {
-                        ++info.declarationCount;
-                    }
-                    if (info.replaceable) {
-                        info.replaceable = isRoot && info.declarationCount == 1;
-                    }
-                    info.parent.add(ast);
-                    info.node = node;
-                }
+                // else {
+                //
+                //     const info: VariableScopeInfo = <VariableScopeInfo>variableScope.get((<AstDeclaration>node).nam);
+                //
+                //     info.globalScope = isRoot;
+                //
+                //     if (!isRoot) {
+                //
+                //         ++info.declarationCount;
+                //     }
+                //
+                //     if (info.replaceable) {
+                //
+                //         info.replaceable = isRoot && info.declarationCount == 1;
+                //     }
+                //
+                //     info.parent.add(ast);
+                //     info.node = (<AstDeclaration>node);
+                // }
             }
             else {
                 replace(node, variableScope);
@@ -126,9 +133,10 @@ class InlineCssVariablesFeature {
     }
     cleanup(ast, options = {}, context) {
         const variableScope = context.variableScope;
-        if (variableScope == null) {
-            return;
-        }
+        // if (variableScope == null) {
+        //
+        //     return;
+        // }
         for (const info of variableScope.values()) {
             if (info.replaceable) {
                 let i;
@@ -140,7 +148,7 @@ class InlineCssVariablesFeature {
                             // @ts-ignore
                             parent.chi.splice(i, 1, {
                                 typ: EnumToken.CommentTokenType,
-                                val: `/* ${info.node.nam}: ${info.values.reduce((acc, curr) => acc + renderToken(curr), '')} */`
+                                val: `/* ${info.node.nam}: ${info.values.reduce((acc, curr) => acc + renderToken(curr, { convertColor: false }), '')} */`
                             });
                             break;
                         }

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

@@ -2,14 +2,14 @@ import { EnumToken, SyntaxValidationResult } from '../types.js';
 import { getSyntaxConfig } from '../../validation/config.js';
 import '../../validation/parser/types.js';
 import '../../validation/parser/parse.js';
-import { splitRule, definedPropertySettings } from '../minify.js';
+import { splitRule } from '../minify.js';
 import { walkValues } from '../walk.js';
-import { parseAtRulePrelude, parseString } from '../../parser/parse.js';
+import '../../parser/parse.js';
 import '../../parser/tokenize.js';
 import '../../parser/utils/config.js';
 import { pseudoAliasMap } from '../../syntax/syntax.js';
 import { renderToken } from '../../renderer/render.js';
-import { funcLike } from '../../renderer/color/utils/constants.js';
+import { funcLike } from '../../syntax/color/utils/constants.js';
 import '../../validation/syntaxes/complex-selector.js';
 import { evaluateSyntax } from '../../validation/syntax.js';
 
@@ -73,12 +73,15 @@ class ComputePrefixFeature {
     run(node) {
         if (node.typ == EnumToken.RuleNodeType) {
             node.sel = replacePseudo(splitRule(node.sel)).reduce((acc, curr, index) => acc + (index > 0 ? ',' : '') + curr.join(''), '');
-            if (node.raw != null) {
-                node.raw = replacePseudo(node.raw);
-            }
-            if (node.optimized != null) {
-                node.optimized.selector = replacePseudo(node.optimized.selector);
-            }
+            // if ((node as AstRule).raw != null) {
+            //
+            //     (node as AstRule).raw = replacePseudo((node as AstRule).raw as string[][]);
+            // }
+            //
+            // if ((node as AstRule).optimized != null) {
+            //
+            //     (node as AstRule).optimized!.selector = replacePseudo((node as AstRule).optimized!.selector as string[][]);
+            // }
             if (node.tokens != null) {
                 replaceAstNodes(node.tokens);
             }
@@ -114,10 +117,9 @@ class ComputePrefixFeature {
                 for (const { value } of walkValues(nodes)) {
                     if ((value.typ == EnumToken.IdenTokenType || funcLike.includes(value.typ))) {
                         const match = value.val.match(/^-([^-]+)-(.+)$/);
-                        if (match == null) {
-                            continue;
+                        if (match != null) {
+                            value.val = match[2];
                         }
-                        value.val = match[2];
                     }
                 }
                 if (SyntaxValidationResult.Valid == evaluateSyntax({ ...node, val: nodes }, {}).valid) {
@@ -133,13 +135,14 @@ class ComputePrefixFeature {
                 }
             }
             if (node.typ == EnumToken.AtRuleNodeType && node.val !== '') {
-                if (node.tokens == null) {
-                    Object.defineProperty(node, 'tokens', {
-                        // @ts-ignore
-                        ...definedPropertySettings,
-                        value: parseAtRulePrelude(parseString(node.val), node),
-                    });
-                }
+                // if ((node as AstAtRule).tokens == null) {
+                //
+                //     Object.defineProperty(node, 'tokens', {
+                //         // @ts-ignore
+                //         ...definedPropertySettings,
+                //         value: parseAtRulePrelude(parseString((node as AstAtRule).val), node as AstAtRule),
+                //     })
+                // }
                 if (replaceAstNodes(node.tokens)) {
                     node.val = node.tokens.reduce((acc, curr) => acc + renderToken(curr), '');
                 }

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

@@ -5,7 +5,7 @@ import '../walk.js';
 import '../../parser/parse.js';
 import '../../parser/tokenize.js';
 import '../../parser/utils/config.js';
-import '../../renderer/color/utils/constants.js';
+import '../../syntax/color/utils/constants.js';
 import '../../renderer/sourcemap/lib/encode.js';
 
 class ComputeShorthandFeature {

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

@@ -6,7 +6,7 @@ import '../../parser/parse.js';
 import '../../parser/tokenize.js';
 import '../../parser/utils/config.js';
 import { filterValues, renderToken } from '../../renderer/render.js';
-import '../../renderer/color/utils/constants.js';
+import '../../syntax/color/utils/constants.js';
 import { compute } from '../transform/compute.js';
 import { eqMatrix } from '../transform/minify.js';
 
@@ -40,7 +40,22 @@ class TransformCssFeature {
             if (node.typ != EnumToken.DeclarationNodeType || !node.nam.match(/^(-[a-z]+-)?transform$/)) {
                 continue;
             }
-            const children = node.val.slice();
+            const children = node.val.reduce((acc, curr) => {
+                if (curr.typ == EnumToken.FunctionTokenType && 'skew' == curr.val.toLowerCase()) {
+                    if (curr.chi.length == 3) {
+                        if (curr.chi[2].val == '0') {
+                            curr.chi.length = 1;
+                            curr.val = 'skew';
+                        }
+                        else if (curr.chi[0].val == '0') {
+                            curr.chi = [curr.chi[2]];
+                            curr.val = 'skewY';
+                        }
+                    }
+                }
+                acc.push(curr);
+                return acc;
+            }, []);
             consumeWhitespace(children);
             let { matrix, cumulative, minified } = compute(children) ?? {};
             if (matrix == null || cumulative == null || minified == null) {