@tbela99/css-parser 0.0.1 → 0.1.0

package/dist/index-umd-web.js

@@ -4,6 +4,93 @@
     (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.CSSParser = {}));
 })(this, (function (exports) { 'use strict';
 
+    exports.NodeType = void 0;
+    (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";
+    })(exports.NodeType || (exports.NodeType = {}));
+    exports.EnumToken = void 0;
+    (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";
+    })(exports.EnumToken || (exports.EnumToken = {}));
+
     // name to color
     const COLORS_NAMES = Object.seal({
         'aliceblue': '#f0f8ff',
@@ -316,18 +403,18 @@
             // @ts-ignore
             t = token.chi[i];
             // @ts-ignore
-            value += Math.round(t.typ == 'Perc' ? 255 * t.val / 100 : t.val).toString(16).padStart(2, '0');
+            value += Math.round(t.typ == exports.EnumToken.PercentageTokenType ? 255 * t.val / 100 : t.val).toString(16).padStart(2, '0');
         }
         // @ts-ignore
         if (token.chi.length == 7) {
             // @ts-ignore
             t = token.chi[6];
             // @ts-ignore
-            if ((t.typ == 'Number' && t.val < 1) ||
+            if ((t.typ == exports.EnumToken.NumberTokenType && t.val < 1) ||
                 // @ts-ignore
-                (t.typ == 'Perc' && t.val < 100)) {
+                (t.typ == exports.EnumToken.PercentageTokenType && t.val < 100)) {
                 // @ts-ignore
-                value += Math.round(255 * (t.typ == 'Perc' ? t.val / 100 : t.val)).toString(16).padStart(2, '0');
+                value += Math.round(255 * (t.typ == exports.EnumToken.PercentageTokenType ? t.val / 100 : t.val)).toString(16).padStart(2, '0');
             }
         }
         return value;
@@ -339,21 +426,21 @@
         // @ts-ignore
         t = token.chi[2];
         // @ts-ignore
-        let s = t.typ == 'Perc' ? t.val / 100 : t.val;
+        let s = t.typ == exports.EnumToken.PercentageTokenType ? t.val / 100 : t.val;
         // @ts-ignore
         t = token.chi[4];
         // @ts-ignore
-        let l = t.typ == 'Perc' ? t.val / 100 : t.val;
+        let l = t.typ == exports.EnumToken.PercentageTokenType ? t.val / 100 : t.val;
         let a = null;
         if (token.chi?.length == 7) {
             // @ts-ignore
             t = token.chi[6];
             // @ts-ignore
-            if ((t.typ == 'Perc' && t.val < 100) ||
+            if ((t.typ == exports.EnumToken.PercentageTokenType && t.val < 100) ||
                 // @ts-ignore
-                (t.typ == 'Number' && t.val < 1)) {
+                (t.typ == exports.EnumToken.NumberTokenType && t.val < 1)) {
                 // @ts-ignore
-                a = (t.typ == 'Perc' ? t.val / 100 : t.val);
+                a = (t.typ == exports.EnumToken.PercentageTokenType ? t.val / 100 : t.val);
             }
         }
         return `#${hsl2rgb(h, s, l, a).reduce((acc, curr) => acc + curr.toString(16).padStart(2, '0'), '')}`;
@@ -365,21 +452,21 @@
         // @ts-ignore
         t = token.chi[2];
         // @ts-ignore
-        let white = t.typ == 'Perc' ? t.val / 100 : t.val;
+        let white = t.typ == exports.EnumToken.PercentageTokenType ? t.val / 100 : t.val;
         // @ts-ignore
         t = token.chi[4];
         // @ts-ignore
-        let black = t.typ == 'Perc' ? t.val / 100 : t.val;
+        let black = t.typ == exports.EnumToken.PercentageTokenType ? t.val / 100 : t.val;
         let a = null;
         if (token.chi?.length == 7) {
             // @ts-ignore
             t = token.chi[6];
             // @ts-ignore
-            if ((t.typ == 'Perc' && t.val < 100) ||
+            if ((t.typ == exports.EnumToken.PercentageTokenType && t.val < 100) ||
                 // @ts-ignore
-                (t.typ == 'Number' && t.val < 1)) {
+                (t.typ == exports.EnumToken.NumberTokenType && t.val < 1)) {
                 // @ts-ignore
-                a = (t.typ == 'Perc' ? t.val / 100 : t.val);
+                a = (t.typ == exports.EnumToken.PercentageTokenType ? t.val / 100 : t.val);
             }
         }
         const rgb = hsl2rgb(h, 1, .5, a);
@@ -396,19 +483,19 @@
         // @ts-ignore
         let t = token.chi[0];
         // @ts-ignore
-        const c = t.typ == 'Perc' ? t.val / 100 : t.val;
+        const c = t.typ == exports.EnumToken.PercentageTokenType ? t.val / 100 : t.val;
         // @ts-ignore
         t = token.chi[2];
         // @ts-ignore
-        const m = t.typ == 'Perc' ? t.val / 100 : t.val;
+        const m = t.typ == exports.EnumToken.PercentageTokenType ? t.val / 100 : t.val;
         // @ts-ignore
         t = token.chi[4];
         // @ts-ignore
-        const y = t.typ == 'Perc' ? t.val / 100 : t.val;
+        const y = t.typ == exports.EnumToken.PercentageTokenType ? t.val / 100 : t.val;
         // @ts-ignore
         t = token.chi[6];
         // @ts-ignore
-        const k = t.typ == 'Perc' ? t.val / 100 : t.val;
+        const k = t.typ == exports.EnumToken.PercentageTokenType ? t.val / 100 : t.val;
         const rgb = [
             Math.round(255 * (1 - Math.min(1, c * (1 - k) + k))),
             Math.round(255 * (1 - Math.min(1, m * (1 - k) + k))),
@@ -419,12 +506,12 @@
             // @ts-ignore
             t = token.chi[8];
             // @ts-ignore
-            rgb.push(Math.round(255 * (t.typ == 'Perc' ? t.val / 100 : t.val)));
+            rgb.push(Math.round(255 * (t.typ == exports.EnumToken.PercentageTokenType ? t.val / 100 : t.val)));
         }
         return `#${rgb.reduce((acc, curr) => acc + curr.toString(16).padStart(2, '0'), '')}`;
     }
     function getAngle(token) {
-        if (token.typ == 'Angle') {
+        if (token.typ == exports.EnumToken.AngleTokenType) {
             switch (token.unit) {
                 case 'deg':
                     // @ts-ignore
@@ -497,6 +584,97 @@
         return values;
     }
 
+    // from https://github.com/Rich-Harris/vlq/tree/master
+    // credit: Rich Harris
+    const integer_to_char = {};
+    let i = 0;
+    for (const char of 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=') {
+        integer_to_char[i++] = char;
+    }
+    function encode(value) {
+        if (typeof value === 'number') {
+            return encode_integer(value);
+        }
+        let result = '';
+        for (let i = 0; i < value.length; i += 1) {
+            result += encode_integer(value[i]);
+        }
+        return result;
+    }
+    function encode_integer(num) {
+        let result = '';
+        if (num < 0) {
+            num = (-num << 1) | 1;
+        }
+        else {
+            num <<= 1;
+        }
+        do {
+            let clamped = num & 31;
+            num >>>= 5;
+            if (num > 0) {
+                clamped |= 32;
+            }
+            result += integer_to_char[clamped];
+        } while (num > 0);
+        return result;
+    }
+
+    class SourceMap {
+        #version = 3;
+        #sources = [];
+        #map = new Map;
+        #line = -1;
+        lastLocation = null;
+        add(source, original) {
+            if (original.src !== '') {
+                if (!this.#sources.includes(original.src)) {
+                    this.#sources.push(original.src);
+                }
+                const line = source.sta.lin - 1;
+                let record;
+                if (line > this.#line) {
+                    this.#line = line;
+                }
+                if (!this.#map.has(line)) {
+                    record = [Math.max(0, source.sta.col - 1), this.#sources.indexOf(original.src), original.sta.lin - 1, original.sta.col - 1];
+                    this.#map.set(line, [record]);
+                }
+                else {
+                    const arr = this.#map.get(line);
+                    record = [Math.max(0, source.sta.col - 1 - arr[0][0]), this.#sources.indexOf(original.src) - arr[0][1], original.sta.lin - 1, original.sta.col - 1];
+                    arr.push(record);
+                }
+                if (this.lastLocation != null) {
+                    record[2] -= this.lastLocation.sta.lin - 1;
+                    record[3] -= this.lastLocation.sta.col - 1;
+                }
+                this.lastLocation = original;
+            }
+        }
+        toUrl() {
+            // /*# sourceMappingURL = ${url} */
+            return `data:application/json,${encodeURIComponent(JSON.stringify(this.toJSON()))}`;
+        }
+        toJSON() {
+            const mappings = [];
+            let i = 0;
+            for (; i <= this.#line; i++) {
+                if (!this.#map.has(i)) {
+                    mappings.push('');
+                }
+                else {
+                    mappings.push(this.#map.get(i).reduce((acc, curr) => acc + (acc === '' ? '' : ',') + encode(curr), ''));
+                }
+            }
+            return {
+                version: this.#version,
+                sources: this.#sources.slice(),
+                mappings: mappings.join(';')
+            };
+        }
+    }
+
     const colorsFunc = ['rgb', 'rgba', 'hsl', 'hsla', 'hwb', 'device-cmyk'];
     function reduceNumber(val) {
         val = (+val).toString();
@@ -515,35 +693,88 @@
         }
         return val;
     }
-    function render(data, opt = {}) {
+    function update(position, str) {
+        let i = 0;
+        for (; i < str.length; i++) {
+            if (isNewLine(str[i].charCodeAt(0))) {
+                position.lin++;
+                position.col = 0;
+            }
+            else {
+                position.col++;
+            }
+        }
+    }
+    function doRender(data, options = {}) {
+        options = {
+            ...(options.minify ?? true ? {
+                indent: '',
+                newLine: '',
+                removeComments: true
+            } : {
+                indent: ' ',
+                newLine: '\n',
+                compress: false,
+                removeComments: false,
+            }), sourcemap: false, colorConvert: true, expandNestingRules: false, preserveLicense: false, ...options
+        };
         const startTime = performance.now();
         const errors = [];
-        const options = Object.assign(opt.minify ?? true ? {
-            indent: '',
-            newLine: '',
-            removeComments: true
-        } : {
-            indent: ' ',
-            newLine: '\n',
-            compress: false,
-            removeComments: false,
-        }, { colorConvert: true, expandNestingRules: false, preserveLicense: false }, opt);
-        return {
-            code: doRender(options.expandNestingRules ? expand(data) : data, options, errors, function reducer(acc, curr) {
-                if (curr.typ == 'Comment' && options.removeComments) {
+        const sourcemap = options.sourcemap ? new SourceMap : null;
+        const cache = Object.create(null);
+        const result = {
+            code: renderAstNode(options.expandNestingRules ? expand(data) : data, options, sourcemap, {
+                ind: 0,
+                lin: 1,
+                col: 1
+            }, errors, function reducer(acc, curr) {
+                if (curr.typ == exports.EnumToken.CommentTokenType && options.removeComments) {
                     if (!options.preserveLicense || !curr.val.startsWith('/*!')) {
                         return acc;
                     }
                     return acc + curr.val;
                 }
-                return acc + renderToken(curr, options, reducer, errors);
-            }, 0), errors, stats: {
+                return acc + renderToken(curr, options, cache, reducer, errors);
+            }, cache), errors, stats: {
                 total: `${(performance.now() - startTime).toFixed(2)}ms`
             }
         };
+        if (options.output != null) {
+            // @ts-ignore
+            options.output = options.resolve(options.output, options.cwd).absolute;
+        }
+        if (sourcemap != null) {
+            result.map = sourcemap.toJSON();
+            // @ts-ignore
+            // result.map.sources = result.map.sources?.map(s => <string>options?.resolve(s, <string>options?.cwd)?.relative)
+        }
+        return result;
+    }
+    function updateSourceMap(node, options, cache, sourcemap, position, str) {
+        if ([4 /* NodeType.RuleNodeType */, 3 /* NodeType.AtRuleNodeType */].includes(node.typ)) {
+            let src = node.loc?.src ?? '';
+            let output = options.output ?? '';
+            if (src !== '') {
+                if (!(src in cache)) {
+                    // @ts-ignore
+                    cache[src] = options.resolve(src, options.cwd ?? '').relative;
+                }
+            }
+            if (!(output in cache)) {
+                // @ts-ignore
+                cache[output] = options.resolve(output, options.cwd).relative;
+            }
+            // @ts-ignore
+            sourcemap.add({ src: cache[output], sta: { ...position } }, {
+                ...node.loc,
+                // @ts-ignore
+                src: options.resolve(cache[src], options.cwd).relative
+            });
+        }
+        update(position, str);
     }
     // @ts-ignore
-    function doRender(data, options, errors, reducer, level = 0, indents = []) {
+    function renderAstNode(data, options, sourcemap, position, errors, reducer, cache, level = 0, indents = []) {
         if (indents.length < level + 1) {
             indents.push(options.indent.repeat(level));
         }
@@ -553,46 +784,61 @@
         const indent = indents[level];
         const indentSub = indents[level + 1];
         switch (data.typ) {
-            case 'Declaration':
+            case 5 /* NodeType.DeclarationNodeType */:
                 return `${data.nam}:${options.indent}${data.val.reduce(reducer, '')}`;
-            case 'Comment':
-            case 'CDOCOMM':
+            case 0 /* NodeType.CommentNodeType */:
+            case 1 /* NodeType.CDOCOMMNodeType */:
+                if (data.val.startsWith('# sourceMappingURL=')) {
+                    // ignore sourcemap
+                    return '';
+                }
                 return !options.removeComments || (options.preserveLicense && data.val.startsWith('/*!')) ? data.val : '';
-            case 'StyleSheet':
+            case 2 /* NodeType.StyleSheetNodeType */:
                 return data.chi.reduce((css, node) => {
-                    const str = doRender(node, options, errors, reducer, level, indents);
+                    const str = renderAstNode(node, options, sourcemap, { ...position }, errors, reducer, cache, level, indents);
                     if (str === '') {
                         return css;
                     }
                     if (css === '') {
+                        if (sourcemap != null) {
+                            updateSourceMap(node, options, cache, sourcemap, position, str);
+                        }
                         return str;
                     }
+                    if (sourcemap != null) {
+                        update(position, options.newLine);
+                        updateSourceMap(node, options, cache, sourcemap, position, str);
+                    }
                     return `${css}${options.newLine}${str}`;
                 }, '');
-            case 'AtRule':
-            case 'Rule':
-                if (data.typ == 'AtRule' && !('chi' in data)) {
+            case 3 /* NodeType.AtRuleNodeType */:
+            case 4 /* NodeType.RuleNodeType */:
+                if (data.typ == 3 /* NodeType.AtRuleNodeType */ && !('chi' in data)) {
                     return `${indent}@${data.nam}${data.val === '' ? '' : options.indent || ' '}${data.val};`;
                 }
                 // @ts-ignore
                 let children = data.chi.reduce((css, node) => {
                     let str;
-                    if (node.typ == 'Comment') {
+                    if (node.typ == 0 /* NodeType.CommentNodeType */) {
                         str = options.removeComments && (!options.preserveLicense || !node.val.startsWith('/*!')) ? '' : node.val;
                     }
-                    else if (node.typ == 'Declaration') {
+                    else if (node.typ == 5 /* NodeType.DeclarationNodeType */) {
                         if (node.val.length == 0) {
                             // @ts-ignore
-                            errors.push({ action: 'ignore', message: `render: invalid declaration ${JSON.stringify(node)}`, location: node.loc });
+                            errors.push({
+                                action: 'ignore',
+                                message: `render: invalid declaration ${JSON.stringify(node)}`,
+                                location: node.loc
+                            });
                             return '';
                         }
                         str = `${node.nam}:${options.indent}${node.val.reduce(reducer, '').trimEnd()};`;
                     }
-                    else if (node.typ == 'AtRule' && !('chi' in node)) {
+                    else if (node.typ == 3 /* NodeType.AtRuleNodeType */ && !('chi' in node)) {
                         str = `${data.val === '' ? '' : options.indent || ' '}${data.val};`;
                     }
                     else {
-                        str = doRender(node, options, errors, reducer, level + 1, indents);
+                        str = renderAstNode(node, options, sourcemap, { ...position }, errors, reducer, cache, level + 1, indents);
                     }
                     if (css === '') {
                         return str;
@@ -605,28 +851,40 @@
                 if (children.endsWith(';')) {
                     children = children.slice(0, -1);
                 }
-                if (data.typ == 'AtRule') {
+                if (data.typ == 3 /* NodeType.AtRuleNodeType */) {
                     return `@${data.nam}${data.val === '' ? '' : options.indent || ' '}${data.val}${options.indent}{${options.newLine}` + (children === '' ? '' : indentSub + children + options.newLine) + indent + `}`;
                 }
                 return data.sel + `${options.indent}{${options.newLine}` + (children === '' ? '' : indentSub + children + options.newLine) + indent + `}`;
         }
         return '';
     }
-    function renderToken(token, options = {}, reducer, errors) {
+    function renderToken(token, options = {}, cache = Object.create(null), reducer, errors) {
         if (reducer == null) {
             reducer = function (acc, curr) {
-                if (curr.typ == 'Comment' && options.removeComments) {
+                if (curr.typ == exports.EnumToken.CommentTokenType && options.removeComments) {
                     if (!options.preserveLicense || !curr.val.startsWith('/*!')) {
                         return acc;
                     }
                     return acc + curr.val;
                 }
-                return acc + renderToken(curr, options, reducer, errors);
+                return acc + renderToken(curr, options, cache, reducer, errors);
             };
         }
         switch (token.typ) {
-            case 'Color':
-                if (options.minify || options.colorConvert) {
+            case exports.EnumToken.ListToken:
+                return token.chi.reduce((acc, curr) => acc + renderToken(curr, options, cache), '');
+            case exports.EnumToken.BinaryExpressionTokenType:
+                return renderToken(token.l, options, cache) + (token.op == exports.EnumToken.Add ? ' + ' : (token.op == exports.EnumToken.Sub ? ' - ' : (token.op == exports.EnumToken.Mul ? '*' : '/'))) + renderToken(token.r, options, cache);
+            case exports.EnumToken.Add:
+                return ' + ';
+            case exports.EnumToken.Sub:
+                return ' - ';
+            case exports.EnumToken.Mul:
+                return '*';
+            case exports.EnumToken.Div:
+                return '/';
+            case exports.EnumToken.ColorTokenType:
+                if (options.colorConvert) {
                     if (token.kin == 'lit' && token.val.toLowerCase() == 'currentcolor') {
                         return 'currentcolor';
                     }
@@ -666,54 +924,69 @@
                 if (token.kin == 'hex' || token.kin == 'lit') {
                     return token.val;
                 }
-            case 'Start-parens':
-                if (!('chi' in token)) {
-                    return '(';
+            case exports.EnumToken.ParensTokenType:
+            case exports.EnumToken.FunctionTokenType:
+            case exports.EnumToken.UrlFunctionTokenType:
+            case exports.EnumToken.PseudoClassFuncTokenType:
+                if (token.typ == exports.EnumToken.FunctionTokenType &&
+                    token.val == 'calc' &&
+                    token.chi.length == 1) {
+                    // calc(200px) => 200px
+                    return token.chi.reduce((acc, curr) => acc + renderToken(curr, options, cache, reducer), '');
                 }
-            case 'Func':
-            case 'UrlFunc':
-            case 'Pseudo-class-func':
                 // @ts-ignore
                 return ( /* options.minify && 'Pseudo-class-func' == token.typ && token.val.slice(0, 2) == '::' ? token.val.slice(1) :*/token.val ?? '') + '(' + token.chi.reduce(reducer, '') + ')';
-            case 'Includes':
+            case exports.EnumToken.StartParensTokenType:
+                return '(';
+            case exports.EnumToken.IncludesTokenType:
                 return '~=';
-            case 'Dash-match':
+            case exports.EnumToken.DashMatchTokenType:
                 return '|=';
-            case 'Lt':
+            case exports.EnumToken.LtTokenType:
                 return '<';
-            case 'Lte':
+            case exports.EnumToken.LteTokenType:
                 return '<=';
-            case 'Gt':
+            case exports.EnumToken.GtTokenType:
                 return '>';
-            case 'Gte':
+            case exports.EnumToken.GteTokenType:
                 return '>=';
-            case 'End-parens':
+            case exports.EnumToken.EndParensTokenType:
                 return ')';
-            case 'Attr-start':
+            case exports.EnumToken.AttrStartTokenType:
                 return '[';
-            case 'Attr-end':
+            case exports.EnumToken.AttrEndTokenType:
                 return ']';
-            case 'Whitespace':
+            case exports.EnumToken.WhitespaceTokenType:
                 return ' ';
-            case 'Colon':
+            case exports.EnumToken.ColonTokenType:
                 return ':';
-            case 'Semi-colon':
+            case exports.EnumToken.SemiColonTokenType:
                 return ';';
-            case 'Comma':
+            case exports.EnumToken.CommaTokenType:
                 return ',';
-            case 'Important':
+            case exports.EnumToken.ImportantTokenType:
                 return '!important';
-            case 'Attr':
+            case exports.EnumToken.AttrTokenType:
                 return '[' + token.chi.reduce(reducer, '') + ']';
-            case 'Time':
-            case 'Angle':
-            case 'Length':
-            case 'Dimension':
-            case 'Frequency':
-            case 'Resolution':
+            case exports.EnumToken.TimeTokenType:
+            case exports.EnumToken.AngleTokenType:
+            case exports.EnumToken.LengthTokenType:
+            case exports.EnumToken.DimensionTokenType:
+            case exports.EnumToken.FrequencyTokenType:
+            case exports.EnumToken.ResolutionTokenType:
+                if (token.val.typ == exports.EnumToken.BinaryExpressionTokenType) {
+                    const result = renderToken(token.val, options, cache);
+                    if (!('unit' in token)) {
+                        return result;
+                    }
+                    if (!result.includes(' ')) {
+                        return result + token.unit;
+                    }
+                    return `(${result})*1${token.unit}`;
+                }
                 let val = reduceNumber(token.val);
                 let unit = token.unit;
-                if (token.typ == 'Angle') {
+                if (token.typ == exports.EnumToken.AngleTokenType) {
                     const angle = getAngle(token);
                     let v;
                     let value = val + unit;
@@ -758,36 +1031,58 @@
                     }
                 }
                 if (val === '0') {
-                    if (token.typ == 'Time') {
+                    if (token.typ == exports.EnumToken.TimeTokenType) {
                         return '0s';
                     }
-                    if (token.typ == 'Frequency') {
+                    if (token.typ == exports.EnumToken.FrequencyTokenType) {
                         return '0Hz';
                     }
                     // @ts-ignore
-                    if (token.typ == 'Resolution') {
+                    if (token.typ == exports.EnumToken.ResolutionTokenType) {
                         return '0x';
                     }
                     return '0';
                 }
                 return val + unit;
-            case 'Perc':
+            case exports.EnumToken.PercentageTokenType:
                 const perc = reduceNumber(token.val);
                 return options.minify && perc == '0' ? '0' : perc + '%';
-            case 'Number':
+            case exports.EnumToken.NumberTokenType:
                 return reduceNumber(token.val);
-            case 'Comment':
+            case exports.EnumToken.CommentTokenType:
                 if (options.removeComments && (!options.preserveLicense || !token.val.startsWith('/*!'))) {
                     return '';
                 }
-            case 'Url-token':
-            case 'At-rule':
-            case 'Hash':
-            case 'Pseudo-class':
-            case 'Literal':
-            case 'String':
-            case 'Iden':
-            case 'Delim':
+            case exports.EnumToken.UrlTokenTokenType:
+                if (token.typ == exports.EnumToken.UrlTokenTokenType) {
+                    if (options.output != null) {
+                        if (!('original' in token)) {
+                            // do not modify original token
+                            token = { ...token };
+                            Object.defineProperty(token, 'original', { enumerable: false, writable: false, value: token.val });
+                        }
+                        // @ts-ignore
+                        if (!(token.original in cache)) {
+                            let output = options.output ?? '';
+                            const key = output + 'abs';
+                            if (!(key in cache)) {
+                                // @ts-ignore
+                                cache[key] = options.dirname(options.resolve(output, options.cwd).absolute);
+                            }
+                            // @ts-ignore
+                            cache[token.original] = options.resolve(token.original, cache[key]).relative;
+                        }
+                        // @ts-ignore
+                        token.val = cache[token.original];
+                    }
+                }
+            case exports.EnumToken.AtRuleTokenType:
+            case exports.EnumToken.HashTokenType:
+            case exports.EnumToken.PseudoClassTokenType:
+            case exports.EnumToken.LiteralTokenType:
+            case exports.EnumToken.StringTokenType:
+            case exports.EnumToken.IdenTokenType:
+            case exports.EnumToken.DelimTokenType:
                 return /* options.minify && 'Pseudo-class' == token.typ && '::' == token.val.slice(0, 2) ? token.val.slice(1) :  */ token.val;
         }
         errors?.push({ action: 'ignore', message: `render: unexpected token ${JSON.stringify(token, null, 1)}` });
@@ -820,17 +1115,17 @@
         return 'unit' in dimension && ['hz', 'khz'].includes(dimension.unit.toLowerCase());
     }
     function isColor(token) {
-        if (token.typ == 'Color') {
+        if (token.typ == exports.EnumToken.ColorTokenType) {
             return true;
         }
-        if (token.typ == 'Iden') {
+        if (token.typ == exports.EnumToken.IdenTokenType) {
             // named color
             return token.val.toLowerCase() in COLORS_NAMES;
         }
-        if (token.typ == 'Func' && token.chi.length > 0 && colorsFunc.includes(token.val)) {
+        if (token.typ == exports.EnumToken.FunctionTokenType && token.chi.length > 0 && colorsFunc.includes(token.val)) {
             // @ts-ignore
             for (const v of token.chi) {
-                if (!['Number', 'Angle', 'Perc', 'Comma', 'Whitespace', 'Literal'].includes(v.typ)) {
+                if (![exports.EnumToken.NumberTokenType, exports.EnumToken.AngleTokenType, exports.EnumToken.PercentageTokenType, exports.EnumToken.CommaTokenType, exports.EnumToken.WhitespaceTokenType, exports.EnumToken.LiteralTokenType].includes(v.typ)) {
                     return false;
                 }
             }
@@ -999,29 +1294,29 @@
             index++;
             break;
         }
-        const dimension = { typ: 'Dimension', val: name.slice(0, index), unit: name.slice(index) };
+        const dimension = { typ: exports.EnumToken.DimensionTokenType, val: name.slice(0, index), unit: name.slice(index) };
         if (isAngle(dimension)) {
             // @ts-ignore
-            dimension.typ = 'Angle';
+            dimension.typ = exports.EnumToken.AngleTokenType;
         }
         else if (isLength(dimension)) {
             // @ts-ignore
-            dimension.typ = 'Length';
+            dimension.typ = exports.EnumToken.LengthTokenType;
         }
         else if (isTime(dimension)) {
             // @ts-ignore
-            dimension.typ = 'Time';
+            dimension.typ = exports.EnumToken.TimeTokenType;
         }
         else if (isResolution(dimension)) {
             // @ts-ignore
-            dimension.typ = 'Resolution';
+            dimension.typ = exports.EnumToken.ResolutionTokenType;
             if (dimension.unit == 'dppx') {
                 dimension.unit = 'x';
             }
         }
         else if (isFrequency(dimension)) {
             // @ts-ignore
-            dimension.typ = 'Frequency';
+            dimension.typ = exports.EnumToken.FrequencyTokenType;
         }
         return dimension;
     }
@@ -1908,340 +2203,144 @@
 
     const funcList = ['clamp', 'calc'];
     function matchType(val, properties) {
-        if (val.typ == 'Iden' && properties.keywords.includes(val.val) ||
-            (properties.types.includes(val.typ))) {
+        if (val.typ == exports.EnumToken.IdenTokenType && properties.keywords.includes(val.val) ||
+            // @ts-ignore
+            (properties.types.some((t) => exports.EnumToken[t] == val.typ))) {
             return true;
         }
-        if (val.typ == 'Number' && val.val == '0') {
-            return properties.types.some(type => type == 'Length' || type == 'Angle');
+        if (val.typ == exports.EnumToken.NumberTokenType && val.val == '0') {
+            // @ts-ignore
+            return properties.types.some((type) => {
+                // @ts-ignore
+                const typ = exports.EnumToken[type];
+                return typ == exports.EnumToken.LengthTokenType || typ == exports.EnumToken.AngleTokenType;
+            });
         }
-        if (val.typ == 'Func' && funcList.includes(val.val)) {
-            return val.chi.every((t => ['Literal', 'Comma', 'Whitespace', 'Start-parens', 'End-parens'].includes(t.typ) || matchType(t, properties)));
+        if (val.typ == exports.EnumToken.FunctionTokenType && funcList.includes(val.val)) {
+            return val.chi.every((t => [exports.EnumToken.LiteralTokenType, exports.EnumToken.CommaTokenType, exports.EnumToken.WhitespaceTokenType, exports.EnumToken.StartParensTokenType, exports.EnumToken.EndParensTokenType].includes(t.typ) || matchType(t, properties)));
         }
         return false;
     }
 
-    function eq(a, b) {
-        if (a == null || b == null) {
-            return a == b;
-        }
-        if (typeof a != 'object' || typeof b != 'object') {
-            return a === b;
-        }
-        if (Object.getPrototypeOf(a) !== Object.getPrototypeOf(b)) {
-            return false;
-        }
-        if (Array.isArray(a)) {
-            if (a.length != b.length) {
-                return false;
-            }
-            let i = 0;
-            for (; i < a.length; i++) {
-                if (!eq(a[i], b[i])) {
-                    return false;
-                }
-            }
-            return true;
-        }
-        const k1 = Object.keys(a);
-        const k2 = Object.keys(b);
-        if (k1.length != k2.length) {
-            return false;
-        }
-        let key;
-        for (key of k1) {
-            if (!(key in b) || !eq(a[key], b[key])) {
-                return false;
+    function* tokenize(stream) {
+        let ind = -1;
+        let lin = 1;
+        let col = 0;
+        const position = {
+            ind: Math.max(ind, 0),
+            lin: lin,
+            col: Math.max(col, 1)
+        };
+        let value;
+        let buffer = '';
+        // let input: string = '';
+        function consumeWhiteSpace() {
+            let count = 0;
+            while (isWhiteSpace(stream.charAt(count + ind + 1).charCodeAt(0))) {
+                count++;
             }
+            next(count);
+            return count;
         }
-        return true;
-    }
-
-    class PropertySet {
-        config;
-        declarations;
-        constructor(config) {
-            this.config = config;
-            this.declarations = new Map;
+        function pushToken(token, hint) {
+            const result = { token, hint, position: { ...position }, bytesIn: ind };
+            position.ind = ind;
+            position.lin = lin;
+            position.col = col == 0 ? 1 : col;
+            return result;
         }
-        add(declaration) {
-            if (declaration.nam == this.config.shorthand) {
-                this.declarations = new Map;
+        function* consumeString(quoteStr) {
+            const quote = quoteStr;
+            let value;
+            let hasNewLine = false;
+            if (buffer.length > 0) {
+                yield pushToken(buffer);
+                buffer = '';
             }
-            else {
-                // expand shorthand
-                if (declaration.nam != this.config.shorthand && this.declarations.has(this.config.shorthand)) {
-                    let isValid = true;
-                    let current = -1;
-                    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' &&
-                            (this.config.types.includes('Length') ||
-                                this.config.types.includes('Angle') ||
-                                this.config.types.includes('Dimension')))) {
-                            if (tokens.length == 0) {
-                                tokens.push([]);
-                                current++;
+            buffer += quoteStr;
+            while (value = peek()) {
+                if (value == '\\') {
+                    const sequence = peek(6);
+                    let escapeSequence = '';
+                    let codepoint;
+                    let i;
+                    for (i = 1; i < sequence.length; i++) {
+                        codepoint = sequence.charCodeAt(i);
+                        if (codepoint == 0x20 ||
+                            (codepoint >= 0x61 && codepoint <= 0x66) ||
+                            (codepoint >= 0x41 && codepoint <= 0x46) ||
+                            (codepoint >= 0x30 && codepoint <= 0x39)) {
+                            escapeSequence += sequence[i];
+                            if (codepoint == 0x20) {
+                                break;
                             }
-                            tokens[current].push(token);
                             continue;
                         }
-                        if (token.typ != 'Whitespace' && token.typ != 'Comment') {
-                            if (token.typ == 'Iden' && 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) {
-                                tokens.push([]);
-                                current++;
-                                continue;
-                            }
-                            isValid = false;
-                            break;
-                        }
+                        break;
                     }
-                    if (isValid && tokens.length > 0) {
-                        this.declarations.delete(this.config.shorthand);
-                        for (const values of tokens) {
-                            this.config.properties.forEach((property, index) => {
-                                if (!this.declarations.has(property)) {
-                                    this.declarations.set(property, {
-                                        typ: 'Declaration',
-                                        nam: property,
-                                        val: []
-                                    });
-                                }
-                                while (index > 0 && index >= values.length) {
-                                    if (index > 1) {
-                                        index %= 2;
-                                    }
-                                    else {
-                                        index = 0;
-                                        break;
-                                    }
-                                }
-                                // @ts-ignore
-                                const val = this.declarations.get(property).val;
-                                if (val.length > 0) {
-                                    val.push({ typ: 'Whitespace' });
-                                }
-                                val.push({ ...values[index] });
-                            });
+                    if (i == 1) {
+                        buffer += value + sequence[i];
+                        next(2);
+                        continue;
+                    }
+                    if (escapeSequence.trimEnd().length > 0) {
+                        const codepoint = Number(`0x${escapeSequence.trimEnd()}`);
+                        if (codepoint == 0 ||
+                            // leading surrogate
+                            (0xD800 <= codepoint && codepoint <= 0xDBFF) ||
+                            // trailing surrogate
+                            (0xDC00 <= codepoint && codepoint <= 0xDFFF)) {
+                            buffer += String.fromCodePoint(0xFFFD);
                         }
+                        else {
+                            buffer += String.fromCodePoint(codepoint);
+                        }
+                        next(escapeSequence.length + 1 + (isWhiteSpace(peek()?.charCodeAt(0)) ? 1 : 0));
+                        continue;
                     }
-                    this.declarations.set(declaration.nam, declaration);
-                    return this;
+                    buffer += next(2);
+                    continue;
+                }
+                if (value == quote) {
+                    buffer += value;
+                    yield pushToken(buffer, hasNewLine ? exports.EnumToken.BadStringTokenType : exports.EnumToken.StringTokenType);
+                    next();
+                    // i += value.length;
+                    buffer = '';
+                    return;
+                }
+                if (isNewLine(value.charCodeAt(0))) {
+                    hasNewLine = true;
+                }
+                if (hasNewLine && value == ';') {
+                    yield pushToken(buffer + value, exports.EnumToken.BadStringTokenType);
+                    buffer = '';
+                    next();
+                    break;
                 }
-            }
-            this.declarations.set(declaration.nam, declaration);
-            return this;
-        }
-        isShortHand() {
-            if (this.declarations.has(this.config.shorthand)) {
-                return this.declarations.size == 1;
-            }
-            return this.config.properties.length == this.declarations.size;
-        }
-        [Symbol.iterator]() {
-            let iterator;
-            const declarations = this.declarations;
-            if (declarations.size < this.config.properties.length) {
-                iterator = declarations.values();
-            }
-            else {
-                const values = [];
-                this.config.properties.forEach((property) => {
-                    let index = 0;
-                    // @ts-ignore
-                    for (const token of this.declarations.get(property).val) {
-                        if (token.typ == 'Whitespace') {
-                            continue;
-                        }
-                        if (values.length == index) {
-                            values.push([]);
-                        }
-                        values[index].push(token);
-                        index++;
-                    }
-                });
-                for (const value of values) {
-                    let i = value.length;
-                    while (i-- > 1) {
-                        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)) ||
-                                (isLength(k) || isLength(t))) {
-                                value.splice(i, 1);
-                                continue;
-                            }
-                        }
-                        if (eq(t, k)) {
-                            value.splice(i, 1);
-                            continue;
-                        }
-                        break;
-                    }
-                }
-                iterator = [{
-                        typ: 'Declaration',
-                        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' });
-                                    i += 2;
-                                }
-                            }
-                            if (acc.length > 0) {
-                                acc.push({ typ: 'Literal', val: this.config.separator });
-                            }
-                            acc.push(...curr);
-                            return acc;
-                        }, [])
-                    }][Symbol.iterator]();
-                // return {
-                //     next() {
-                //
-                //         return iterator.next();
-                //     }
-                // }
-            }
-            return iterator;
-            // return {
-            //     next() {
-            //
-            //         return iterator.next();
-            //     }
-            // }
-        }
-    }
-
-    function* tokenize(iterator) {
-        let ind = -1;
-        let lin = 1;
-        let col = 0;
-        const position = {
-            ind: Math.max(ind, 0),
-            lin: lin,
-            col: Math.max(col, 1)
-        };
-        let value;
-        let buffer = '';
-        function consumeWhiteSpace() {
-            let count = 0;
-            while (isWhiteSpace(iterator.charAt(count + ind + 1).charCodeAt(0))) {
-                count++;
-            }
-            next(count);
-            return count;
-        }
-        function pushToken(token, hint) {
-            const result = { token, hint, position: { ...position }, bytesIn: ind };
-            position.ind = ind;
-            position.lin = lin;
-            position.col = col == 0 ? 1 : col;
-            return result;
-        }
-        function* consumeString(quoteStr) {
-            const quote = quoteStr;
-            let value;
-            let hasNewLine = false;
-            if (buffer.length > 0) {
-                yield pushToken(buffer);
-                buffer = '';
-            }
-            buffer += quoteStr;
-            while (value = peek()) {
-                if (value == '\\') {
-                    const sequence = peek(6);
-                    let escapeSequence = '';
-                    let codepoint;
-                    let i;
-                    for (i = 1; i < sequence.length; i++) {
-                        codepoint = sequence.charCodeAt(i);
-                        if (codepoint == 0x20 ||
-                            (codepoint >= 0x61 && codepoint <= 0x66) ||
-                            (codepoint >= 0x41 && codepoint <= 0x46) ||
-                            (codepoint >= 0x30 && codepoint <= 0x39)) {
-                            escapeSequence += sequence[i];
-                            if (codepoint == 0x20) {
-                                break;
-                            }
-                            continue;
-                        }
-                        break;
-                    }
-                    if (i == 1) {
-                        buffer += value + sequence[i];
-                        next(2);
-                        continue;
-                    }
-                    if (escapeSequence.trimEnd().length > 0) {
-                        const codepoint = Number(`0x${escapeSequence.trimEnd()}`);
-                        if (codepoint == 0 ||
-                            // leading surrogate
-                            (0xD800 <= codepoint && codepoint <= 0xDBFF) ||
-                            // trailing surrogate
-                            (0xDC00 <= codepoint && codepoint <= 0xDFFF)) {
-                            buffer += String.fromCodePoint(0xFFFD);
-                        }
-                        else {
-                            buffer += String.fromCodePoint(codepoint);
-                        }
-                        next(escapeSequence.length + 1 + (isWhiteSpace(peek()?.charCodeAt(0)) ? 1 : 0));
-                        continue;
-                    }
-                    buffer += next(2);
-                    continue;
-                }
-                if (value == quote) {
-                    buffer += value;
-                    yield pushToken(buffer, hasNewLine ? 'Bad-string' : 'String');
-                    next();
-                    // i += value.length;
-                    buffer = '';
-                    return;
-                }
-                if (isNewLine(value.charCodeAt(0))) {
-                    hasNewLine = true;
-                }
-                if (hasNewLine && value == ';') {
-                    yield pushToken(buffer + value, 'Bad-string');
-                    buffer = '';
-                    next();
-                    break;
-                }
-                buffer += value;
-                next();
+                buffer += value;
+                next();
             }
             if (hasNewLine) {
-                yield pushToken(buffer, 'Bad-string');
+                yield pushToken(buffer, exports.EnumToken.BadStringTokenType);
             }
             else {
                 // EOF - 'Unclosed-string' fixed
-                yield pushToken(buffer + quote, 'String');
+                yield pushToken(buffer + quote, exports.EnumToken.StringTokenType);
             }
             buffer = '';
         }
         function peek(count = 1) {
             if (count == 1) {
-                return iterator.charAt(ind + 1);
+                return stream.charAt(ind + 1);
             }
-            return iterator.slice(ind + 1, ind + count + 1);
+            return stream.slice(ind + 1, ind + count + 1);
         }
         function prev(count = 1) {
             if (count == 1) {
-                return ind == 0 ? '' : iterator.charAt(ind - 1);
+                return ind == 0 ? '' : stream.charAt(ind - 1);
             }
-            return iterator.slice(ind - 1 - count, ind - 1);
+            return stream.slice(ind - 1 - count, ind - 1);
         }
         function next(count = 1) {
             let char = '';
@@ -2249,9 +2348,9 @@
             if (count < 0) {
                 return '';
             }
-            while (count-- && (chr = iterator.charAt(ind + 1))) {
+            while (count-- && (chr = stream.charAt(ind + 1))) {
                 char += chr;
-                const codepoint = iterator.charCodeAt(++ind);
+                const codepoint = stream.charCodeAt(++ind);
                 if (isNaN(codepoint)) {
                     return char;
                 }
@@ -2276,7 +2375,7 @@
                         break;
                     }
                 }
-                yield pushToken('', 'Whitespace');
+                yield pushToken('', exports.EnumToken.WhitespaceTokenType);
                 buffer = '';
             }
             switch (value) {
@@ -2296,7 +2395,7 @@
                             if (value == '*') {
                                 buffer += value;
                                 if (peek() == '/') {
-                                    yield pushToken(buffer + next(), 'Comment');
+                                    yield pushToken(buffer + next(), exports.EnumToken.CommentTokenType);
                                     buffer = '';
                                     break;
                                 }
@@ -2305,7 +2404,7 @@
                                 buffer += value;
                             }
                         }
-                        yield pushToken(buffer, 'Bad-comment');
+                        yield pushToken(buffer, exports.EnumToken.BadCommentTokenType);
                         buffer = '';
                     }
                     break;
@@ -2315,7 +2414,7 @@
                         buffer = '';
                     }
                     if (peek() == '=') {
-                        yield pushToken('', 'Lte');
+                        yield pushToken('', exports.EnumToken.LteTokenType);
                         next();
                         break;
                     }
@@ -2329,10 +2428,10 @@
                             }
                         }
                         if (value === '') {
-                            yield pushToken(buffer, 'Bad-cdo');
+                            yield pushToken(buffer, exports.EnumToken.BadCdoTokenType);
                         }
                         else {
-                            yield pushToken(buffer + next(2), 'CDOCOMM');
+                            yield pushToken(buffer + next(2), exports.EnumToken.CDOCOMMTokenType);
                         }
                         buffer = '';
                     }
@@ -2365,7 +2464,7 @@
                     }
                     if (value == '=') {
                         buffer += value;
-                        yield pushToken(buffer, buffer[0] == '~' ? 'Includes' : 'Dash-matches');
+                        yield pushToken(buffer, buffer[0] == '~' ? exports.EnumToken.IncludesTokenType : exports.EnumToken.DashMatchTokenType);
                         buffer = '';
                         break;
                     }
@@ -2381,11 +2480,11 @@
                         buffer = '';
                     }
                     if (peek() == '=') {
-                        yield pushToken('', 'Gte');
+                        yield pushToken('', exports.EnumToken.GteTokenType);
                         next();
                     }
                     else {
-                        yield pushToken('', 'Gt');
+                        yield pushToken('', exports.EnumToken.GtTokenType);
                     }
                     consumeWhiteSpace();
                     break;
@@ -2399,6 +2498,7 @@
                     buffer += value;
                     break;
                 case '+':
+                case '*':
                 case ':':
                 case ',':
                 case '=':
@@ -2412,7 +2512,7 @@
                     }
                     yield pushToken(value);
                     buffer = '';
-                    if (value == '+' && isWhiteSpace(peek().charCodeAt(0))) {
+                    if (['+', '*', '/'].includes(value) && isWhiteSpace(peek().charCodeAt(0))) {
                         yield pushToken(next());
                     }
                     while (isWhiteSpace(peek().charCodeAt(0))) {
@@ -2424,7 +2524,7 @@
                         yield pushToken(buffer);
                         buffer = '';
                     }
-                    yield pushToken('', 'End-parens');
+                    yield pushToken('', exports.EnumToken.EndParensTokenType);
                     break;
                 case '(':
                     if (buffer.length == 0) {
@@ -2462,7 +2562,7 @@
                                             }
                                         }
                                         if (value === '') {
-                                            yield pushToken(buffer, 'Bad-string');
+                                            yield pushToken(buffer, exports.EnumToken.BadUrlTokenType);
                                             buffer = '';
                                             break;
                                         }
@@ -2489,7 +2589,7 @@
                                             break;
                                         }
                                         if (!(value = next())) {
-                                            yield pushToken(buffer, hasNewLine ? 'Bad-url-token' : 'Url-token');
+                                            yield pushToken(buffer, hasNewLine ? exports.EnumToken.BadUrlTokenType : exports.EnumToken.UrlTokenTokenType);
                                             buffer = '';
                                             break;
                                         }
@@ -2497,8 +2597,8 @@
                                     cp = value.charCodeAt(0);
                                     // ')'
                                     if (cp == 0x29) {
-                                        yield pushToken(buffer, hasNewLine ? 'Bad-string' : 'String');
-                                        yield pushToken('', 'End-parens');
+                                        yield pushToken(buffer, hasNewLine ? exports.EnumToken.BadStringTokenType : exports.EnumToken.StringTokenType);
+                                        yield pushToken('', exports.EnumToken.EndParensTokenType);
                                         buffer = '';
                                         break;
                                     }
@@ -2509,15 +2609,15 @@
                                             continue;
                                         }
                                         if (cp == 0x29) {
-                                            yield pushToken(buffer, 'Bad-string');
-                                            yield pushToken('', 'End-parens');
+                                            yield pushToken(buffer, exports.EnumToken.BadStringTokenType);
+                                            yield pushToken('', exports.EnumToken.EndParensTokenType);
                                             buffer = '';
                                             break;
                                         }
                                         buffer += value;
                                     }
                                     if (hasNewLine) {
-                                        yield pushToken(buffer, 'Bad-string');
+                                        yield pushToken(buffer, exports.EnumToken.BadStringTokenType);
                                         buffer = '';
                                     }
                                     break;
@@ -2532,8 +2632,8 @@
                                 cp = value.charCodeAt(0);
                                 // ')'
                                 if (cp == 0x29) {
-                                    yield pushToken(buffer, 'Url-token');
-                                    yield pushToken('', 'End-parens');
+                                    yield pushToken(buffer, exports.EnumToken.UrlTokenTokenType);
+                                    yield pushToken('', exports.EnumToken.EndParensTokenType);
                                     buffer = '';
                                     break;
                                 }
@@ -2569,7 +2669,7 @@
                                         }
                                         buffer += next();
                                     }
-                                    yield pushToken(buffer, 'Bad-url-token');
+                                    yield pushToken(buffer, exports.EnumToken.BadUrlTokenType);
                                     buffer = '';
                                     break;
                                 }
@@ -2577,7 +2677,7 @@
                             }
                         }
                         if (buffer !== '') {
-                            yield pushToken(buffer, 'Url-token');
+                            yield pushToken(buffer, exports.EnumToken.UrlTokenTokenType);
                             buffer = '';
                             break;
                         }
@@ -2603,7 +2703,7 @@
                         buffer = '';
                     }
                     if (peek(9) == 'important') {
-                        yield pushToken('', 'Important');
+                        yield pushToken('', exports.EnumToken.ImportantTokenType);
                         next(9);
                         buffer = '';
                         break;
@@ -2622,33 +2722,40 @@
     }
 
     const urlTokenMatcher = /^(["']?)[a-zA-Z0-9_/.-][a-zA-Z0-9_/:.#?-]+(\1)$/;
-    const trimWhiteSpace = ['Gt', 'Gte', 'Lt', 'Lte'];
-    const funcLike = ['Start-parens', 'Func', 'UrlFunc', 'Pseudo-class-func'];
-    /**
-     *
-     * @param iterator
-     * @param opt
-     */
-    async function parse$1(iterator, opt = {}) {
-        const startTime = performance.now();
-        const errors = [];
-        const options = {
+    const trimWhiteSpace = [exports.EnumToken.GtTokenType, exports.EnumToken.GteTokenType, exports.EnumToken.LtTokenType, exports.EnumToken.LteTokenType];
+    const funcLike = [exports.EnumToken.ParensTokenType, exports.EnumToken.StartParensTokenType, exports.EnumToken.FunctionTokenType, exports.EnumToken.UrlFunctionTokenType, exports.EnumToken.PseudoClassFuncTokenType];
+    const BadTokensTypes = [exports.EnumToken.BadCommentTokenType,
+        exports.EnumToken.BadCdoTokenType,
+        exports.EnumToken.BadUrlTokenType,
+        exports.EnumToken.BadStringTokenType];
+    async function doParse(iterator, options = {}) {
+        options = {
             src: '',
             sourcemap: false,
             minify: true,
             nestingRules: false,
             resolveImport: false,
             resolveUrls: false,
+            removeCharset: false,
             removeEmpty: true,
-            ...opt
+            removeDuplicateDeclarations: true,
+            computeShorthand: true,
+            computeCalcExpression: true,
+            inlineCssVariables: false,
+            ...options
         };
+        if (options.expandNestingRules) {
+            options.nestingRules = false;
+        }
         if (options.resolveImport) {
             options.resolveUrls = true;
         }
+        const startTime = performance.now();
+        const errors = [];
         const src = options.src;
         const stack = [];
-        const ast = {
-            typ: "StyleSheet",
+        let ast = {
+            typ: 2 /* NodeType.StyleSheetNodeType */,
             chi: []
         };
         let tokens = [];
@@ -2670,10 +2777,14 @@
             let i;
             let loc;
             for (i = 0; i < tokens.length; i++) {
-                if (tokens[i].typ == 'Comment' || tokens[i].typ == 'CDOCOMM') {
+                if (tokens[i].typ == exports.EnumToken.CommentTokenType || tokens[i].typ == exports.EnumToken.CDOCOMMTokenType) {
                     const position = map.get(tokens[i]);
-                    if (tokens[i].typ == 'CDOCOMM' && context.typ != 'StyleSheet') {
-                        errors.push({ action: 'drop', message: `CDOCOMM not allowed here ${JSON.stringify(tokens[i], null, 1)}`, location: { src, ...position } });
+                    if (tokens[i].typ == exports.EnumToken.CDOCOMMTokenType && context.typ != 2 /* NodeType.StyleSheetNodeType */) {
+                        errors.push({
+                            action: 'drop',
+                            message: `CDOCOMM not allowed here ${JSON.stringify(tokens[i], null, 1)}`,
+                            location: { src, ...position }
+                        });
                         continue;
                     }
                     loc = {
@@ -2686,7 +2797,7 @@
                         tokens[i].loc = loc;
                     }
                 }
-                else if (tokens[i].typ != 'Whitespace') {
+                else if (tokens[i].typ != exports.EnumToken.WhitespaceTokenType) {
                     break;
                 }
             }
@@ -2695,28 +2806,33 @@
                 return null;
             }
             let delim = tokens.at(-1);
-            if (delim.typ == 'Semi-colon' || delim.typ == 'Block-start' || delim.typ == 'Block-end') {
+            if (delim.typ == exports.EnumToken.SemiColonTokenType || delim.typ == exports.EnumToken.BlockStartTokenType || delim.typ == exports.EnumToken.BlockEndTokenType) {
                 tokens.pop();
             }
             else {
-                delim = { typ: 'Semi-colon' };
+                delim = { typ: exports.EnumToken.SemiColonTokenType };
             }
             // @ts-ignore
-            while (['Whitespace', 'Bad-string', 'Bad-comment'].includes(tokens.at(-1)?.typ)) {
+            while ([exports.EnumToken.WhitespaceTokenType, exports.EnumToken.BadStringTokenType, exports.EnumToken.BadCommentTokenType].includes(tokens.at(-1)?.typ)) {
                 tokens.pop();
             }
             if (tokens.length == 0) {
                 return null;
             }
-            if (tokens[0]?.typ == 'At-rule') {
+            if (tokens[0]?.typ == exports.EnumToken.AtRuleTokenType) {
                 const atRule = tokens.shift();
                 const position = map.get(atRule);
-                if (atRule.val == 'charset' && position.ind > 0) {
-                    errors.push({ action: 'drop', message: 'parse: invalid @charset', location: { src, ...position } });
-                    return null;
+                if (atRule.val == 'charset') {
+                    if (position.ind > 0) {
+                        errors.push({ action: 'drop', message: 'doParse: invalid @charset', location: { src, ...position } });
+                        return null;
+                    }
+                    if (options.removeCharset) {
+                        return null;
+                    }
                 }
                 // @ts-ignore
-                while (['Whitespace'].includes(tokens[0]?.typ)) {
+                while ([exports.EnumToken.WhitespaceTokenType].includes(tokens[0]?.typ)) {
                     tokens.shift();
                 }
                 if (atRule.val == 'import') {
@@ -2725,10 +2841,10 @@
                         let i = context.chi.length;
                         while (i--) {
                             const type = context.chi[i].typ;
-                            if (type == 'Comment') {
+                            if (type == 0 /* NodeType.CommentNodeType */) {
                                 continue;
                             }
-                            if (type != 'AtRule') {
+                            if (type != 3 /* NodeType.AtRuleNodeType */) {
                                 errors.push({ action: 'drop', message: 'invalid @import', location: { src, ...position } });
                                 return null;
                             }
@@ -2741,33 +2857,33 @@
                         }
                     }
                     // @ts-ignore
-                    if (tokens[0]?.typ != 'String' && tokens[0]?.typ != 'UrlFunc') {
-                        errors.push({ action: 'drop', message: 'parse: invalid @import', location: { src, ...position } });
+                    if (tokens[0]?.typ != exports.EnumToken.StringTokenType && tokens[0]?.typ != exports.EnumToken.UrlFunctionTokenType) {
+                        errors.push({ action: 'drop', message: 'doParse: invalid @import', location: { src, ...position } });
                         return null;
                     }
                     // @ts-ignore
-                    if (tokens[0].typ == 'UrlFunc' && tokens[1]?.typ != 'Url-token' && tokens[1]?.typ != 'String') {
-                        errors.push({ action: 'drop', message: 'parse: invalid @import', location: { src, ...position } });
+                    if (tokens[0].typ == exports.EnumToken.UrlFunctionTokenType && tokens[1]?.typ != exports.EnumToken.UrlTokenTokenType && tokens[1]?.typ != exports.EnumToken.StringTokenType) {
+                        errors.push({ action: 'drop', message: 'doParse: invalid @import', location: { src, ...position } });
                         return null;
                     }
                 }
                 if (atRule.val == 'import') {
                     // @ts-ignore
-                    if (tokens[0].typ == 'UrlFunc' && tokens[1].typ == 'Url-token') {
+                    if (tokens[0].typ == exports.EnumToken.UrlFunctionTokenType && tokens[1].typ == exports.EnumToken.UrlTokenTokenType) {
                         tokens.shift();
                         // @ts-ignore
-                        tokens[0].typ = 'String';
+                        tokens[0].typ = exports.EnumToken.StringTokenType;
                         // @ts-ignore
                         tokens[0].val = `"${tokens[0].val}"`;
                     }
                     // @ts-ignore
-                    if (tokens[0].typ == 'String') {
+                    if (tokens[0].typ == exports.EnumToken.StringTokenType) {
                         if (options.resolveImport) {
                             const url = tokens[0].val.slice(1, -1);
                             try {
                                 // @ts-ignore
                                 const root = await options.load(url, options.src).then((src) => {
-                                    return parse$1(src, Object.assign({}, options, {
+                                    return doParse(src, Object.assign({}, options, {
                                         minify: false,
                                         // @ts-ignore
                                         src: options.resolve(url, options.src).absolute
@@ -2775,6 +2891,7 @@
                                 });
                                 bytesIn += root.stats.bytesIn;
                                 if (root.ast.chi.length > 0) {
+                                    // @todo - filter charset, layer and scope
                                     context.chi.push(...root.ast.chi);
                                 }
                                 if (root.errors.length > 0) {
@@ -2784,7 +2901,7 @@
                             }
                             catch (error) {
                                 // @ts-ignore
-                                errors.push({ action: 'ignore', message: 'parse: ' + error.message, error });
+                                errors.push({ action: 'ignore', message: 'doParse: ' + error.message, error });
                             }
                         }
                     }
@@ -2797,12 +2914,12 @@
                     return acc;
                 }, []);
                 const node = {
-                    typ: 'AtRule',
+                    typ: 3 /* NodeType.AtRuleNodeType */,
                     nam: renderToken(atRule, { removeComments: true }),
                     val: raw.join('')
                 };
                 Object.defineProperty(node, 'raw', { enumerable: false, configurable: true, writable: true, value: raw });
-                if (delim.typ == 'Block-start') {
+                if (delim.typ == exports.EnumToken.BlockStartTokenType) {
                     node.chi = [];
                 }
                 loc = {
@@ -2814,15 +2931,15 @@
                 }
                 // @ts-ignore
                 context.chi.push(node);
-                return delim.typ == 'Block-start' ? node : null;
+                return delim.typ == exports.EnumToken.BlockStartTokenType ? node : null;
             }
             else {
                 // rule
-                if (delim.typ == 'Block-start') {
+                if (delim.typ == exports.EnumToken.BlockStartTokenType) {
                     const position = map.get(tokens[0]);
                     const uniq = new Map;
                     parseTokens(tokens, { minify: true }).reduce((acc, curr, index, array) => {
-                        if (curr.typ == 'Whitespace') {
+                        if (curr.typ == exports.EnumToken.WhitespaceTokenType) {
                             if (trimWhiteSpace.includes(array[index - 1]?.typ) ||
                                 trimWhiteSpace.includes(array[index + 1]?.typ) ||
                                 combinators.includes(array[index - 1]?.val) ||
@@ -2843,7 +2960,7 @@
                         return acc;
                     }, uniq);
                     const node = {
-                        typ: 'Rule',
+                        typ: 4 /* NodeType.RuleNodeType */,
                         // @ts-ignore
                         sel: [...uniq.keys()].join(','),
                         chi: []
@@ -2868,10 +2985,10 @@
                     // @ts-ignore
                     let value = null;
                     for (let i = 0; i < tokens.length; i++) {
-                        if (tokens[i].typ == 'Comment') {
+                        if (tokens[i].typ == exports.EnumToken.CommentTokenType) {
                             continue;
                         }
-                        if (tokens[i].typ == 'Colon') {
+                        if (tokens[i].typ == exports.EnumToken.ColonTokenType) {
                             name = tokens.slice(0, i);
                             value = parseTokens(tokens.slice(i + 1), {
                                 parseColor: true,
@@ -2888,46 +3005,38 @@
                     const position = map.get(name[0]);
                     if (name.length > 0) {
                         for (let i = 1; i < name.length; i++) {
-                            if (name[i].typ != 'Whitespace' && name[i].typ != 'Comment') {
+                            if (name[i].typ != exports.EnumToken.WhitespaceTokenType && name[i].typ != exports.EnumToken.CommentTokenType) {
                                 errors.push({
                                     action: 'drop',
-                                    message: 'parse: invalid declaration',
+                                    message: 'doParse: invalid declaration',
                                     location: { src, ...position }
                                 });
                                 return null;
                             }
                         }
                     }
-                    if (value == null) {
-                        errors.push({
-                            action: 'drop',
-                            message: 'parse: invalid declaration',
-                            location: { src, ...position }
-                        });
-                        return null;
-                    }
-                    if (value.length == 0) {
+                    if (value == null || value.length == 0) {
                         errors.push({
                             action: 'drop',
-                            message: 'parse: invalid declaration',
+                            message: 'doParse: invalid declaration',
                             location: { src, ...position }
                         });
                         return null;
                     }
                     const node = {
-                        typ: 'Declaration',
+                        typ: 5 /* NodeType.DeclarationNodeType */,
                         // @ts-ignore
                         nam: renderToken(name.shift(), { removeComments: true }),
                         // @ts-ignore
                         val: value
                     };
-                    while (node.val[0]?.typ == 'Whitespace') {
+                    while (node.val[0]?.typ == exports.EnumToken.WhitespaceTokenType) {
                         node.val.shift();
                     }
                     if (node.val.length == 0) {
                         errors.push({
                             action: 'drop',
-                            message: 'parse: invalid declaration',
+                            message: 'doParse: invalid declaration',
                             location: { src, ...position }
                         });
                         return null;
@@ -2947,8 +3056,8 @@
         let item;
         while (item = iter.next().value) {
             bytesIn = item.bytesIn;
-            // parse error
-            if (item.hint != null && item.hint.startsWith('Bad-')) {
+            // doParse error
+            if (item.hint != null && BadTokensTypes.includes(item.hint)) {
                 // bad token
                 continue;
             }
@@ -3008,9 +3117,12 @@
             break;
         }
         const endParseTime = performance.now();
+        if (options.expandNestingRules) {
+            ast = expand(ast);
+        }
         if (options.minify) {
             if (ast.chi.length > 0) {
-                minify(ast, options, true, errors);
+                minify(ast, options, true, errors, false);
             }
         }
         const endTime = performance.now();
@@ -3040,81 +3152,81 @@
         }
         if (hint != null) {
             return ([
-                'Whitespace', 'Semi-colon', 'Colon', 'Block-start',
-                'Block-start', 'Attr-start', 'Attr-end', 'Start-parens', 'End-parens',
-                'Comma', 'Gt', 'Lt', 'Gte', 'Lte', 'EOF'
+                exports.EnumToken.WhitespaceTokenType, exports.EnumToken.SemiColonTokenType, exports.EnumToken.ColonTokenType, exports.EnumToken.BlockStartTokenType,
+                exports.EnumToken.BlockStartTokenType, exports.EnumToken.AttrStartTokenType, exports.EnumToken.AttrEndTokenType, exports.EnumToken.StartParensTokenType, exports.EnumToken.EndParensTokenType,
+                exports.EnumToken.CommaTokenType, exports.EnumToken.GtTokenType, exports.EnumToken.LtTokenType, exports.EnumToken.GteTokenType, exports.EnumToken.LteTokenType, exports.EnumToken.EOFTokenType
             ].includes(hint) ? { typ: hint } : { typ: hint, val });
         }
         if (val == ' ') {
-            return { typ: 'Whitespace' };
+            return { typ: exports.EnumToken.WhitespaceTokenType };
         }
         if (val == ';') {
-            return { typ: 'Semi-colon' };
+            return { typ: exports.EnumToken.SemiColonTokenType };
         }
         if (val == '{') {
-            return { typ: 'Block-start' };
+            return { typ: exports.EnumToken.BlockStartTokenType };
         }
         if (val == '}') {
-            return { typ: 'Block-end' };
+            return { typ: exports.EnumToken.BlockEndTokenType };
         }
         if (val == '[') {
-            return { typ: 'Attr-start' };
+            return { typ: exports.EnumToken.AttrStartTokenType };
         }
         if (val == ']') {
-            return { typ: 'Attr-end' };
+            return { typ: exports.EnumToken.AttrEndTokenType };
         }
         if (val == ':') {
-            return { typ: 'Colon' };
+            return { typ: exports.EnumToken.ColonTokenType };
         }
         if (val == ')') {
-            return { typ: 'End-parens' };
+            return { typ: exports.EnumToken.EndParensTokenType };
         }
         if (val == '(') {
-            return { typ: 'Start-parens' };
+            return { typ: exports.EnumToken.StartParensTokenType };
         }
         if (val == '=') {
-            return { typ: 'Delim', val };
+            return { typ: exports.EnumToken.DelimTokenType, val };
         }
         if (val == ';') {
-            return { typ: 'Semi-colon' };
+            return { typ: exports.EnumToken.SemiColonTokenType };
         }
         if (val == ',') {
-            return { typ: 'Comma' };
+            return { typ: exports.EnumToken.CommaTokenType };
         }
         if (val == '<') {
-            return { typ: 'Lt' };
+            return { typ: exports.EnumToken.LtTokenType };
         }
         if (val == '>') {
-            return { typ: 'Gt' };
+            return { typ: exports.EnumToken.GtTokenType };
         }
         if (isPseudo(val)) {
             return val.endsWith('(') ? {
-                typ: 'Pseudo-class-func',
+                typ: exports.EnumToken.PseudoClassFuncTokenType,
                 val: val.slice(0, -1),
                 chi: []
             }
                 : {
-                    typ: 'Pseudo-class',
+                    typ: exports.EnumToken.PseudoClassTokenType,
                     val
                 };
         }
         if (isAtKeyword(val)) {
             return {
-                typ: 'At-rule',
+                typ: exports.EnumToken.AtRuleTokenType,
                 val: val.slice(1)
             };
         }
         if (isFunction(val)) {
             val = val.slice(0, -1);
             return {
-                typ: val == 'url' ? 'UrlFunc' : 'Func',
+                typ: val == 'url' ? exports.EnumToken.UrlFunctionTokenType : exports.EnumToken.FunctionTokenType,
                 val,
                 chi: []
             };
         }
         if (isNumber(val)) {
             return {
-                typ: 'Number',
+                typ: exports.EnumToken.NumberTokenType,
                 val
             };
         }
@@ -3123,97 +3235,97 @@
         }
         if (isPercentage(val)) {
             return {
-                typ: 'Perc',
+                typ: exports.EnumToken.PercentageTokenType,
                 val: val.slice(0, -1)
             };
         }
         const v = val.toLowerCase();
         if (v == 'currentcolor' || val == 'transparent' || v in COLORS_NAMES) {
             return {
-                typ: 'Color',
+                typ: exports.EnumToken.ColorTokenType,
                 val,
                 kin: 'lit'
             };
         }
         if (isIdent(val)) {
             return {
-                typ: 'Iden',
+                typ: exports.EnumToken.IdenTokenType,
                 val
             };
         }
         if (val.charAt(0) == '#' && isHexColor(val)) {
             return {
-                typ: 'Color',
+                typ: exports.EnumToken.ColorTokenType,
                 val,
                 kin: 'hex'
             };
         }
         if (val.charAt(0) == '#' && isHash(val)) {
             return {
-                typ: 'Hash',
+                typ: exports.EnumToken.HashTokenType,
                 val
             };
         }
         if ('"\''.includes(val.charAt(0))) {
             return {
-                typ: 'Unclosed-string',
+                typ: exports.EnumToken.UnclosedStringTokenType,
                 val
             };
         }
         return {
-            typ: 'Literal',
+            typ: exports.EnumToken.LiteralTokenType,
             val
         };
     }
     function parseTokens(tokens, options = {}) {
         for (let i = 0; i < tokens.length; i++) {
             const t = tokens[i];
-            if (t.typ == 'Whitespace' && ((i == 0 ||
+            if (t.typ == exports.EnumToken.WhitespaceTokenType && ((i == 0 ||
                 i + 1 == tokens.length ||
-                ['Comma', 'Gte', 'Lte'].includes(tokens[i + 1].typ)) ||
+                [exports.EnumToken.CommaTokenType, exports.EnumToken.GteTokenType, exports.EnumToken.LteTokenType].includes(tokens[i + 1].typ)) ||
                 (i > 0 &&
-                    // tokens[i + 1]?.typ != 'Literal' ||
+                    // tokens[i + 1]?.typ != Literal ||
                     // funcLike.includes(tokens[i - 1].typ) &&
                     // !['var', 'calc'].includes((<FunctionToken>tokens[i - 1]).val)))) &&
                     trimWhiteSpace.includes(tokens[i - 1].typ)))) {
                 tokens.splice(i--, 1);
                 continue;
             }
-            if (t.typ == 'Colon') {
+            if (t.typ == exports.EnumToken.ColonTokenType) {
                 const typ = tokens[i + 1]?.typ;
                 if (typ != null) {
-                    if (typ == 'Func') {
+                    if (typ == exports.EnumToken.FunctionTokenType) {
                         tokens[i + 1].val = ':' + tokens[i + 1].val;
-                        tokens[i + 1].typ = 'Pseudo-class-func';
+                        tokens[i + 1].typ = exports.EnumToken.PseudoClassFuncTokenType;
                     }
-                    else if (typ == 'Iden') {
+                    else if (typ == exports.EnumToken.IdenTokenType) {
                         tokens[i + 1].val = ':' + tokens[i + 1].val;
-                        tokens[i + 1].typ = 'Pseudo-class';
+                        tokens[i + 1].typ = exports.EnumToken.PseudoClassTokenType;
                     }
-                    if (typ == 'Func' || typ == 'Iden') {
+                    if (typ == exports.EnumToken.FunctionTokenType || typ == exports.EnumToken.IdenTokenType) {
                         tokens.splice(i, 1);
                         i--;
                         continue;
                     }
                 }
             }
-            if (t.typ == 'Attr-start') {
+            if (t.typ == exports.EnumToken.AttrStartTokenType) {
                 let k = i;
                 let inAttr = 1;
                 while (++k < tokens.length) {
-                    if (tokens[k].typ == 'Attr-end') {
+                    if (tokens[k].typ == exports.EnumToken.AttrEndTokenType) {
                         inAttr--;
                     }
-                    else if (tokens[k].typ == 'Attr-start') {
+                    else if (tokens[k].typ == exports.EnumToken.AttrStartTokenType) {
                         inAttr++;
                     }
                     if (inAttr == 0) {
                         break;
                     }
                 }
-                Object.assign(t, { typ: 'Attr', chi: tokens.splice(i + 1, k - i) });
+                Object.assign(t, { typ: exports.EnumToken.AttrTokenType, chi: tokens.splice(i + 1, k - i) });
                 // @ts-ignore
-                if (t.chi.at(-1).typ == 'Attr-end') {
+                if (t.chi.at(-1).typ == exports.EnumToken.AttrEndTokenType) {
                     // @ts-ignore
                     t.chi.pop();
                     // @ts-ignore
@@ -3224,10 +3336,10 @@
                     }
                     // @ts-ignore
                     t.chi.forEach(val => {
-                        if (val.typ == 'String') {
+                        if (val.typ == exports.EnumToken.StringTokenType) {
                             const slice = val.val.slice(1, -1);
                             if ((slice.charAt(0) != '-' || (slice.charAt(0) == '-' && isIdentStart(slice.charCodeAt(1)))) && isIdent(slice)) {
-                                Object.assign(val, { typ: 'Iden', val: slice });
+                                Object.assign(val, { typ: exports.EnumToken.IdenTokenType, val: slice });
                             }
                         }
                     });
@@ -3238,18 +3350,18 @@
                 let parens = 1;
                 let k = i;
                 while (++k < tokens.length) {
-                    if (tokens[k].typ == 'Colon') {
+                    if (tokens[k].typ == exports.EnumToken.ColonTokenType) {
                         const typ = tokens[k + 1]?.typ;
                         if (typ != null) {
-                            if (typ == 'Iden') {
-                                tokens[k + 1].typ = 'Pseudo-class';
+                            if (typ == exports.EnumToken.IdenTokenType) {
+                                tokens[k + 1].typ = exports.EnumToken.PseudoClassTokenType;
                                 tokens[k + 1].val = ':' + tokens[k + 1].val;
                             }
-                            else if (typ == 'Func') {
-                                tokens[k + 1].typ = 'Pseudo-class-func';
+                            else if (typ == exports.EnumToken.FunctionTokenType) {
+                                tokens[k + 1].typ = exports.EnumToken.PseudoClassFuncTokenType;
                                 tokens[k + 1].val = ':' + tokens[k + 1].val;
                             }
-                            if (typ == 'Func' || typ == 'Iden') {
+                            if (typ == exports.EnumToken.FunctionTokenType || typ == exports.EnumToken.IdenTokenType) {
                                 tokens.splice(k, 1);
                                 k--;
                                 continue;
@@ -3259,7 +3371,7 @@
                     if (funcLike.includes(tokens[k].typ)) {
                         parens++;
                     }
-                    else if (tokens[k].typ == 'End-parens') {
+                    else if (tokens[k].typ == exports.EnumToken.EndParensTokenType) {
                         parens--;
                     }
                     if (parens == 0) {
@@ -3269,29 +3381,55 @@
                 // @ts-ignore
                 t.chi = tokens.splice(i + 1, k - i);
                 // @ts-ignore
-                if (t.chi.at(-1)?.typ == 'End-parens') {
+                if (t.chi.at(-1)?.typ == exports.EnumToken.EndParensTokenType) {
                     // @ts-ignore
                     t.chi.pop();
                 }
+                if (t.typ == exports.EnumToken.FunctionTokenType && t.val == 'calc') {
+                    for (const { value, parent } of walkValues(t.chi)) {
+                        if (value.typ == exports.EnumToken.WhitespaceTokenType) {
+                            const p = (parent ?? t);
+                            for (let i = 0; i < (p).chi.length; i++) {
+                                // @ts-ignore
+                                if (p.chi[i] == value) {
+                                    // @ts-ignore
+                                    (p).chi.splice(i, 1);
+                                    i--;
+                                    break;
+                                }
+                            }
+                        }
+                        else if (value.typ == exports.EnumToken.LiteralTokenType && ['+', '-', '/', '*'].includes(value.val)) {
+                            // @ts-ignore
+                            value.typ = value.val == '+' ? exports.EnumToken.Add : (value.val == '-' ? exports.EnumToken.Sub : (value.val == '*' ? exports.EnumToken.Mul : exports.EnumToken.Div));
+                            // @ts-ignore
+                            delete value.val;
+                        }
+                    }
+                }
+                else if (t.typ == exports.EnumToken.StartParensTokenType) {
+                    // @ts-ignore
+                    t.typ = exports.EnumToken.ParensTokenType;
+                }
                 // @ts-ignore
-                if (options.parseColor && t.typ == 'Func' && isColor(t)) {
+                if (options.parseColor && t.typ == exports.EnumToken.FunctionTokenType && isColor(t)) {
                     // if (isColor) {
                     // @ts-ignore
-                    t.typ = 'Color';
+                    t.typ = exports.EnumToken.ColorTokenType;
                     // @ts-ignore
                     t.kin = t.val;
                     // @ts-ignore
                     let m = t.chi.length;
                     while (m-- > 0) {
                         // @ts-ignore
-                        if (['Literal'].concat(trimWhiteSpace).includes(t.chi[m].typ)) {
+                        if ([exports.EnumToken.LiteralTokenType].concat(trimWhiteSpace).includes(t.chi[m].typ)) {
                             // @ts-ignore
-                            if (t.chi[m + 1]?.typ == 'Whitespace') {
+                            if (t.chi[m + 1]?.typ == exports.EnumToken.WhitespaceTokenType) {
                                 // @ts-ignore
                                 t.chi.splice(m + 1, 1);
                             }
                             // @ts-ignore
-                            if (t.chi[m - 1]?.typ == 'Whitespace') {
+                            if (t.chi[m - 1]?.typ == exports.EnumToken.WhitespaceTokenType) {
                                 // @ts-ignore
                                 t.chi.splice(m - 1, 1);
                                 m--;
@@ -3299,22 +3437,21 @@
                         }
                     }
                     continue;
-                    // }
                 }
-                if (t.typ == 'UrlFunc') {
+                if (t.typ == exports.EnumToken.UrlFunctionTokenType) {
                     // @ts-ignore
-                    if (t.chi[0]?.typ == 'String') {
+                    if (t.chi[0]?.typ == exports.EnumToken.StringTokenType) {
                         // @ts-ignore
                         const value = t.chi[0].val.slice(1, -1);
                         // @ts-ignore
                         if (t.chi[0].val.slice(1, 5) != 'data:' && urlTokenMatcher.test(value)) {
                             // @ts-ignore
-                            t.chi[0].typ = 'Url-token';
+                            t.chi[0].typ = exports.EnumToken.UrlTokenTokenType;
                             // @ts-ignore
                             t.chi[0].val = options.src !== '' && options.resolveUrls ? options.resolve(value, options.src).absolute : value;
                         }
                     }
-                    if (t.chi[0]?.typ == 'Url-token') {
+                    if (t.chi[0]?.typ == exports.EnumToken.UrlTokenTokenType) {
                         if (options.src !== '' && options.resolveUrls) {
                             // @ts-ignore
                             t.chi[0].val = options.resolve(t.chi[0].val, options.src, options.cwd).relative;
@@ -3325,13 +3462,13 @@
                 if (t.chi.length > 0) {
                     // @ts-ignore
                     parseTokens(t.chi, options);
-                    if (t.typ == 'Pseudo-class-func' && t.val == ':is' && options.minify) {
+                    if (t.typ == exports.EnumToken.PseudoClassFuncTokenType && t.val == ':is' && options.minify) {
                         //
-                        const count = t.chi.filter(t => t.typ != 'Comment').length;
+                        const count = t.chi.filter(t => t.typ != exports.EnumToken.CommentTokenType).length;
                         if (count == 1 ||
                             (i == 0 &&
-                                (tokens[i + 1]?.typ == 'Comma' || tokens.length == i + 1)) ||
-                            (tokens[i - 1]?.typ == 'Comma' && (tokens[i + 1]?.typ == 'Comma' || tokens.length == i + 1))) {
+                                (tokens[i + 1]?.typ == exports.EnumToken.CommaTokenType || tokens.length == i + 1)) ||
+                            (tokens[i - 1]?.typ == exports.EnumToken.CommaTokenType && (tokens[i + 1]?.typ == exports.EnumToken.CommaTokenType || tokens.length == i + 1))) {
                             tokens.splice(i, 1, ...t.chi);
                             i = Math.max(0, i - t.chi.length);
                         }
@@ -3340,22 +3477,22 @@
                 continue;
             }
             if (options.parseColor) {
-                if (t.typ == 'Iden') {
+                if (t.typ == exports.EnumToken.IdenTokenType) {
                     // named color
                     const value = t.val.toLowerCase();
                     if (value in COLORS_NAMES) {
                         Object.assign(t, {
-                            typ: 'Color',
+                            typ: exports.EnumToken.ColorTokenType,
                             val: COLORS_NAMES[value].length < value.length ? COLORS_NAMES[value] : value,
                             kin: 'hex'
                         });
                     }
                     continue;
                 }
-                if (t.typ == 'Hash' && isHexColor(t.val)) {
+                if (t.typ == exports.EnumToken.HashTokenType && isHexColor(t.val)) {
                     // hex color
                     // @ts-ignore
-                    t.typ = 'Color';
+                    t.typ = exports.EnumToken.ColorTokenType;
                     // @ts-ignore
                     t.kin = 'hex';
                 }
@@ -3364,43 +3501,544 @@
         return tokens;
     }
 
-    const propertiesConfig = getConfig();
-    class PropertyMap {
-        config;
-        declarations;
-        requiredCount;
-        pattern;
-        constructor(config) {
-            const values = Object.values(config.properties);
-            this.requiredCount = values.reduce((acc, curr) => curr.required ? ++acc : acc, 0) || values.length;
-            this.config = config;
-            this.declarations = new Map;
-            this.pattern = config.pattern.split(/\s/);
+    function eq(a, b) {
+        if (a == null || b == null) {
+            return a == b;
         }
-        add(declaration) {
-            for (const val of declaration.val) {
-                Object.defineProperty(val, 'propertyName', { enumerable: false, writable: true, value: declaration.nam });
+        if (typeof a != 'object' || typeof b != 'object') {
+            return a === b;
+        }
+        if (Object.getPrototypeOf(a) !== Object.getPrototypeOf(b)) {
+            return false;
+        }
+        if (Array.isArray(a)) {
+            if (a.length != b.length) {
+                return false;
             }
-            if (declaration.nam == this.config.shorthand) {
-                this.declarations = new Map;
-                this.declarations.set(declaration.nam, declaration);
+            let i = 0;
+            for (; i < a.length; i++) {
+                if (!eq(a[i], b[i])) {
+                    return false;
+                }
             }
-            else {
-                const separator = this.config.separator;
-                // 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) => {
-                        if (separator != null && separator.typ == curr.typ && eq(separator, curr)) {
-                            acc.push([]);
-                            return acc;
+            return true;
+        }
+        const k1 = Object.keys(a);
+        const k2 = Object.keys(b);
+        if (k1.length != k2.length) {
+            return false;
+        }
+        let key;
+        for (key of k1) {
+            if (!(key in b) || !eq(a[key], b[key])) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    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) {
+        const stack = values.slice();
+        const weakMap = new WeakMap;
+        let value;
+        while (stack.length > 0) {
+            value = stack.shift();
+            // @ts-ignore
+            yield { value, parent: weakMap.get(value) };
+            if ('chi' in value) {
+                for (const child of value.chi) {
+                    weakMap.set(child, value);
+                }
+                stack.unshift(...value.chi);
+            }
+        }
+    }
+
+    function expand(ast) {
+        //
+        if (![4 /* NodeType.RuleNodeType */, 2 /* NodeType.StyleSheetNodeType */, 3 /* NodeType.AtRuleNodeType */].includes(ast.typ)) {
+            return ast;
+        }
+        if (4 /* NodeType.RuleNodeType */ == ast.typ) {
+            return {
+                typ: 2 /* NodeType.StyleSheetNodeType */,
+                chi: expandRule(ast)
+            };
+        }
+        if (!('chi' in ast)) {
+            return ast;
+        }
+        const result = { ...ast, chi: [] };
+        // @ts-ignore
+        for (let i = 0; i < ast.chi.length; i++) {
+            // @ts-ignore
+            const node = ast.chi[i];
+            if (node.typ == 4 /* NodeType.RuleNodeType */) {
+                // @ts-ignore
+                result.chi.push(...expandRule(node));
+                // i += expanded.length - 1;
+            }
+            else if (node.typ == 3 /* NodeType.AtRuleNodeType */ && 'chi' in node) {
+                let hasRule = false;
+                let j = node.chi.length;
+                while (j--) {
+                    if (node.chi[j].typ == 4 /* NodeType.RuleNodeType */ || node.chi[j].typ == 3 /* NodeType.AtRuleNodeType */) {
+                        hasRule = true;
+                        break;
+                    }
+                }
+                // @ts-ignore
+                result.chi.push({ ...(hasRule ? expand(node) : node) });
+            }
+            else {
+                // @ts-ignore
+                result.chi.push(node);
+            }
+        }
+        return result;
+    }
+    function expandRule(node) {
+        const ast = { ...node, chi: node.chi.slice() };
+        const result = [];
+        if (ast.typ == 4 /* NodeType.RuleNodeType */) {
+            let i = 0;
+            for (; i < ast.chi.length; i++) {
+                if (ast.chi[i].typ == 4 /* NodeType.RuleNodeType */) {
+                    const rule = ast.chi[i];
+                    if (!rule.sel.includes('&')) {
+                        const selRule = splitRule(rule.sel);
+                        selRule.forEach(arr => combinators.includes(arr[0].charAt(0)) ? arr.unshift(ast.sel) : arr.unshift(ast.sel, ' '));
+                        rule.sel = selRule.reduce((acc, curr) => {
+                            acc.push(curr.join(''));
+                            return acc;
+                        }, []).join(',');
+                    }
+                    else {
+                        rule.sel = replaceCompound(rule.sel, ast.sel);
+                    }
+                    ast.chi.splice(i--, 1);
+                    result.push(...expandRule(rule));
+                }
+                else if (ast.chi[i].typ == 3 /* NodeType.AtRuleNodeType */) {
+                    let astAtRule = ast.chi[i];
+                    const values = [];
+                    if (astAtRule.nam == 'scope') {
+                        if (astAtRule.val.includes('&')) {
+                            astAtRule.val = replaceCompound(astAtRule.val, ast.sel);
+                        }
+                        astAtRule = expand(astAtRule);
+                    }
+                    else {
+                        // @ts-ignore
+                        const clone = { ...ast, chi: astAtRule.chi.slice() };
+                        // @ts-ignore
+                        astAtRule.chi.length = 0;
+                        for (const r of expandRule(clone)) {
+                            if (r.typ == 3 /* NodeType.AtRuleNodeType */ && 'chi' in r) {
+                                if (astAtRule.val !== '' && r.val !== '') {
+                                    if (astAtRule.nam == 'media' && r.nam == 'media') {
+                                        r.val = astAtRule.val + ' and ' + r.val;
+                                    }
+                                    else if (astAtRule.nam == 'layer' && r.nam == 'layer') {
+                                        r.val = astAtRule.val + '.' + r.val;
+                                    }
+                                }
+                                // @ts-ignore
+                                values.push(r);
+                            }
+                            else if (r.typ == 4 /* NodeType.RuleNodeType */) {
+                                // @ts-ignore
+                                astAtRule.chi.push(...expandRule(r));
+                            }
+                            else {
+                                // @ts-ignore
+                                astAtRule.chi.push(r);
+                            }
+                        }
+                    }
+                    // @ts-ignore
+                    result.push(...(astAtRule.chi.length > 0 ? [astAtRule].concat(values) : values));
+                    ast.chi.splice(i--, 1);
+                }
+            }
+        }
+        // @ts-ignore
+        return ast.chi.length > 0 ? [ast].concat(result) : result;
+    }
+    function replaceCompound(input, replace) {
+        const tokens = parseString(input);
+        for (const t of walkValues(tokens)) {
+            if (t.value.typ == exports.EnumToken.LiteralTokenType) {
+                if (t.value.val == '&') {
+                    t.value.val = replace;
+                }
+                else if (t.value.val.length > 1 && t.value.val.charAt(0) == '&') {
+                    t.value.val = replaceCompoundLiteral(t.value.val, replace);
+                }
+            }
+        }
+        return tokens.reduce((acc, curr) => acc + renderToken(curr), '');
+    }
+    function replaceCompoundLiteral(selector, replace) {
+        const tokens = [''];
+        let i = 0;
+        for (; i < selector.length; i++) {
+            if (selector.charAt(i) == '&') {
+                tokens.push('&');
+                tokens.push('');
+            }
+            else {
+                tokens[tokens.length - 1] += selector.charAt(i);
+            }
+        }
+        return tokens.sort((a, b) => {
+            if (a == '&') {
+                return 1;
+            }
+            return b == '&' ? -1 : 0;
+        }).reduce((acc, curr) => acc + (curr == '&' ? replace : curr), '');
+    }
+
+    class MinifyFeature {
+        static get ordering() { return 10000; }
+        register(options) { }
+        run(ast, options = {}, parent, context) {
+        }
+    }
+
+    class InlineCssVariables extends MinifyFeature {
+        static get ordering() {
+            return 0;
+        }
+        static register(options) {
+            if (options.inlineCssVariables) {
+                for (const feature of options.features) {
+                    if (feature instanceof InlineCssVariables) {
+                        return;
+                    }
+                }
+                // @ts-ignore
+                options.features.push(new InlineCssVariables());
+            }
+        }
+        run(ast, options = {}, parent, context) {
+            if (!('variableScope' in context)) {
+                context.variableScope = new Map;
+            }
+            const isRoot = parent.typ == 2 /* NodeType.StyleSheetNodeType */ && ast.typ == 4 /* NodeType.RuleNodeType */ && ast.sel == ':root';
+            const variableScope = context.variableScope;
+            // @ts-ignore
+            for (const node of ast.chi) {
+                if (node.typ == 1 /* NodeType.CDOCOMMNodeType */ || node.typ == 0 /* NodeType.CommentNodeType */) {
+                    continue;
+                }
+                if (node.typ != 5 /* NodeType.DeclarationNodeType */) {
+                    break;
+                }
+                // css variable
+                if (node.nam.startsWith('--')) {
+                    if (!variableScope.has(node.nam)) {
+                        const info = {
+                            globalScope: isRoot,
+                            // @ts-ignore
+                            parent: new Set(),
+                            declarationCount: 1,
+                            replaceable: isRoot,
+                            node: node
+                        };
+                        info.parent.add(ast);
+                        variableScope.set(node.nam, info);
+                    }
+                    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 {
+                    for (const { value, parent: parentValue } of walkValues(node.val)) {
+                        if (value?.typ == exports.EnumToken.FunctionTokenType && value.val == 'var') {
+                            if (value.chi.length == 1 && value.chi[0].typ == exports.EnumToken.IdenTokenType) {
+                                const info = variableScope.get(value.chi[0].val);
+                                if (info?.replaceable) {
+                                    if (parentValue != null) {
+                                        let i = 0;
+                                        for (; i < parentValue.chi.length; i++) {
+                                            if (parentValue.chi[i] == value) {
+                                                parentValue.chi.splice(i, 1, ...info.node.val);
+                                                break;
+                                            }
+                                        }
+                                    }
+                                    else {
+                                        node.val = info.node.val.slice();
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        cleanup(ast, options = {}, context) {
+            const variableScope = context.variableScope;
+            for (const info of variableScope.values()) {
+                if (info.replaceable) {
+                    let i;
+                    for (const parent of info.parent) {
+                        i = parent.chi?.length ?? 0;
+                        while (i--) {
+                            if (parent.chi[i].typ == 5 /* NodeType.DeclarationNodeType */ && parent.chi[i].nam == info.node.nam) {
+                                parent.chi.splice(i, 1);
+                            }
+                        }
+                        if (parent.chi?.length == 0 && 'parent' in parent) {
+                            // @ts-ignore
+                            for (i = 0; i < parent.parent.chi?.length; i++) {
+                                // @ts-ignore
+                                if (parent.parent.chi[i] == parent) {
+                                    // @ts-ignore
+                                    parent.parent.chi.splice(i, 1);
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    class PropertySet {
+        config;
+        declarations;
+        constructor(config) {
+            this.config = config;
+            this.declarations = new Map;
+        }
+        add(declaration) {
+            if (declaration.nam == this.config.shorthand) {
+                this.declarations = new Map;
+            }
+            else {
+                // expand shorthand
+                if (declaration.nam != this.config.shorthand && this.declarations.has(this.config.shorthand)) {
+                    let isValid = true;
+                    let current = -1;
+                    const tokens = [];
+                    // @ts-ignore
+                    for (let token of this.declarations.get(this.config.shorthand).val) {
+                        // @ts-ignore
+                        if (this.config.types.some(t => token.typ == exports.EnumToken[t]) || (token.typ == exports.EnumToken.NumberTokenType && token.val == '0' &&
+                            (this.config.types.includes('Length') ||
+                                this.config.types.includes('Angle') ||
+                                this.config.types.includes('Dimension')))) {
+                            if (tokens.length == 0) {
+                                tokens.push([]);
+                                current++;
+                            }
+                            tokens[current].push(token);
+                            continue;
+                        }
+                        if (token.typ != exports.EnumToken.WhitespaceTokenType && token.typ != exports.EnumToken.CommentTokenType) {
+                            if (token.typ == exports.EnumToken.IdenTokenType && this.config.keywords.includes(token.val)) {
+                                if (tokens.length == 0) {
+                                    tokens.push([]);
+                                    current++;
+                                }
+                                tokens[current].push(token);
+                            }
+                            if (token.typ == exports.EnumToken.LiteralTokenType && token.val == this.config.separator) {
+                                tokens.push([]);
+                                current++;
+                                continue;
+                            }
+                            isValid = false;
+                            break;
+                        }
+                    }
+                    if (isValid && tokens.length > 0) {
+                        this.declarations.delete(this.config.shorthand);
+                        for (const values of tokens) {
+                            this.config.properties.forEach((property, index) => {
+                                if (!this.declarations.has(property)) {
+                                    this.declarations.set(property, {
+                                        typ: 5 /* NodeType.DeclarationNodeType */,
+                                        nam: property,
+                                        val: []
+                                    });
+                                }
+                                while (index > 0 && index >= values.length) {
+                                    if (index > 1) {
+                                        index %= 2;
+                                    }
+                                    else {
+                                        index = 0;
+                                        break;
+                                    }
+                                }
+                                // @ts-ignore
+                                const val = this.declarations.get(property).val;
+                                if (val.length > 0) {
+                                    val.push({ typ: exports.EnumToken.WhitespaceTokenType });
+                                }
+                                val.push({ ...values[index] });
+                            });
+                        }
+                    }
+                    this.declarations.set(declaration.nam, declaration);
+                    return this;
+                }
+            }
+            this.declarations.set(declaration.nam, declaration);
+            return this;
+        }
+        isShortHand() {
+            if (this.declarations.has(this.config.shorthand)) {
+                return this.declarations.size == 1;
+            }
+            return this.config.properties.length == this.declarations.size;
+        }
+        [Symbol.iterator]() {
+            let iterator;
+            const declarations = this.declarations;
+            if (declarations.size < this.config.properties.length) {
+                iterator = declarations.values();
+            }
+            else {
+                const values = [];
+                this.config.properties.forEach((property) => {
+                    let index = 0;
+                    // @ts-ignore
+                    for (const token of this.declarations.get(property).val) {
+                        if (token.typ == exports.EnumToken.WhitespaceTokenType) {
+                            continue;
+                        }
+                        if (values.length == index) {
+                            values.push([]);
+                        }
+                        values[index].push(token);
+                        index++;
+                    }
+                });
+                for (const value of values) {
+                    let i = value.length;
+                    while (i-- > 1) {
+                        const t = value[i];
+                        const k = value[i == 1 ? 0 : i % 2];
+                        if (t.val == k.val && t.val == '0') {
+                            if ((t.typ == exports.EnumToken.NumberTokenType && isLength(k)) ||
+                                (k.typ == exports.EnumToken.NumberTokenType && isLength(t)) ||
+                                (isLength(k) || isLength(t))) {
+                                value.splice(i, 1);
+                                continue;
+                            }
+                        }
+                        if (eq(t, k)) {
+                            value.splice(i, 1);
+                            continue;
+                        }
+                        break;
+                    }
+                }
+                iterator = [{
+                        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: exports.EnumToken.WhitespaceTokenType });
+                                    i += 2;
+                                }
+                            }
+                            if (acc.length > 0) {
+                                acc.push({ typ: exports.EnumToken.LiteralTokenType, val: this.config.separator });
+                            }
+                            acc.push(...curr);
+                            return acc;
+                        }, [])
+                    }][Symbol.iterator]();
+                // return {
+                //     next() {
+                //
+                //         return iterator.next();
+                //     }
+                // }
+            }
+            return iterator;
+            // return {
+            //     next() {
+            //
+            //         return iterator.next();
+            //     }
+            // }
+        }
+    }
+
+    const propertiesConfig = getConfig();
+    class PropertyMap {
+        config;
+        declarations;
+        requiredCount;
+        pattern;
+        constructor(config) {
+            const values = Object.values(config.properties);
+            this.requiredCount = values.reduce((acc, curr) => curr.required ? ++acc : acc, 0) || values.length;
+            this.config = config;
+            this.declarations = new Map;
+            this.pattern = config.pattern.split(/\s/);
+        }
+        add(declaration) {
+            for (const val of declaration.val) {
+                Object.defineProperty(val, 'propertyName', { enumerable: false, writable: true, value: declaration.nam });
+            }
+            if (declaration.nam == this.config.shorthand) {
+                this.declarations = new Map;
+                this.declarations.set(declaration.nam, declaration);
+            }
+            else {
+                const separator = this.config.separator != null ? {
+                    ...this.config.separator,
+                    typ: exports.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
@@ -3409,7 +4047,7 @@
                             // 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 == exports.EnumToken.CommentTokenType || acc[i].typ == exports.EnumToken.WhitespaceTokenType) {
                                     acc.splice(i, 1);
                                     i--;
                                     continue;
@@ -3425,18 +4063,20 @@
                                     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: exports.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 == exports.EnumToken[props.prefix.typ]) {
+                                        if (eq(acc[i], {
+                                            ...this.config.properties[property].prefix,
+                                            // @ts-ignore
+                                            typ: exports.EnumToken[props.prefix.typ]
+                                        })) {
                                             acc.splice(i, 1);
                                             i--;
                                         }
@@ -3469,7 +4109,7 @@
                                         tokens[property][current].push(...defaults);
                                     }
                                     else {
-                                        tokens[property][current].push({ typ: 'Whitespace' }, ...defaults);
+                                        tokens[property][current].push({ typ: exports.EnumToken.WhitespaceTokenType }, ...defaults);
                                     }
                                 }
                             }
@@ -3480,7 +4120,7 @@
                     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) {
@@ -3550,7 +4190,10 @@
             else {
                 let count = 0;
                 let match;
-                const separator = this.config.separator;
+                const separator = this.config.separator != null ? {
+                    ...this.config.separator,
+                    typ: exports.EnumToken[this.config.separator.typ]
+                } : null;
                 const tokens = {};
                 // @ts-ignore
                 /* const valid: string[] =*/
@@ -3574,14 +4217,18 @@
                                 }
                                 continue;
                             }
-                            if (val.typ == 'Whitespace' || val.typ == 'Comment') {
+                            if (val.typ == exports.EnumToken.WhitespaceTokenType || val.typ == exports.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 && exports.EnumToken[props.separator.typ] == val.typ && eq({
+                                ...props.separator,
+                                typ: exports.EnumToken[props.separator.typ]
+                            }, val)) {
                                 continue;
                             }
                             // @ts-ignore
-                            match = val.typ == 'Comment' || matchType(val, curr[1]);
+                            match = val.typ == exports.EnumToken.CommentTokenType || matchType(val, curr[1]);
                             if (isShorthand) {
                                 isShorthand = match;
                             }
@@ -3610,7 +4257,7 @@
                     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 != exports.EnumToken.CommentTokenType).length == count)) {
                     // @ts-ignore
                     iterable = this.declarations.values();
                 }
@@ -3623,7 +4270,7 @@
                             }
                             let values = curr[1][i].reduce((acc, curr) => {
                                 if (acc.length > 0) {
-                                    acc.push({ typ: 'Whitespace' });
+                                    acc.push({ typ: exports.EnumToken.WhitespaceTokenType });
                                 }
                                 acc.push(curr);
                                 return acc;
@@ -3635,8 +4282,8 @@
                             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 (![exports.EnumToken.WhitespaceTokenType, exports.EnumToken.CommentTokenType, exports.EnumToken.IdenTokenType].includes(v.typ)
+                                        || (v.typ == exports.EnumToken.IdenTokenType && !this.config.properties[curr[0]].default.includes(v.val))) {
                                         doFilterDefault = false;
                                         break;
                                     }
@@ -3644,10 +4291,10 @@
                             }
                             // remove default values
                             values = values.filter((val) => {
-                                if (val.typ == 'Whitespace' || val.typ == 'Comment') {
+                                if (val.typ == exports.EnumToken.WhitespaceTokenType || val.typ == exports.EnumToken.CommentTokenType) {
                                     return false;
                                 }
-                                return !doFilterDefault || !(val.typ == 'Iden' && props.default.includes(val.val));
+                                return !doFilterDefault || !(val.typ == exports.EnumToken.IdenTokenType && props.default.includes(val.val));
                             });
                             if (values.length > 0) {
                                 if ('mapping' in props) {
@@ -3656,7 +4303,7 @@
                                         let i = values.length;
                                         while (i--) {
                                             // @ts-ignore
-                                            if (values[i].typ == 'Iden' && values[i].val in props.mapping) {
+                                            if (values[i].typ == exports.EnumToken.IdenTokenType && values[i].val in props.mapping) {
                                                 // @ts-ignore
                                                 values.splice(i, 1, ...parseString(props.mapping[values[i].val]));
                                             }
@@ -3665,15 +4312,20 @@
                                 }
                                 if ('prefix' in props) {
                                     // @ts-ignore
-                                    acc[i].push({ ...props.prefix });
+                                    acc[i].push({ ...props.prefix, typ: exports.EnumToken[props.prefix.typ] });
                                 }
                                 else if (acc[i].length > 0) {
-                                    acc[i].push({ typ: 'Whitespace' });
+                                    acc[i].push({ typ: exports.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: exports.EnumToken[props.separator.typ]
+                                            }) ?? { typ: exports.EnumToken.WhitespaceTokenType })
+                                        });
                                     }
                                     // @ts-ignore
                                     acc.push(curr);
@@ -3689,7 +4341,7 @@
                         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: exports.EnumToken.WhitespaceTokenType });
                                 }
                                 acc.push(curr);
                                 return acc;
@@ -3702,12 +4354,15 @@
                         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)) ? exports.EnumToken.StringTokenType : exports.EnumToken.IdenTokenType,
+                                // @ts-ignore
+                                val: this.config.mapping[val]
+                            });
                         }
                     }
                     iterable = [{
-                            typ: 'Declaration',
+                            typ: 5 /* NodeType.DeclarationNodeType */,
                             nam: this.config.shorthand,
                             val: values
                         }][Symbol.iterator]();
@@ -3744,570 +4399,442 @@
 
     const config = getConfig();
     class PropertyList {
+        options = { removeDuplicateDeclarations: true, computeShorthand: true };
         declarations;
-        constructor() {
-            this.declarations = new Map;
-        }
-        set(nam, value) {
-            return this.add({ typ: 'Declaration', nam, val: Array.isArray(value) ? value : parseString(String(value)) });
-        }
-        add(declaration) {
-            if (declaration.typ != 'Declaration') {
-                this.declarations.set(Number(Math.random().toString().slice(2)).toString(36), declaration);
-                return this;
-            }
-            let propertyName = declaration.nam;
-            let shortHandType;
-            let shorthand;
-            if (propertyName in config.properties) {
-                // @ts-ignore
-                if ('map' in config.properties[propertyName]) {
-                    shortHandType = 'map';
-                    // @ts-ignore
-                    shorthand = config.properties[propertyName].map;
-                }
-                else {
-                    shortHandType = 'set';
-                    // @ts-ignore
-                    shorthand = config.properties[propertyName].shorthand;
-                }
-            }
-            else if (propertyName in config.map) {
-                shortHandType = 'map';
-                // @ts-ignore
-                shorthand = config.map[propertyName].shorthand;
-            }
-            // @ts-ignore
-            if (shortHandType == 'map') {
-                // @ts-ignore
-                if (!this.declarations.has(shorthand)) {
-                    // @ts-ignore
-                    this.declarations.set(shorthand, new PropertyMap(config.map[shorthand]));
-                }
-                // @ts-ignore
-                this.declarations.get(shorthand).add(declaration);
-                // return this;
-            }
-            // @ts-ignore
-            else if (shortHandType == 'set') {
-                // @ts-ignore
-                // const shorthand: string = <string>config.properties[propertyName].shorthand;
-                if (!this.declarations.has(shorthand)) {
-                    // @ts-ignore
-                    this.declarations.set(shorthand, new PropertySet(config.properties[shorthand]));
-                }
-                // @ts-ignore
-                this.declarations.get(shorthand).add(declaration);
-                // return this;
-            }
-            else {
-                this.declarations.set(propertyName, declaration);
-            }
-            return this;
-        }
-        [Symbol.iterator]() {
-            let iterator = this.declarations.values();
-            const iterators = [];
-            return {
-                next() {
-                    let value = iterator.next();
-                    while ((value.done && iterators.length > 0) ||
-                        value.value instanceof PropertySet ||
-                        value.value instanceof PropertyMap) {
-                        if (value.value instanceof PropertySet || value.value instanceof PropertyMap) {
-                            iterators.unshift(iterator);
-                            // @ts-ignore
-                            iterator = value.value[Symbol.iterator]();
-                            value = iterator.next();
-                        }
-                        if (value.done && iterators.length > 0) {
-                            iterator = iterators.shift();
-                            value = iterator.next();
-                        }
-                    }
-                    return value;
-                }
-            };
-        }
-    }
-
-    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* walkValues(values, parent) {
-        for (const value of values) {
-            // @ts-ignore
-            yield { value, parent };
-            if ('chi' in value) {
-                yield* walkValues(value.chi, value);
-            }
-        }
-    }
-
-    function expand(ast) {
-        //
-        if (!['Rule', 'StyleSheet', 'AtRule'].includes(ast.typ)) {
-            return ast;
-        }
-        if ('Rule' == ast.typ) {
-            return {
-                typ: 'StyleSheet',
-                chi: expandRule(ast)
-            };
-        }
-        if (!('chi' in ast)) {
-            return { ...ast };
-        }
-        const result = { ...ast, chi: [] };
-        // @ts-ignore
-        for (let i = 0; i < ast.chi.length; i++) {
-            // @ts-ignore
-            const node = ast.chi[i];
-            if (node.typ == 'Rule') {
-                // @ts-ignore
-                result.chi.push(...expandRule(node));
-                // i += expanded.length - 1;
-            }
-            else if (node.typ == 'AtRule' && 'chi' in node) {
-                let hasRule = false;
-                let j = node.chi.length;
-                while (j--) {
-                    if (node.chi[j].typ == 'Rule' || node.chi[j].typ == 'AtRule') {
-                        hasRule = true;
-                        break;
-                    }
-                }
-                // @ts-ignore
-                result.chi.push({ ...(hasRule ? expand(node) : node) });
-            }
-            else {
-                // @ts-ignore
-                result.chi.push(node);
-            }
-        }
-        return result;
-    }
-    function expandRule(node) {
-        const ast = { ...node, chi: node.chi.slice() };
-        const result = [];
-        if (ast.typ == 'Rule') {
-            let i = 0;
-            for (; i < ast.chi.length; i++) {
-                if (ast.chi[i].typ == 'Rule') {
-                    const rule = ast.chi[i];
-                    if (!rule.sel.includes('&')) {
-                        const selRule = splitRule(rule.sel);
-                        selRule.forEach(arr => combinators.includes(arr[0].charAt(0)) ? arr.unshift(ast.sel) : arr.unshift(ast.sel, ' '));
-                        rule.sel = selRule.reduce((acc, curr) => {
-                            acc.push(curr.join(''));
-                            return acc;
-                        }, []).join(',');
-                    }
-                    else {
-                        rule.sel = replaceCompound(rule.sel, ast.sel);
-                    }
-                    ast.chi.splice(i--, 1);
-                    result.push(...expandRule(rule));
-                }
-                else if (ast.chi[i].typ == 'AtRule') {
-                    let astAtRule = ast.chi[i];
-                    const values = [];
-                    if (astAtRule.nam == 'scope') {
-                        if (astAtRule.val.includes('&')) {
-                            astAtRule.val = replaceCompound(astAtRule.val, ast.sel);
-                        }
-                        // @ts-ignore
-                        astAtRule = expand(astAtRule);
-                    }
-                    else {
-                        // @ts-ignore
-                        const clone = { ...ast, chi: astAtRule.chi.slice() };
-                        // @ts-ignore
-                        astAtRule.chi.length = 0;
-                        for (const r of expandRule(clone)) {
-                            if (r.typ == 'AtRule' && 'chi' in r) {
-                                if (astAtRule.val !== '' && r.val !== '') {
-                                    if (astAtRule.nam == 'media' && r.nam == 'media') {
-                                        r.val = astAtRule.val + ' and ' + r.val;
-                                    }
-                                    else if (astAtRule.nam == 'layer' && r.nam == 'layer') {
-                                        r.val = astAtRule.val + '.' + r.val;
-                                    }
-                                }
-                                // @ts-ignore
-                                values.push(r);
-                            }
-                            else if (r.typ == 'Rule') {
-                                // @ts-ignore
-                                astAtRule.chi.push(...expandRule(r));
-                            }
-                            else {
-                                // @ts-ignore
-                                astAtRule.chi.push(r);
-                            }
-                        }
-                    }
+        constructor(options = {}) {
+            for (const key of Object.keys(this.options)) {
+                if (key in options) {
                     // @ts-ignore
-                    result.push(...(astAtRule.chi.length > 0 ? [astAtRule].concat(values) : values));
-                    ast.chi.splice(i--, 1);
-                }
-            }
-        }
-        // @ts-ignore
-        return ast.chi.length > 0 ? [ast].concat(result) : result;
-    }
-    function replaceCompound(input, replace) {
-        const tokens = parseString(input);
-        for (const t of walkValues(tokens)) {
-            if (t.value.typ == 'Literal') {
-                if (t.value.val == '&') {
-                    t.value.val = replace;
-                }
-                else if (t.value.val.length > 1 && t.value.val.charAt(0) == '&') {
-                    t.value.val = replaceCompoundLiteral(t.value.val, replace);
+                    this.options[key] = options[key];
                 }
             }
+            this.declarations = new Map;
         }
-        return tokens.reduce((acc, curr) => acc + renderToken(curr), '');
-    }
-    function replaceCompoundLiteral(selector, replace) {
-        const tokens = [''];
-        let i = 0;
-        for (; i < selector.length; i++) {
-            if (selector.charAt(i) == '&') {
-                tokens.push('&');
-                tokens.push('');
-            }
-            else {
-                tokens[tokens.length - 1] += selector.charAt(i);
-            }
-        }
-        return tokens.sort((a, b) => {
-            if (a == '&') {
-                return 1;
+        set(nam, value) {
+            return this.add({ typ: 5 /* NodeType.DeclarationNodeType */, nam, val: Array.isArray(value) ? value : parseString(String(value)) });
+        }
+        add(declaration) {
+            if (declaration.typ != 5 /* NodeType.DeclarationNodeType */ || !this.options.removeDuplicateDeclarations) {
+                this.declarations.set(Number(Math.random().toString().slice(2)).toString(36), declaration);
+                return this;
             }
-            return b == '&' ? -1 : 0;
-        }).reduce((acc, curr) => acc + (curr == '&' ? replace : curr), '');
-    }
-
-    const combinators = ['+', '>', '~'];
-    const notEndingWith = ['(', '['].concat(combinators);
-    const definedPropertySettings = { configurable: true, enumerable: false, writable: true };
-    function minify(ast, options = {}, recursive = false, errors, nestingContent) {
-        function wrapNodes(previous, node, match, ast, i, nodeIndex) {
-            // @ts-ignore
-            let pSel = match.selector1.reduce(reducer, []).join(',');
-            // @ts-ignore
-            let nSel = match.selector2.reduce(reducer, []).join(',');
-            // @ts-ignore
-            const wrapper = { ...previous, chi: [], sel: match.match.reduce(reducer, []).join(',') };
-            // @ts-ignore
-            Object.defineProperty(wrapper, 'raw', { ...definedPropertySettings,
-                // @ts-ignore
-                value: match.match.map(t => t.slice())
-            });
-            if (pSel == '&' || pSel === '') {
-                // @ts-ignore
-                wrapper.chi.push(...previous.chi);
+            if (!this.options.computeShorthand) {
+                this.declarations.set(declaration.nam, declaration);
+                return this;
+            }
+            let propertyName = declaration.nam;
+            let shortHandType;
+            let shorthand;
+            if (propertyName in config.properties) {
                 // @ts-ignore
-                if ((nSel == '&' || nSel === '')) {
+                if ('map' in config.properties[propertyName]) {
+                    shortHandType = 'map';
                     // @ts-ignore
-                    wrapper.chi.push(...node.chi);
+                    shorthand = config.properties[propertyName].map;
                 }
                 else {
+                    shortHandType = 'set';
                     // @ts-ignore
-                    wrapper.chi.push(node);
+                    shorthand = config.properties[propertyName].shorthand;
                 }
             }
-            else {
+            else if (propertyName in config.map) {
+                shortHandType = 'map';
                 // @ts-ignore
-                wrapper.chi.push(previous, node);
+                shorthand = config.map[propertyName].shorthand;
             }
             // @ts-ignore
-            ast.chi.splice(i, 1, wrapper);
-            // @ts-ignore
-            ast.chi.splice(nodeIndex, 1);
-            // @ts-ignore
-            previous.sel = pSel;
-            // @ts-ignore
-            previous.raw = match.selector1;
-            // @ts-ignore
-            node.sel = nSel;
-            // @ts-ignore
-            node.raw = match.selector2;
-            reduceRuleSelector(wrapper);
-            return wrapper;
-        }
-        function reducer(acc, curr, index, array) {
-            // trim :is()
-            if (array.length == 1 && array[0][0] == ':is(' && array[0].at(-1) == ')') {
-                curr = curr.slice(1, -1);
-            }
-            if (curr[0] == '&') {
-                if (curr[1] == ' ' && !isIdent(curr[2]) && !isFunction(curr[2])) {
-                    curr.splice(0, 2);
+            if (shortHandType == 'map') {
+                // @ts-ignore
+                if (!this.declarations.has(shorthand)) {
+                    // @ts-ignore
+                    this.declarations.set(shorthand, new PropertyMap(config.map[shorthand]));
                 }
-                else if (combinators.includes(curr[1])) {
-                    curr.splice(0, 1);
+                // @ts-ignore
+                this.declarations.get(shorthand).add(declaration);
+                // return this;
+            }
+            // @ts-ignore
+            else if (shortHandType == 'set') {
+                // @ts-ignore
+                // const shorthand: string = <string>config.properties[propertyName].shorthand;
+                if (!this.declarations.has(shorthand)) {
+                    // @ts-ignore
+                    this.declarations.set(shorthand, new PropertySet(config.properties[shorthand]));
                 }
+                // @ts-ignore
+                this.declarations.get(shorthand).add(declaration);
+                // return this;
             }
-            else if (ast.typ == 'Rule' && (isIdent(curr[0]) || isFunction(curr[0]))) {
-                curr.unshift('&', ' ');
+            else {
+                this.declarations.set(propertyName, declaration);
             }
-            acc.push(curr.join(''));
-            return acc;
+            return this;
+        }
+        [Symbol.iterator]() {
+            let iterator = this.declarations.values();
+            const iterators = [];
+            return {
+                next() {
+                    let value = iterator.next();
+                    while ((value.done && iterators.length > 0) ||
+                        value.value instanceof PropertySet ||
+                        value.value instanceof PropertyMap) {
+                        if (value.value instanceof PropertySet || value.value instanceof PropertyMap) {
+                            iterators.unshift(iterator);
+                            // @ts-ignore
+                            iterator = value.value[Symbol.iterator]();
+                            value = iterator.next();
+                        }
+                        if (value.done && iterators.length > 0) {
+                            iterator = iterators.shift();
+                            value = iterator.next();
+                        }
+                    }
+                    return value;
+                }
+            };
+        }
+    }
+
+    class ComputeShorthand extends MinifyFeature {
+        static get ordering() {
+            return 2;
         }
-        function diff(n1, n2, options = {}) {
-            let node1 = n1;
-            let node2 = n2;
-            let exchanged = false;
-            if (node1.chi.length > node2.chi.length) {
-                const t = node1;
-                node1 = node2;
-                node2 = t;
-                exchanged = true;
-            }
-            let i = node1.chi.length;
-            let j = node2.chi.length;
-            if (i == 0 || j == 0) {
+        static register(options) {
+            if (options.computeShorthand) {
+                for (const feature of options.features) {
+                    if (feature instanceof ComputeShorthand) {
+                        return;
+                    }
+                }
                 // @ts-ignore
-                return null;
+                options.features.push(new ComputeShorthand());
             }
+        }
+        run(ast, options = {}, parent, context) {
             // @ts-ignore
-            const raw1 = node1.raw;
+            const j = ast.chi.length;
+            let k = 0;
+            let properties = new PropertyList(options);
             // @ts-ignore
-            const raw2 = node2.raw;
+            for (; k < j; k++) {
+                // @ts-ignore
+                const node = ast.chi[k];
+                if (node.typ == 0 /* NodeType.CommentNodeType */ || node.typ == 5 /* NodeType.DeclarationNodeType */) {
+                    properties.add(node);
+                    continue;
+                }
+                break;
+            }
             // @ts-ignore
-            node1 = { ...node1, chi: node1.chi.slice() };
-            node2 = { ...node2, chi: node2.chi.slice() };
-            if (raw1 != null) {
-                Object.defineProperty(node1, 'raw', { ...definedPropertySettings, value: raw1 });
+            ast.chi = [...properties].concat(ast.chi.slice(k));
+            return ast;
+        }
+    }
+
+    class ComputeCalcExpression extends MinifyFeature {
+        static get ordering() {
+            return 1;
+        }
+        static register(options) {
+            if (options.computeCalcExpression) {
+                for (const feature of options.features) {
+                    if (feature instanceof ComputeCalcExpression) {
+                        return;
+                    }
+                }
+                // @ts-ignore
+                options.features.push(new ComputeCalcExpression());
             }
-            if (raw2 != null) {
-                Object.defineProperty(node2, 'raw', { ...definedPropertySettings, value: raw2 });
+        }
+        run(ast) {
+            if (!('chi' in ast)) {
+                return ast;
             }
-            const intersect = [];
-            while (i--) {
-                if (node1.chi[i].typ == 'Comment') {
+            // @ts-ignore
+            for (const node of ast.chi) {
+                if (node.typ != 5 /* NodeType.DeclarationNodeType */) {
                     continue;
                 }
-                j = node2.chi.length;
-                if (j == 0) {
-                    break;
-                }
-                while (j--) {
-                    if (node2.chi[j].typ == 'Comment') {
-                        continue;
-                    }
-                    if (node1.chi[i].nam == node2.chi[j].nam) {
-                        if (eq(node1.chi[i], node2.chi[j])) {
-                            intersect.push(node1.chi[i]);
-                            node1.chi.splice(i, 1);
-                            node2.chi.splice(j, 1);
-                            break;
+                const set = new Set;
+                for (const { parent } of walkValues(node.val)) {
+                    if (parent != null && parent.typ == exports.EnumToken.FunctionTokenType && parent.val == 'calc') {
+                        if (!set.has(parent)) {
+                            set.add(parent);
+                            parent.chi = evaluate(parent.chi);
                         }
                     }
                 }
             }
+            return ast;
+        }
+    }
+    /**
+     * evaluate arithmetic operation
+     * @param l
+     * @param r
+     * @param op
+     */
+    function doEvaluate(l, r, op) {
+        const defaultReturn = {
+            typ: exports.EnumToken.BinaryExpressionTokenType,
+            op,
+            l,
+            r
+        };
+        if (!isScalarToken(l) || !isScalarToken(r)) {
+            return defaultReturn;
+        }
+        if ((op == exports.EnumToken.Add || op == exports.EnumToken.Sub)) {
+            // @ts-ignore
+            if (l.typ != r.typ || Number.isNaN(+l.val) || Number.isNaN(r.val)) {
+                return defaultReturn;
+            }
             // @ts-ignore
-            const result = (intersect.length == 0 ? null : {
-                ...node1,
+            return { ...l, val: reduceNumber(+l.val + (op == exports.EnumToken.Add ? +r.val : -1 * r.val)) };
+        }
+        else {
+            // @ts-ignore
+            let val;
+            if (op == exports.EnumToken.Div) {
+                if (r.typ != exports.EnumToken.NumberTokenType || r.val == '0') {
+                    return defaultReturn;
+                }
                 // @ts-ignore
-                sel: [...new Set([...(n1?.raw?.reduce(reducer, []) || splitRule(n1.sel)).concat(n2?.raw?.reduce(reducer, []) || splitRule(n2.sel))])].join(','),
-                chi: intersect.reverse()
-            });
-            if (result == null || [n1, n2].reduce((acc, curr) => curr.chi.length == 0 ? acc : acc + render(curr, options).code.length, 0) <= [node1, node2, result].reduce((acc, curr) => curr.chi.length == 0 ? acc : acc + render(curr, options).code.length, 0)) {
+                val = reduceNumber(l.val / r.val);
+            }
+            else {
                 // @ts-ignore
-                return null;
+                val = reduceNumber(r.val * l.val);
+            }
+            let result;
+            if (r.typ == exports.EnumToken.NumberTokenType || op == exports.EnumToken.Div) {
+                result = { ...l, val };
+            }
+            else {
+                // @ts-ignore
+                result = { ...r, val };
+            }
+            if (renderToken(result).length <= renderToken(defaultReturn).length) {
+                return result;
             }
-            return { result, node1: exchanged ? node2 : node1, node2: exchanged ? node1 : node2 };
         }
-        function matchSelectors(selector1, selector2, parentType) {
-            let match = [[]];
-            const j = Math.min(selector1.reduce((acc, curr) => Math.min(acc, curr.length), selector1.length > 0 ? selector1[0].length : 0), selector2.reduce((acc, curr) => Math.min(acc, curr.length), selector2.length > 0 ? selector2[0].length : 0));
-            let i = 0;
-            let k;
-            let l;
-            let token;
-            let matching = true;
-            let matchFunction = 0;
-            let inAttr = 0;
-            for (; i < j; i++) {
-                k = 0;
-                token = selector1[0][i];
-                for (; k < selector1.length; k++) {
-                    if (selector1[k][i] != token) {
-                        matching = false;
-                        break;
-                    }
-                }
-                if (matching) {
-                    l = 0;
-                    for (; l < selector2.length; l++) {
-                        if (selector2[l][i] != token) {
-                            matching = false;
-                            break;
-                        }
-                    }
-                }
-                if (!matching) {
-                    break;
-                }
-                if (token == ',') {
-                    match.push([]);
+        return defaultReturn;
+    }
+    /**
+     * 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 == exports.EnumToken.Add) {
+                continue;
+            }
+            if (token.typ == exports.EnumToken.Sub) {
+                if (!isScalarToken(nodes[i + 1])) {
+                    token = { typ: exports.EnumToken.ListToken, chi: [nodes[i], nodes[i + 1]] };
                 }
                 else {
-                    if (token.endsWith('(')) {
-                        matchFunction++;
-                    }
-                    if (token.endsWith('[')) {
-                        inAttr++;
-                    }
-                    else if (token == ')') {
-                        matchFunction--;
-                    }
-                    else if (token == ']') {
-                        inAttr--;
-                    }
-                    match.at(-1).push(token);
+                    token = doEvaluate(nodes[i + 1], { typ: exports.EnumToken.NumberTokenType, val: '-1' }, exports.EnumToken.Mul);
                 }
+                i++;
             }
-            // invalid function
-            if (matchFunction != 0 || inAttr != 0) {
-                return null;
+            if (!map.has(token.typ)) {
+                map.set(token.typ, [token]);
             }
-            if (parentType != 'Rule') {
-                for (const part of match) {
-                    if (part.length > 0 && combinators.includes(part[0].charAt(0))) {
-                        return null;
-                    }
+            else {
+                map.get(token.typ).push(token);
+            }
+        }
+        return [...map].reduce((acc, curr) => {
+            const token = curr[1].reduce((acc, curr) => doEvaluate(acc, curr, exports.EnumToken.Add));
+            if (token.typ != exports.EnumToken.BinaryExpressionTokenType) {
+                if ('val' in token && +token.val < 0) {
+                    acc.push({ typ: exports.EnumToken.Sub }, { ...token, val: String(-token.val) });
+                    return acc;
                 }
             }
-            if (match.length > 1) {
-                errors?.push({ action: 'ignore', message: `minify: unsupported multilevel matching\n${JSON.stringify({ match, selector1, selector2 }, null, 1)}` });
-                return null;
+            if (acc.length > 0 && curr[0] != exports.EnumToken.ListToken) {
+                acc.push({ typ: exports.EnumToken.Add });
             }
-            for (const part of match) {
-                while (part.length > 0) {
-                    const token = part.at(-1);
-                    if (token == ' ' || combinators.includes(token) || notEndingWith.includes(token.at(-1))) {
-                        part.pop();
-                        continue;
-                    }
-                    break;
-                }
+            acc.push(token);
+            return acc;
+        }, []);
+    }
+    /**
+     * convert BinaryExpression into an array
+     * @param token
+     */
+    function inlineExpression(token) {
+        const result = [];
+        if (token.typ == exports.EnumToken.BinaryExpressionTokenType) {
+            if ([exports.EnumToken.Mul, exports.EnumToken.Div].includes(token.op)) {
+                result.push(token);
             }
-            if (match.every(t => t.length == 0)) {
-                return null;
+            else {
+                result.push(...inlineExpression(token.l), { typ: token.op }, ...inlineExpression(token.r));
             }
-            if (eq([['&']], match)) {
-                return null;
+        }
+        else {
+            result.push(token);
+        }
+        return result;
+    }
+    /**
+     * evaluate expression
+     * @param token
+     */
+    function evaluateExpression(token) {
+        if (token.typ != exports.EnumToken.BinaryExpressionTokenType) {
+            return token;
+        }
+        if (token.r.typ == exports.EnumToken.BinaryExpressionTokenType) {
+            token.r = evaluateExpression(token.r);
+        }
+        if (token.l.typ == exports.EnumToken.BinaryExpressionTokenType) {
+            token.l = evaluateExpression(token.l);
+        }
+        const result = doEvaluate(token.l, token.r, token.op);
+        if (result.typ == exports.EnumToken.BinaryExpressionTokenType &&
+            [exports.EnumToken.Mul, exports.EnumToken.Div].includes(result.op)) {
+            // wrap expression
+            if (result.l.typ == exports.EnumToken.BinaryExpressionTokenType && [exports.EnumToken.Sub, exports.EnumToken.Add].includes(result.l.op)) {
+                result.l = { typ: exports.EnumToken.ParensTokenType, chi: [result.l] };
             }
-            function reduce(acc, curr) {
-                if (acc === null) {
-                    return null;
-                }
-                let hasCompoundSelector = true;
-                curr = curr.slice(match[0].length);
-                while (curr.length > 0) {
-                    if (curr[0] == ' ') {
-                        hasCompoundSelector = false;
-                        curr.unshift('&');
-                        continue;
-                    }
-                    break;
-                }
-                // invalid function match
-                if (curr.length > 0 && curr[0].endsWith('(') && curr.at(-1) != ')') {
-                    return null;
-                }
-                if (curr.length == 1 && combinators.includes(curr[0].charAt(0))) {
-                    return null;
-                }
-                if (hasCompoundSelector && curr.length > 0) {
-                    hasCompoundSelector = !['&'].concat(combinators).includes(curr[0].charAt(0));
-                }
-                if (curr[0] == ':is(') {
-                    let inFunction = 0;
-                    let canReduce = true;
-                    const isCompound = curr.reduce((acc, token, index) => {
-                        if (index == 0) {
-                            inFunction++;
-                            canReduce = curr[1] == '&';
-                        }
-                        else if (token.endsWith('(')) {
-                            if (inFunction == 0) {
-                                canReduce = false;
-                            }
-                            inFunction++;
-                        }
-                        else if (token == ')') {
-                            inFunction--;
-                        }
-                        else if (token == ',') {
-                            if (!canReduce) {
-                                canReduce = curr[index + 1] == '&';
-                            }
-                            acc.push([]);
-                        }
-                        else
-                            acc.at(-1)?.push(token);
-                        return acc;
-                    }, [[]]);
-                    if (inFunction > 0) {
-                        canReduce = false;
-                    }
-                    if (canReduce) {
-                        curr = isCompound.reduce((acc, curr) => {
-                            if (acc.length > 0) {
-                                acc.push(',');
-                            }
-                            acc.push(...curr);
-                            return acc;
-                        }, []);
-                    }
-                }
-                // @todo: check hasCompoundSelector && curr[0] == '&' && curr[1] == ' '
-                acc.push(match.length == 0 ? ['&'] : (hasCompoundSelector && curr[0] != '&' && (curr.length == 0 || !combinators.includes(curr[0].charAt(0))) ? ['&'].concat(curr) : curr));
-                return acc;
+            else if (result.r.typ == exports.EnumToken.BinaryExpressionTokenType && [exports.EnumToken.Sub, exports.EnumToken.Add].includes(result.r.op)) {
+                result.r = { typ: exports.EnumToken.ParensTokenType, chi: [result.r] };
+            }
+        }
+        return result;
+    }
+    function isScalarToken(token) {
+        return token.typ != exports.EnumToken.BinaryExpressionTokenType && token.typ != exports.EnumToken.ParensTokenType && token.typ != exports.EnumToken.FunctionTokenType;
+    }
+    /**
+     *
+     * generate binary expression tree
+     * @param tokens
+     */
+    function buildExpression(tokens) {
+        return factor(factor(tokens.filter(t => t.typ != exports.EnumToken.WhitespaceTokenType), ['/', '*']), ['+', '-'])[0];
+    }
+    function getArithmeticOperation(op) {
+        if (op == '+') {
+            return exports.EnumToken.Add;
+        }
+        if (op == '-') {
+            return exports.EnumToken.Sub;
+        }
+        if (op == '/') {
+            return exports.EnumToken.Div;
+        }
+        return exports.EnumToken.Mul;
+    }
+    /**
+     *
+     * generate binary expression tree
+     * @param token
+     */
+    function factorToken(token) {
+        if (token.typ == exports.EnumToken.ParensTokenType || (token.typ == exports.EnumToken.FunctionTokenType && token.val == 'calc')) {
+            if (token.typ == exports.EnumToken.FunctionTokenType && token.val == 'calc') {
+                token = { ...token, typ: exports.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 = [exports.EnumToken.Add, exports.EnumToken.Sub, exports.EnumToken.Div, exports.EnumToken.Mul];
+        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 == exports.EnumToken.LiteralTokenType && ops.includes(tokens[i].val))) {
+                tokens.splice(i - 1, 3, {
+                    typ: exports.EnumToken.BinaryExpressionTokenType,
+                    op: isOp ? tokens[i].typ : getArithmeticOperation(tokens[i].val),
+                    l: factorToken(tokens[i - 1]),
+                    r: factorToken(tokens[i + 1])
+                });
+                i--;
             }
+        }
+        return tokens;
+    }
+
+    var allFeatures = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        ComputeCalcExpression: ComputeCalcExpression,
+        ComputeShorthand: ComputeShorthand,
+        InlineCssVariables: InlineCssVariables
+    });
+
+    const combinators = ['+', '>', '~'];
+    const notEndingWith = ['(', '['].concat(combinators);
+    const definedPropertySettings = { configurable: true, enumerable: false, writable: true };
+    // @ts-ignore
+    const features = Object.values(allFeatures).sort((a, b) => a.ordering - b.ordering);
+    function minify(ast, options = {}, recursive = false, errors, nestingContent, context = {}) {
+        if (!('nodes' in context)) {
+            context.nodes = new WeakSet;
+        }
+        if (context.nodes.has(ast)) {
+            // console.error('skipped', ast.typ);
+            return ast;
+        }
+        context.nodes.add(ast);
+        if (!('features' in options)) {
             // @ts-ignore
-            selector1 = selector1.reduce(reduce, []);
+            options = { removeDuplicateDeclarations: true, computeShorthand: true, computeCalcExpression: true, features: [], ...options };
             // @ts-ignore
-            selector2 = selector2.reduce(reduce, []);
-            return selector1 == null || selector2 == null ? null : {
-                eq: eq(selector1, selector2),
-                match,
-                selector1,
-                selector2
-            };
+            for (const feature of features) {
+                feature.register(options);
+            }
         }
-        function fixSelector(node) {
-            // @ts-ignore
-            if (node.sel.includes('&')) {
-                const attributes = parseString(node.sel);
-                for (const attr of walkValues(attributes)) {
-                    if (attr.value.typ == 'Pseudo-class-func' && attr.value.val == ':is') {
-                        let i = attr.value.chi.length;
-                        while (i--) {
-                            if (attr.value.chi[i].typ == 'Literal' && attr.value.chi[i].val == '&') {
-                                attr.value.chi.splice(i, 1);
-                            }
-                        }
-                    }
+        function reducer(acc, curr, index, array) {
+            // trim :is()
+            if (array.length == 1 && array[0][0] == ':is(' && array[0].at(-1) == ')') {
+                curr = curr.slice(1, -1);
+            }
+            if (curr[0] == '&') {
+                if (curr[1] == ' ' && !isIdent(curr[2]) && !isFunction(curr[2])) {
+                    curr.splice(0, 2);
+                }
+                else if (combinators.includes(curr[1])) {
+                    curr.splice(0, 1);
                 }
-                node.sel = attributes.reduce((acc, curr) => acc + renderToken(curr), '');
             }
+            else if (ast.typ == 4 /* NodeType.RuleNodeType */ && (isIdent(curr[0]) || isFunction(curr[0]))) {
+                curr.unshift('&', ' ');
+            }
+            acc.push(curr.join(''));
+            return acc;
         }
         // @ts-ignore
-        if (('chi' in ast) && ast.chi?.length > 0) {
+        if ('chi' in ast && ast.chi.length > 0) {
             if (!nestingContent) {
-                nestingContent = options.nestingRules && ast.typ == 'Rule';
+                nestingContent = options.nestingRules && ast.typ == 4 /* NodeType.RuleNodeType */;
             }
             let i = 0;
             let previous;
@@ -4316,7 +4843,7 @@
             // @ts-ignore
             for (; i < ast.chi.length; i++) {
                 // @ts-ignore
-                if (ast.chi[i].typ == 'Comment') {
+                if (ast.chi[i].typ == 0 /* NodeType.CommentNodeType */) {
                     continue;
                 }
                 // @ts-ignore
@@ -4328,10 +4855,10 @@
                     i--;
                     continue;
                 }
-                if (node.typ == 'AtRule' && node.nam == 'font-face') {
+                if (node.typ == 3 /* NodeType.AtRuleNodeType */ && node.nam == 'font-face') {
                     continue;
                 }
-                if (node.typ == 'AtRule') {
+                if (node.typ == 3 /* NodeType.AtRuleNodeType */) {
                     if (node.nam == 'media' && node.val == 'all') {
                         // @ts-ignore
                         ast.chi?.splice(i, 1, ...node.chi);
@@ -4339,47 +4866,41 @@
                         continue;
                     }
                     // @ts-ignore
-                    if (previous?.typ == 'AtRule' &&
+                    if (previous?.typ == 3 /* NodeType.AtRuleNodeType */ &&
                         previous.nam == node.nam &&
                         previous.val == node.val) {
                         if ('chi' in node) {
                             // @ts-ignore
                             previous.chi.push(...node.chi);
                         }
-                        // else {
                         ast?.chi?.splice(i--, 1);
                         continue;
-                        // }
                     }
                     // @ts-ignore
-                    if (hasDeclaration(node)) {
-                        // @ts-ignore
-                        minifyRule(node);
-                    }
-                    else {
-                        minify(node, options, recursive, errors, nestingContent);
+                    if (!hasDeclaration(node)) {
+                        minify(node, options, recursive, errors, nestingContent, context);
                     }
                     previous = node;
                     nodeIndex = i;
                     continue;
                 }
                 // @ts-ignore
-                if (node.typ == 'Rule') {
+                if (node.typ == 4 /* NodeType.RuleNodeType */) {
                     reduceRuleSelector(node);
                     let wrapper;
                     let match;
                     // @ts-ignore
                     if (options.nestingRules) {
                         // @ts-ignore
-                        if (previous?.typ == 'Rule') {
+                        if (previous?.typ == 4 /* NodeType.RuleNodeType */) {
                             // @ts-ignore
                             reduceRuleSelector(previous);
                             // @ts-ignore
-                            match = matchSelectors(previous.raw, node.raw, ast.typ);
+                            match = matchSelectors(previous.raw, node.raw, ast.typ, errors);
                             // @ts-ignore
                             if (match != null) {
                                 // @ts-ignore
-                                wrapper = wrapNodes(previous, node, match, ast, i, nodeIndex);
+                                wrapper = wrapNodes(previous, node, match, ast, reducer, i, nodeIndex);
                                 nodeIndex = i - 1;
                                 // @ts-ignore
                                 previous = ast.chi[nodeIndex];
@@ -4392,26 +4913,23 @@
                                 // @ts-ignore
                                 const nextNode = ast.chi[i];
                                 // @ts-ignore
-                                if (nextNode.typ != 'Rule') {
-                                    // i--;
-                                    // previous = wrapper;
-                                    // nodeIndex = i;
+                                if (nextNode.typ != 4 /* NodeType.RuleNodeType */) {
                                     break;
                                 }
                                 reduceRuleSelector(nextNode);
                                 // @ts-ignore
-                                match = matchSelectors(wrapper.raw, nextNode.raw, ast.typ);
+                                match = matchSelectors(wrapper.raw, nextNode.raw, ast.typ, errors);
                                 // @ts-ignore
                                 if (match == null) {
                                     break;
                                 }
                                 // @ts-ignore
-                                wrapper = wrapNodes(wrapper, nextNode, match, ast, i, nodeIndex);
+                                wrapper = wrapNodes(wrapper, nextNode, match, ast, reducer, i, nodeIndex);
                             }
                             nodeIndex = --i;
                             // @ts-ignore
                             previous = ast.chi[nodeIndex];
-                            minify(wrapper, options, recursive, errors, nestingContent);
+                            minify(wrapper, options, recursive, errors, nestingContent, context);
                             continue;
                         }
                         // @ts-ignore
@@ -4449,7 +4967,7 @@
                                     curr.splice(0, 2);
                                 }
                                 else {
-                                    if (ast.typ != 'Rule' && combinators.includes(curr[1])) {
+                                    if (ast.typ != 4 /* NodeType.RuleNodeType */ && combinators.includes(curr[1])) {
                                         wrap = false;
                                     }
                                     else {
@@ -4466,7 +4984,7 @@
                             return acc;
                         }, []);
                         if (!wrap) {
-                            wrap = selector.some(s => s[0] != '&');
+                            wrap = selector.some((s) => s[0] != '&');
                         }
                         let rule = selector.map(s => {
                             if (s[0] == '&') {
@@ -4497,37 +5015,36 @@
                             let k = previous.chi.length;
                             while (k-- > 0) {
                                 // @ts-ignore
-                                if (previous.chi[k].typ == 'Comment') {
+                                if (previous.chi[k].typ == 0 /* NodeType.CommentNodeType */) {
                                     continue;
                                 }
                                 // @ts-ignore
-                                shouldMerge = previous.chi[k].typ == 'Declaration';
+                                shouldMerge = previous.chi[k].typ == 5 /* NodeType.DeclarationNodeType */;
                                 break;
                             }
                             if (shouldMerge) {
                                 // @ts-ignore
-                                if ((node.typ == 'Rule' && node.sel == previous.sel) ||
+                                if ((node.typ == 4 /* NodeType.RuleNodeType */ && node.sel == previous.sel) ||
                                     // @ts-ignore
-                                    (node.typ == 'AtRule') && node.val != 'font-face' && node.val == previous.val) {
+                                    (node.typ == 3 /* NodeType.AtRuleNodeType */) && node.val != 'font-face' && node.val == previous.val) {
                                     // @ts-ignore
                                     node.chi.unshift(...previous.chi);
                                     // @ts-ignore
                                     ast.chi.splice(nodeIndex, 1);
                                     // @ts-ignore
-                                    if (hasDeclaration(node)) {
+                                    if (!hasDeclaration(node)) {
                                         // @ts-ignore
-                                        minifyRule(node);
-                                    }
-                                    else {
-                                        minify(node, options, recursive, errors, nestingContent);
+                                        // minifyRule(node, <MinifyOptions>options, ast, context);
+                                        // } else {
+                                        minify(node, options, recursive, errors, nestingContent, context);
                                     }
                                     i--;
                                     previous = node;
                                     nodeIndex = i;
                                     continue;
                                 }
-                                else if (node.typ == 'Rule' && previous?.typ == 'Rule') {
-                                    const intersect = diff(previous, node, options);
+                                else if (node.typ == 4 /* NodeType.RuleNodeType */ && previous?.typ == 4 /* NodeType.RuleNodeType */) {
+                                    const intersect = diff(previous, node, reducer, options);
                                     if (intersect != null) {
                                         if (intersect.node1.chi.length == 0) {
                                             // @ts-ignore
@@ -4559,24 +5076,22 @@
                         // @ts-ignore
                         if (recursive && previous != node) {
                             // @ts-ignore
-                            if (hasDeclaration(previous)) {
+                            if (!hasDeclaration(previous)) {
                                 // @ts-ignore
-                                minifyRule(previous);
-                            }
-                            else {
-                                minify(previous, options, recursive, errors, nestingContent);
+                                // minifyRule(previous, <MinifyOptions>options, ast, context);
+                                // } else {
+                                minify(previous, options, recursive, errors, nestingContent, context);
                             }
                         }
                     }
                     else {
                         if ('chi' in previous) {
                             // @ts-ignore
-                            if (hasDeclaration(previous)) {
+                            if (!hasDeclaration(previous)) {
                                 // @ts-ignore
-                                minifyRule(previous);
-                            }
-                            else {
-                                minify(previous, options, recursive, errors, nestingContent);
+                                // minifyRule(previous, <MinifyOptions>options, ast, context);
+                                // } else {
+                                minify(previous, options, recursive, errors, nestingContent, context);
                             }
                         }
                     }
@@ -4585,7 +5100,7 @@
                     // @ts-ignore
                     previous != null &&
                     // previous.optimized != null &&
-                    previous.typ == 'Rule' &&
+                    previous.typ == 4 /* NodeType.RuleNodeType */ &&
                     previous.sel.includes('&')) {
                     fixSelector(previous);
                 }
@@ -4595,13 +5110,10 @@
             // @ts-ignore
             if (recursive && node != null && ('chi' in node)) {
                 // @ts-ignore
-                if (node.chi.some(n => n.typ == 'Declaration')) {
-                    minifyRule(node);
-                }
-                else {
+                if (!node.chi.some(n => n.typ == 5 /* NodeType.DeclarationNodeType */)) {
                     // @ts-ignore
-                    if (!(node.typ == 'AtRule' && node.nam != 'font-face')) {
-                        minify(node, options, recursive, errors, nestingContent);
+                    if (!(node.typ == 3 /* NodeType.AtRuleNodeType */ && node.nam != 'font-face')) {
+                        minify(node, options, recursive, errors, nestingContent, context);
                     }
                 }
             }
@@ -4609,11 +5121,46 @@
                 // @ts-ignore
                 node != null &&
                 // previous.optimized != null &&
-                node.typ == 'Rule' &&
+                node.typ == 4 /* NodeType.RuleNodeType */ &&
                 node.sel.includes('&')) {
                 fixSelector(node);
             }
         }
+        if (ast.typ == 2 /* NodeType.StyleSheetNodeType */) {
+            let parent;
+            let parents = [ast];
+            while (parents.length > 0) {
+                parent = parents.shift();
+                // @ts-ignore
+                for (let k = 0; k < parent.chi.length; k++) {
+                    // @ts-ignore
+                    const node = parent.chi[k];
+                    if (!('chi' in node) || node.typ == 2 /* NodeType.StyleSheetNodeType */ || (node.typ == 3 /* NodeType.AtRuleNodeType */ && node.nam == 'font-face')) {
+                        continue;
+                    }
+                    // @ts-ignore
+                    if (node.chi.length > 0) {
+                        parents.push(node);
+                        Object.defineProperty(node, 'parent', { ...definedPropertySettings, value: parent });
+                        for (const feature of options.features) {
+                            feature.run(node, options, parent, context);
+                        }
+                    }
+                    // @ts-ignore
+                    if (options.removeEmpty && node.chi.length == 0) {
+                        // @ts-ignore
+                        parent.chi.splice(k, 1);
+                        k--;
+                    }
+                }
+            }
+            for (const feature of options.features) {
+                if ('cleanup' in feature) {
+                    // @ts-ignore
+                    feature.cleanup(ast, options, context);
+                }
+            }
+        }
         return ast;
     }
     function reduceSelector(selector) {
@@ -4699,37 +5246,14 @@
         // @ts-ignore
         for (let i = 0; i < node.chi?.length; i++) {
             // @ts-ignore
-            if (node.chi[i].typ == 'Comment') {
+            if (node.chi[i].typ == 0 /* NodeType.CommentNodeType */) {
                 continue;
             }
             // @ts-ignore
-            return node.chi[i].typ == 'Declaration';
+            return node.chi[i].typ == 5 /* NodeType.DeclarationNodeType */;
         }
         return true;
     }
-    function minifyRule(ast) {
-        // @ts-ignore
-        if (!('chi' in ast) || ast.chi?.length <= 1) {
-            return ast;
-        }
-        // @ts-ignore
-        const j = ast.chi.length;
-        let k = 0;
-        let properties = new PropertyList();
-        // @ts-ignore
-        for (; k < j; k++) {
-            // @ts-ignore
-            const node = ast.chi[k];
-            if (node.typ == 'Comment' || node.typ == 'Declaration') {
-                properties.add(node);
-                continue;
-            }
-            break;
-        }
-        // @ts-ignore
-        ast.chi = [...properties].concat(ast.chi.slice(k));
-        return ast;
-    }
     function splitRule(buffer) {
         const result = [[]];
         let str = '';
@@ -4818,6 +5342,300 @@
         }
         return result;
     }
+    function matchSelectors(selector1, selector2, parentType, errors) {
+        let match = [[]];
+        const j = Math.min(selector1.reduce((acc, curr) => Math.min(acc, curr.length), selector1.length > 0 ? selector1[0].length : 0), selector2.reduce((acc, curr) => Math.min(acc, curr.length), selector2.length > 0 ? selector2[0].length : 0));
+        let i = 0;
+        let k;
+        let l;
+        let token;
+        let matching = true;
+        let matchFunction = 0;
+        let inAttr = 0;
+        for (; i < j; i++) {
+            k = 0;
+            token = selector1[0][i];
+            for (; k < selector1.length; k++) {
+                if (selector1[k][i] != token) {
+                    matching = false;
+                    break;
+                }
+            }
+            if (matching) {
+                l = 0;
+                for (; l < selector2.length; l++) {
+                    if (selector2[l][i] != token) {
+                        matching = false;
+                        break;
+                    }
+                }
+            }
+            if (!matching) {
+                break;
+            }
+            if (token == ',') {
+                match.push([]);
+            }
+            else {
+                if (token.endsWith('(')) {
+                    matchFunction++;
+                }
+                if (token.endsWith('[')) {
+                    inAttr++;
+                }
+                else if (token == ')') {
+                    matchFunction--;
+                }
+                else if (token == ']') {
+                    inAttr--;
+                }
+                match.at(-1).push(token);
+            }
+        }
+        // invalid function
+        if (matchFunction != 0 || inAttr != 0) {
+            return null;
+        }
+        if (parentType != 4 /* NodeType.RuleNodeType */) {
+            for (const part of match) {
+                if (part.length > 0 && combinators.includes(part[0].charAt(0))) {
+                    return null;
+                }
+            }
+        }
+        if (match.length > 1) {
+            errors?.push({
+                action: 'ignore',
+                message: `minify: unsupported multilevel matching\n${JSON.stringify({
+                match,
+                selector1,
+                selector2
+            }, null, 1)}`
+            });
+            return null;
+        }
+        for (const part of match) {
+            while (part.length > 0) {
+                const token = part.at(-1);
+                if (token == ' ' || combinators.includes(token) || notEndingWith.includes(token.at(-1))) {
+                    part.pop();
+                    continue;
+                }
+                break;
+            }
+        }
+        if (match.every(t => t.length == 0)) {
+            return null;
+        }
+        if (eq([['&']], match)) {
+            return null;
+        }
+        function reduce(acc, curr) {
+            if (acc === null) {
+                return null;
+            }
+            let hasCompoundSelector = true;
+            curr = curr.slice(match[0].length);
+            while (curr.length > 0) {
+                if (curr[0] == ' ') {
+                    hasCompoundSelector = false;
+                    curr.unshift('&');
+                    continue;
+                }
+                break;
+            }
+            // invalid function match
+            if (curr.length > 0 && curr[0].endsWith('(') && curr.at(-1) != ')') {
+                return null;
+            }
+            if (curr.length == 1 && combinators.includes(curr[0].charAt(0))) {
+                return null;
+            }
+            if (hasCompoundSelector && curr.length > 0) {
+                hasCompoundSelector = !['&'].concat(combinators).includes(curr[0].charAt(0));
+            }
+            if (curr[0] == ':is(') {
+                let inFunction = 0;
+                let canReduce = true;
+                const isCompound = curr.reduce((acc, token, index) => {
+                    if (index == 0) {
+                        inFunction++;
+                        canReduce = curr[1] == '&';
+                    }
+                    else if (token.endsWith('(')) {
+                        if (inFunction == 0) {
+                            canReduce = false;
+                        }
+                        inFunction++;
+                    }
+                    else if (token == ')') {
+                        inFunction--;
+                    }
+                    else if (token == ',') {
+                        if (!canReduce) {
+                            canReduce = curr[index + 1] == '&';
+                        }
+                        acc.push([]);
+                    }
+                    else
+                        acc.at(-1)?.push(token);
+                    return acc;
+                }, [[]]);
+                if (inFunction > 0) {
+                    canReduce = false;
+                }
+                if (canReduce) {
+                    curr = isCompound.reduce((acc, curr) => {
+                        if (acc.length > 0) {
+                            acc.push(',');
+                        }
+                        acc.push(...curr);
+                        return acc;
+                    }, []);
+                }
+            }
+            // @todo: check hasCompoundSelector && curr[0] == '&' && curr[1] == ' '
+            acc.push(match.length == 0 ? ['&'] : (hasCompoundSelector && curr[0] != '&' && (curr.length == 0 || !combinators.includes(curr[0].charAt(0))) ? ['&'].concat(curr) : curr));
+            return acc;
+        }
+        // @ts-ignore
+        selector1 = selector1.reduce(reduce, []);
+        // @ts-ignore
+        selector2 = selector2.reduce(reduce, []);
+        return selector1 == null || selector2 == null ? null : {
+            eq: eq(selector1, selector2),
+            match,
+            selector1,
+            selector2
+        };
+    }
+    function fixSelector(node) {
+        // @ts-ignore
+        if (node.sel.includes('&')) {
+            const attributes = parseString(node.sel);
+            for (const attr of walkValues(attributes)) {
+                if (attr.value.typ == exports.EnumToken.PseudoClassFuncTokenType && attr.value.val == ':is') {
+                    let i = attr.value.chi.length;
+                    while (i--) {
+                        if (attr.value.chi[i].typ == exports.EnumToken.LiteralTokenType && attr.value.chi[i].val == '&') {
+                            attr.value.chi.splice(i, 1);
+                        }
+                    }
+                }
+            }
+            node.sel = attributes.reduce((acc, curr) => acc + renderToken(curr), '');
+        }
+    }
+    function wrapNodes(previous, node, match, ast, reducer, i, nodeIndex) {
+        // @ts-ignore
+        let pSel = match.selector1.reduce(reducer, []).join(',');
+        // @ts-ignore
+        let nSel = match.selector2.reduce(reducer, []).join(',');
+        // @ts-ignore
+        const wrapper = { ...previous, chi: [], sel: match.match.reduce(reducer, []).join(',') };
+        // @ts-ignore
+        Object.defineProperty(wrapper, 'raw', {
+            ...definedPropertySettings,
+            // @ts-ignore
+            value: match.match.map(t => t.slice())
+        });
+        if (pSel == '&' || pSel === '') {
+            // @ts-ignore
+            wrapper.chi.push(...previous.chi);
+            // @ts-ignore
+            if ((nSel == '&' || nSel === '')) {
+                // @ts-ignore
+                wrapper.chi.push(...node.chi);
+            }
+            else {
+                // @ts-ignore
+                wrapper.chi.push(node);
+            }
+        }
+        else {
+            // @ts-ignore
+            wrapper.chi.push(previous, node);
+        }
+        // @ts-ignore
+        ast.chi.splice(i, 1, wrapper);
+        // @ts-ignore
+        ast.chi.splice(nodeIndex, 1);
+        // @ts-ignore
+        previous.sel = pSel;
+        // @ts-ignore
+        previous.raw = match.selector1;
+        // @ts-ignore
+        node.sel = nSel;
+        // @ts-ignore
+        node.raw = match.selector2;
+        reduceRuleSelector(wrapper);
+        return wrapper;
+    }
+    function diff(n1, n2, reducer, options = {}) {
+        let node1 = n1;
+        let node2 = n2;
+        let exchanged = false;
+        if (node1.chi.length > node2.chi.length) {
+            const t = node1;
+            node1 = node2;
+            node2 = t;
+            exchanged = true;
+        }
+        let i = node1.chi.length;
+        let j = node2.chi.length;
+        if (i == 0 || j == 0) {
+            // @ts-ignore
+            return null;
+        }
+        // @ts-ignore
+        const raw1 = node1.raw;
+        // @ts-ignore
+        const raw2 = node2.raw;
+        // @ts-ignore
+        node1 = { ...node1, chi: node1.chi.slice() };
+        node2 = { ...node2, chi: node2.chi.slice() };
+        if (raw1 != null) {
+            Object.defineProperty(node1, 'raw', { ...definedPropertySettings, value: raw1 });
+        }
+        if (raw2 != null) {
+            Object.defineProperty(node2, 'raw', { ...definedPropertySettings, value: raw2 });
+        }
+        const intersect = [];
+        while (i--) {
+            if (node1.chi[i].typ == 0 /* NodeType.CommentNodeType */) {
+                continue;
+            }
+            j = node2.chi.length;
+            if (j == 0) {
+                break;
+            }
+            while (j--) {
+                if (node2.chi[j].typ == 0 /* NodeType.CommentNodeType */) {
+                    continue;
+                }
+                if (node1.chi[i].nam == node2.chi[j].nam) {
+                    if (eq(node1.chi[i], node2.chi[j])) {
+                        intersect.push(node1.chi[i]);
+                        node1.chi.splice(i, 1);
+                        node2.chi.splice(j, 1);
+                        break;
+                    }
+                }
+            }
+        }
+        // @ts-ignore
+        const result = (intersect.length == 0 ? null : {
+            ...node1,
+            // @ts-ignore
+            sel: [...new Set([...(n1?.raw?.reduce(reducer, []) || splitRule(n1.sel)).concat(n2?.raw?.reduce(reducer, []) || splitRule(n2.sel))])].join(','),
+            chi: intersect.reverse()
+        });
+        if (result == null || [n1, n2].reduce((acc, curr) => curr.chi.length == 0 ? acc : acc + doRender(curr, options).code.length, 0) <= [node1, node2, result].reduce((acc, curr) => curr.chi.length == 0 ? acc : acc + doRender(curr, options).code.length, 0)) {
+            // @ts-ignore
+            return null;
+        }
+        return { result, node1: exchanged ? node2 : node1, node2: exchanged ? node1 : node2 };
+    }
     function reduceRuleSelector(node) {
         if (node.raw == null) {
             Object.defineProperty(node, 'raw', { ...definedPropertySettings, value: splitRule(node.sel) });
@@ -4853,25 +5671,6 @@
         }
     }
 
-    async function transform$1(css, options = {}) {
-        options = { minify: true, removeEmpty: true, ...options };
-        const startTime = performance.now();
-        return parse$1(css, options).then((parseResult) => {
-            const rendered = render(parseResult.ast, options);
-            return {
-                ...parseResult,
-                ...rendered,
-                errors: parseResult.errors.concat(rendered.errors),
-                stats: {
-                    bytesOut: rendered.code.length,
-                    ...parseResult.stats,
-                    render: rendered.stats.total,
-                    total: `${(performance.now() - startTime).toFixed(2)}ms`
-                }
-            };
-        });
-    }
-
     const matchUrl = /^(https?:)?\/\//;
     function dirname(path) {
         if (path == '/' || path === '') {
@@ -4988,24 +5787,46 @@
         return fetch(resolve(url, currentFile).absolute).then(parseResponse);
     }
 
-    async function parse(iterator, opt = {}) {
-        return parse$1(iterator, Object.assign(opt, {
+    function render(data, options = {}) {
+        return doRender(data, Object.assign(options, {
             load,
             resolve,
-            cwd: opt.cwd ?? self.location.pathname.endsWith('/') ? self.location.pathname : dirname(self.location.pathname)
+            dirname,
+            cwd: options.cwd ?? self.location.pathname.endsWith('/') ? self.location.pathname : dirname(self.location.pathname)
         }));
     }
-    async function transform(css, options = {}) {
-        return transform$1(css, Object.assign(options, {
+    async function parse(iterator, opt = {}) {
+        return doParse(iterator, Object.assign(opt, {
             load,
             resolve,
-            cwd: options.cwd ?? self.location.pathname.endsWith('/') ? self.location.pathname : dirname(self.location.pathname)
+            dirname,
+            cwd: opt.cwd ?? self.location.pathname.endsWith('/') ? self.location.pathname : dirname(self.location.pathname)
         }));
     }
+    async function transform(css, options = {}) {
+        options = { minify: true, removeEmpty: true, removeCharset: true, ...options };
+        const startTime = performance.now();
+        return parse(css, options).then((parseResult) => {
+            const rendered = render(parseResult.ast, options);
+            return {
+                ...parseResult,
+                ...rendered,
+                errors: parseResult.errors.concat(rendered.errors),
+                stats: {
+                    bytesOut: rendered.code.length,
+                    ...parseResult.stats,
+                    render: rendered.stats.total,
+                    total: `${(performance.now() - startTime).toFixed(2)}ms`
+                }
+            };
+        });
+    }
 
     exports.colorsFunc = colorsFunc;
     exports.combinators = combinators;
     exports.dirname = dirname;
+    exports.doParse = doParse;
+    exports.doRender = doRender;
     exports.expand = expand;
     exports.funcList = funcList;
     exports.getConfig = getConfig;
@@ -5035,10 +5856,11 @@
     exports.matchType = matchType;
     exports.matchUrl = matchUrl;
     exports.minify = minify;
-    exports.minifyRule = minifyRule;
     exports.parse = parse;
     exports.parseDimension = parseDimension;
     exports.parseString = parseString;
+    exports.parseTokens = parseTokens;
+    exports.reduceNumber = reduceNumber;
     exports.reduceSelector = reduceSelector;
     exports.render = render;
     exports.renderToken = renderToken;