@tbela99/css-parser 0.0.1 → 0.1.0

package/dist/index.cjs

@@ -2,6 +2,93 @@
 
 var promises = require('fs/promises');
 
+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',
@@ -314,18 +401,18 @@ function rgb2Hex(token) {
         // @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;
@@ -337,21 +424,21 @@ function hsl2Hex(token) {
     // @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'), '')}`;
@@ -363,21 +450,21 @@ function hwb2hex(token) {
     // @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);
@@ -394,19 +481,19 @@ function cmyk2hex(token) {
     // @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))),
@@ -417,12 +504,12 @@ function cmyk2hex(token) {
         // @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
@@ -495,6 +582,97 @@ function hsl2rgb(h, s, l, a = null) {
     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();
@@ -513,35 +691,88 @@ function reduceNumber(val) {
     }
     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));
     }
@@ -551,46 +782,61 @@ function doRender(data, options, errors, reducer, level = 0, indents = []) {
     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;
@@ -603,28 +849,40 @@ function doRender(data, options, errors, reducer, level = 0, indents = []) {
             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';
                 }
@@ -664,54 +922,69 @@ function renderToken(token, options = {}, reducer, errors) {
             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;
@@ -756,36 +1029,58 @@ function renderToken(token, options = {}, reducer, errors) {
                 }
             }
             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)}` });
@@ -818,17 +1113,17 @@ function isFrequency(dimension) {
     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;
             }
         }
@@ -997,29 +1292,29 @@ function parseDimension(name) {
         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;
 }
@@ -1906,340 +2201,144 @@ const getConfig = () => config$1;
 
 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 = '';
@@ -2247,9 +2346,9 @@ function* tokenize(iterator) {
         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;
             }
@@ -2274,7 +2373,7 @@ function* tokenize(iterator) {
                     break;
                 }
             }
-            yield pushToken('', 'Whitespace');
+            yield pushToken('', exports.EnumToken.WhitespaceTokenType);
             buffer = '';
         }
         switch (value) {
@@ -2294,7 +2393,7 @@ function* tokenize(iterator) {
                         if (value == '*') {
                             buffer += value;
                             if (peek() == '/') {
-                                yield pushToken(buffer + next(), 'Comment');
+                                yield pushToken(buffer + next(), exports.EnumToken.CommentTokenType);
                                 buffer = '';
                                 break;
                             }
@@ -2303,7 +2402,7 @@ function* tokenize(iterator) {
                             buffer += value;
                         }
                     }
-                    yield pushToken(buffer, 'Bad-comment');
+                    yield pushToken(buffer, exports.EnumToken.BadCommentTokenType);
                     buffer = '';
                 }
                 break;
@@ -2313,7 +2412,7 @@ function* tokenize(iterator) {
                     buffer = '';
                 }
                 if (peek() == '=') {
-                    yield pushToken('', 'Lte');
+                    yield pushToken('', exports.EnumToken.LteTokenType);
                     next();
                     break;
                 }
@@ -2327,10 +2426,10 @@ function* tokenize(iterator) {
                         }
                     }
                     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 = '';
                 }
@@ -2363,7 +2462,7 @@ function* tokenize(iterator) {
                 }
                 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;
                 }
@@ -2379,11 +2478,11 @@ function* tokenize(iterator) {
                     buffer = '';
                 }
                 if (peek() == '=') {
-                    yield pushToken('', 'Gte');
+                    yield pushToken('', exports.EnumToken.GteTokenType);
                     next();
                 }
                 else {
-                    yield pushToken('', 'Gt');
+                    yield pushToken('', exports.EnumToken.GtTokenType);
                 }
                 consumeWhiteSpace();
                 break;
@@ -2397,6 +2496,7 @@ function* tokenize(iterator) {
                 buffer += value;
                 break;
             case '+':
+            case '*':
             case ':':
             case ',':
             case '=':
@@ -2410,7 +2510,7 @@ function* tokenize(iterator) {
                 }
                 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))) {
@@ -2422,7 +2522,7 @@ function* tokenize(iterator) {
                     yield pushToken(buffer);
                     buffer = '';
                 }
-                yield pushToken('', 'End-parens');
+                yield pushToken('', exports.EnumToken.EndParensTokenType);
                 break;
             case '(':
                 if (buffer.length == 0) {
@@ -2460,7 +2560,7 @@ function* tokenize(iterator) {
                                         }
                                     }
                                     if (value === '') {
-                                        yield pushToken(buffer, 'Bad-string');
+                                        yield pushToken(buffer, exports.EnumToken.BadUrlTokenType);
                                         buffer = '';
                                         break;
                                     }
@@ -2487,7 +2587,7 @@ function* tokenize(iterator) {
                                         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;
                                     }
@@ -2495,8 +2595,8 @@ function* tokenize(iterator) {
                                 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;
                                 }
@@ -2507,15 +2607,15 @@ function* tokenize(iterator) {
                                         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;
@@ -2530,8 +2630,8 @@ function* tokenize(iterator) {
                             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;
                             }
@@ -2567,7 +2667,7 @@ function* tokenize(iterator) {
                                     }
                                     buffer += next();
                                 }
-                                yield pushToken(buffer, 'Bad-url-token');
+                                yield pushToken(buffer, exports.EnumToken.BadUrlTokenType);
                                 buffer = '';
                                 break;
                             }
@@ -2575,7 +2675,7 @@ function* tokenize(iterator) {
                         }
                     }
                     if (buffer !== '') {
-                        yield pushToken(buffer, 'Url-token');
+                        yield pushToken(buffer, exports.EnumToken.UrlTokenTokenType);
                         buffer = '';
                         break;
                     }
@@ -2601,7 +2701,7 @@ function* tokenize(iterator) {
                     buffer = '';
                 }
                 if (peek(9) == 'important') {
-                    yield pushToken('', 'Important');
+                    yield pushToken('', exports.EnumToken.ImportantTokenType);
                     next(9);
                     buffer = '';
                     break;
@@ -2620,33 +2720,40 @@ function* tokenize(iterator) {
 }
 
 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 = [];
@@ -2668,10 +2775,14 @@ async function parse$1(iterator, opt = {}) {
         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 = {
@@ -2684,7 +2795,7 @@ async function parse$1(iterator, opt = {}) {
                     tokens[i].loc = loc;
                 }
             }
-            else if (tokens[i].typ != 'Whitespace') {
+            else if (tokens[i].typ != exports.EnumToken.WhitespaceTokenType) {
                 break;
             }
         }
@@ -2693,28 +2804,33 @@ async function parse$1(iterator, opt = {}) {
             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') {
@@ -2723,10 +2839,10 @@ async function parse$1(iterator, opt = {}) {
                     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;
                         }
@@ -2739,33 +2855,33 @@ async function parse$1(iterator, opt = {}) {
                     }
                 }
                 // @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
@@ -2773,6 +2889,7 @@ async function parse$1(iterator, opt = {}) {
                             });
                             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) {
@@ -2782,7 +2899,7 @@ async function parse$1(iterator, opt = {}) {
                         }
                         catch (error) {
                             // @ts-ignore
-                            errors.push({ action: 'ignore', message: 'parse: ' + error.message, error });
+                            errors.push({ action: 'ignore', message: 'doParse: ' + error.message, error });
                         }
                     }
                 }
@@ -2795,12 +2912,12 @@ async function parse$1(iterator, opt = {}) {
                 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 = {
@@ -2812,15 +2929,15 @@ async function parse$1(iterator, opt = {}) {
             }
             // @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) ||
@@ -2841,7 +2958,7 @@ async function parse$1(iterator, opt = {}) {
                     return acc;
                 }, uniq);
                 const node = {
-                    typ: 'Rule',
+                    typ: 4 /* NodeType.RuleNodeType */,
                     // @ts-ignore
                     sel: [...uniq.keys()].join(','),
                     chi: []
@@ -2866,10 +2983,10 @@ async function parse$1(iterator, opt = {}) {
                 // @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,
@@ -2886,46 +3003,38 @@ async function parse$1(iterator, opt = {}) {
                 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;
@@ -2945,8 +3054,8 @@ async function parse$1(iterator, opt = {}) {
     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;
         }
@@ -3006,9 +3115,12 @@ async function parse$1(iterator, opt = {}) {
         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();
@@ -3038,81 +3150,81 @@ function getTokenType(val, hint) {
     }
     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
         };
     }
@@ -3121,97 +3233,97 @@ function getTokenType(val, hint) {
     }
     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
@@ -3222,10 +3334,10 @@ function parseTokens(tokens, options = {}) {
                 }
                 // @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 });
                         }
                     }
                 });
@@ -3236,18 +3348,18 @@ function parseTokens(tokens, options = {}) {
             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;
@@ -3257,7 +3369,7 @@ function parseTokens(tokens, options = {}) {
                 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) {
@@ -3267,29 +3379,55 @@ function parseTokens(tokens, options = {}) {
             // @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--;
@@ -3297,22 +3435,21 @@ function parseTokens(tokens, options = {}) {
                     }
                 }
                 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;
@@ -3323,13 +3460,13 @@ function parseTokens(tokens, options = {}) {
             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);
                     }
@@ -3338,22 +3475,22 @@ function parseTokens(tokens, options = {}) {
             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';
             }
@@ -3362,43 +3499,544 @@ function parseTokens(tokens, options = {}) {
     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
@@ -3407,7 +4045,7 @@ class PropertyMap {
                         // let current: number = 0;
                         const props = this.config.properties[property];
                         for (let i = 0; i < acc.length; i++) {
-                            if (acc[i].typ == 'Comment' || acc[i].typ == 'Whitespace') {
+                            if (acc[i].typ == exports.EnumToken.CommentTokenType || acc[i].typ == exports.EnumToken.WhitespaceTokenType) {
                                 acc.splice(i, 1);
                                 i--;
                                 continue;
@@ -3423,18 +4061,20 @@ class PropertyMap {
                                 else {
                                     if (current == tokens[property].length) {
                                         tokens[property].push([acc[i]]);
-                                        // tokens[property][current].push();
                                     }
                                     else {
-                                        tokens[property][current].push({ typ: 'Whitespace' }, acc[i]);
+                                        tokens[property][current].push({ typ: 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--;
                                     }
@@ -3467,7 +4107,7 @@ class PropertyMap {
                                     tokens[property][current].push(...defaults);
                                 }
                                 else {
-                                    tokens[property][current].push({ typ: 'Whitespace' }, ...defaults);
+                                    tokens[property][current].push({ typ: exports.EnumToken.WhitespaceTokenType }, ...defaults);
                                 }
                             }
                         }
@@ -3478,7 +4118,7 @@ class PropertyMap {
                 if (values.length == 0) {
                     this.declarations = Object.entries(tokens).reduce((acc, curr) => {
                         acc.set(curr[0], {
-                            typ: 'Declaration',
+                            typ: 5 /* NodeType.DeclarationNodeType */,
                             nam: curr[0],
                             val: curr[1].reduce((acc, curr) => {
                                 if (acc.length > 0) {
@@ -3548,7 +4188,10 @@ class PropertyMap {
         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[] =*/
@@ -3572,14 +4215,18 @@ class PropertyMap {
                             }
                             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;
                         }
@@ -3608,7 +4255,7 @@ class PropertyMap {
                 return entry[1].required && !(entry[0] in tokens);
             }) ||
                 // @ts-ignore
-                !Object.values(tokens).every(v => v.filter(t => t.typ != 'Comment').length == count)) {
+                !Object.values(tokens).every(v => v.filter(t => t.typ != exports.EnumToken.CommentTokenType).length == count)) {
                 // @ts-ignore
                 iterable = this.declarations.values();
             }
@@ -3621,7 +4268,7 @@ class PropertyMap {
                         }
                         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;
@@ -3633,8 +4280,8 @@ class PropertyMap {
                         let doFilterDefault = true;
                         if (curr[0] in propertiesConfig.properties) {
                             for (let v of values) {
-                                if (!['Whitespace', 'Comment', 'Iden'].includes(v.typ)
-                                    || (v.typ == 'Iden' && !this.config.properties[curr[0]].default.includes(v.val))) {
+                                if (![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;
                                 }
@@ -3642,10 +4289,10 @@ class PropertyMap {
                         }
                         // 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) {
@@ -3654,7 +4301,7 @@ class PropertyMap {
                                     let i = values.length;
                                     while (i--) {
                                         // @ts-ignore
-                                        if (values[i].typ == 'Iden' && values[i].val in props.mapping) {
+                                        if (values[i].typ == exports.EnumToken.IdenTokenType && values[i].val in props.mapping) {
                                             // @ts-ignore
                                             values.splice(i, 1, ...parseString(props.mapping[values[i].val]));
                                         }
@@ -3663,15 +4310,20 @@ class PropertyMap {
                             }
                             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);
@@ -3687,7 +4339,7 @@ class PropertyMap {
                     if (curr.length == 0 && this.config.default.length > 0) {
                         curr.push(...parseString(this.config.default[0]).reduce((acc, curr) => {
                             if (acc.length > 0) {
-                                acc.push({ typ: 'Whitespace' });
+                                acc.push({ typ: exports.EnumToken.WhitespaceTokenType });
                             }
                             acc.push(curr);
                             return acc;
@@ -3700,12 +4352,15 @@ class PropertyMap {
                     const val = values.reduce((acc, curr) => acc + renderToken(curr, { removeComments: true }), '');
                     if (val in this.config.mapping) {
                         values.length = 0;
-                        // @ts-ignore
-                        values.push({ typ: ['"', "'"].includes(val.charAt(0)) ? 'String' : 'Iden', val: this.config.mapping[val] });
+                        values.push({
+                            typ: ['"', "'"].includes(val.charAt(0)) ? 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]();
@@ -3742,570 +4397,442 @@ class PropertyMap {
 
 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);
-                        }
-                    }
-                }
-                // @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);
+    constructor(options = {}) {
+        for (const key of Object.keys(this.options)) {
+            if (key in options) {
+                // @ts-ignore
+                this.options[key] = options[key];
             }
         }
+        this.declarations = new Map;
     }
-    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);
-        }
+    set(nam, value) {
+        return this.add({ typ: 5 /* NodeType.DeclarationNodeType */, nam, val: Array.isArray(value) ? value : parseString(String(value)) });
     }
-    return tokens.sort((a, b) => {
-        if (a == '&') {
-            return 1;
+    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
+        return { ...l, val: reduceNumber(+l.val + (op == exports.EnumToken.Add ? +r.val : -1 * r.val)) };
+    }
+    else {
         // @ts-ignore
-        const result = (intersect.length == 0 ? null : {
-            ...node1,
+        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;
@@ -4314,7 +4841,7 @@ function minify(ast, options = {}, recursive = false, errors, nestingContent) {
         // @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
@@ -4326,10 +4853,10 @@ function minify(ast, options = {}, recursive = false, errors, nestingContent) {
                 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);
@@ -4337,47 +4864,41 @@ function minify(ast, options = {}, recursive = false, errors, nestingContent) {
                     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];
@@ -4390,26 +4911,23 @@ function minify(ast, options = {}, recursive = false, errors, nestingContent) {
                             // @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
@@ -4447,7 +4965,7 @@ function minify(ast, options = {}, recursive = false, errors, nestingContent) {
                                 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 {
@@ -4464,7 +4982,7 @@ function minify(ast, options = {}, recursive = false, errors, nestingContent) {
                         return acc;
                     }, []);
                     if (!wrap) {
-                        wrap = selector.some(s => s[0] != '&');
+                        wrap = selector.some((s) => s[0] != '&');
                     }
                     let rule = selector.map(s => {
                         if (s[0] == '&') {
@@ -4495,37 +5013,36 @@ function minify(ast, options = {}, recursive = false, errors, nestingContent) {
                         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
@@ -4557,24 +5074,22 @@ function minify(ast, options = {}, recursive = false, errors, nestingContent) {
                     // @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);
                         }
                     }
                 }
@@ -4583,7 +5098,7 @@ function minify(ast, options = {}, recursive = false, errors, nestingContent) {
                 // @ts-ignore
                 previous != null &&
                 // previous.optimized != null &&
-                previous.typ == 'Rule' &&
+                previous.typ == 4 /* NodeType.RuleNodeType */ &&
                 previous.sel.includes('&')) {
                 fixSelector(previous);
             }
@@ -4593,13 +5108,10 @@ function minify(ast, options = {}, recursive = false, errors, nestingContent) {
         // @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);
                 }
             }
         }
@@ -4607,11 +5119,46 @@ function minify(ast, options = {}, recursive = false, errors, nestingContent) {
             // @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) {
@@ -4697,37 +5244,14 @@ function hasDeclaration(node) {
     // @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 = '';
@@ -4816,6 +5340,300 @@ function splitRule(buffer) {
     }
     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) });
@@ -4851,25 +5669,6 @@ function reduceRuleSelector(node) {
     }
 }
 
-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 === '') {
@@ -4980,16 +5779,36 @@ async function load(url, currentFile) {
     return matchUrl.test(resolved.absolute) ? fetch(resolved.absolute).then(parseResponse) : promises.readFile(resolved.absolute, { encoding: 'utf-8' });
 }
 
+function render(data, options = {}) {
+    return doRender(data, Object.assign(options, { load, resolve, dirname, cwd: options.cwd ?? process.cwd() }));
+}
 async function parse(iterator, opt = {}) {
-    return parse$1(iterator, Object.assign(opt, { load, resolve, cwd: opt.cwd ?? process.cwd() }));
+    return doParse(iterator, Object.assign(opt, { load, resolve, dirname, cwd: opt.cwd ?? process.cwd() }));
 }
 async function transform(css, options = {}) {
-    return transform$1(css, Object.assign(options, { load, resolve, cwd: options.cwd ?? process.cwd() }));
+    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;
@@ -5019,10 +5838,11 @@ exports.load = load;
 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;