@tbela99/css-parser 0.0.1-alpha5 → 0.0.1-rc2

package/dist/index.cjs

@@ -6,13 +6,14 @@ var promises = require('fs/promises');
 // https://www.w3.org/TR/2021/CRD-css-syntax-3-20211224/#typedef-ident-token
 // '\\'
 const REVERSE_SOLIDUS = 0x5c;
+const dimensionUnits = [
+    'q', 'cap', 'ch', 'cm', 'cqb', 'cqh', 'cqi', 'cqmax', 'cqmin', 'cqw', 'dvb',
+    'dvh', 'dvi', 'dvmax', 'dvmin', 'dvw', 'em', 'ex', 'ic', 'in', 'lh', 'lvb',
+    'lvh', 'lvi', 'lvmax', 'lvw', 'mm', 'pc', 'pt', 'px', 'rem', 'rlh', 'svb',
+    'svh', 'svi', 'svmin', 'svw', 'vb', 'vh', 'vi', 'vmax', 'vmin', 'vw'
+];
 function isLength(dimension) {
-    return 'unit' in dimension && [
-        'q', 'cap', 'ch', 'cm', 'cqb', 'cqh', 'cqi', 'cqmax', 'cqmin', 'cqw', 'dvb',
-        'dvh', 'dvi', 'dvmax', 'dvmin', 'dvw', 'em', 'ex', 'ic', 'in', 'lh', 'lvb',
-        'lvh', 'lvi', 'lvmax', 'lvw', 'mm', 'pc', 'pt', 'px', 'rem', 'rlh', 'svb',
-        'svh', 'svi', 'svmin', 'svw', 'vb', 'vh', 'vi', 'vmax', 'vmin', 'vw'
-    ].includes(dimension.unit.toLowerCase());
+    return 'unit' in dimension && dimensionUnits.includes(dimension.unit.toLowerCase());
 }
 function isResolution(dimension) {
     return 'unit' in dimension && ['dpi', 'dpcm', 'dppx', 'x'].includes(dimension.unit.toLowerCase());
@@ -90,10 +91,7 @@ function isHash(name) {
     if (name.charAt(0) != '#') {
         return false;
     }
-    if (isIdent(name.charAt(1))) {
-        return true;
-    }
-    return true;
+    return isIdent(name.charAt(1));
 }
 function isNumber(name) {
     if (name.length == 0) {
@@ -237,6 +235,22 @@ function isHexColor(name) {
     }
     return true;
 }
+function isHexDigit(name) {
+    if (name.length || name.length > 6) {
+        return false;
+    }
+    for (let chr of name) {
+        let codepoint = chr.charCodeAt(0);
+        if (!isDigit(codepoint) &&
+            // A F
+            !(codepoint >= 0x41 && codepoint <= 0x46) &&
+            // a f
+            !(codepoint >= 0x61 && codepoint <= 0x66)) {
+            return false;
+        }
+    }
+    return true;
+}
 function isFunction(name) {
     return name.endsWith('(') && isIdent(name.slice(0, -1));
 }
@@ -372,6 +386,7 @@ var properties = {
 	},
 	"border-width": {
 		shorthand: "border-width",
+		map: "border",
 		properties: [
 			"border-top-width",
 			"border-right-width",
@@ -382,6 +397,9 @@ var properties = {
 			"Length",
 			"Perc"
 		],
+		"default": [
+			"medium"
+		],
 		keywords: [
 			"thin",
 			"medium",
@@ -389,19 +407,24 @@ var properties = {
 		]
 	},
 	"border-top-width": {
+		map: "border",
 		shorthand: "border-width"
 	},
 	"border-right-width": {
+		map: "border",
 		shorthand: "border-width"
 	},
 	"border-bottom-width": {
+		map: "border",
 		shorthand: "border-width"
 	},
 	"border-left-width": {
+		map: "border",
 		shorthand: "border-width"
 	},
 	"border-style": {
 		shorthand: "border-style",
+		map: "border",
 		properties: [
 			"border-top-style",
 			"border-right-style",
@@ -410,6 +433,9 @@ var properties = {
 		],
 		types: [
 		],
+		"default": [
+			"none"
+		],
 		keywords: [
 			"none",
 			"hidden",
@@ -424,19 +450,24 @@ var properties = {
 		]
 	},
 	"border-top-style": {
+		map: "border",
 		shorthand: "border-style"
 	},
 	"border-right-style": {
+		map: "border",
 		shorthand: "border-style"
 	},
 	"border-bottom-style": {
+		map: "border",
 		shorthand: "border-style"
 	},
 	"border-left-style": {
+		map: "border",
 		shorthand: "border-style"
 	},
 	"border-color": {
 		shorthand: "border-color",
+		map: "border",
 		properties: [
 			"border-top-color",
 			"border-right-color",
@@ -446,23 +477,95 @@ var properties = {
 		types: [
 			"Color"
 		],
+		"default": [
+			"currentcolor"
+		],
 		keywords: [
 		]
 	},
 	"border-top-color": {
+		map: "border",
 		shorthand: "border-color"
 	},
 	"border-right-color": {
+		map: "border",
 		shorthand: "border-color"
 	},
 	"border-bottom-color": {
+		map: "border",
 		shorthand: "border-color"
 	},
 	"border-left-color": {
+		map: "border",
 		shorthand: "border-color"
 	}
 };
 var map = {
+	border: {
+		shorthand: "border",
+		pattern: "border-color border-style border-width",
+		keywords: [
+			"none"
+		],
+		"default": [
+			"0",
+			"none"
+		],
+		properties: {
+			"border-color": {
+				types: [
+					"Color"
+				],
+				"default": [
+					"currentcolor"
+				],
+				keywords: [
+				]
+			},
+			"border-style": {
+				types: [
+				],
+				"default": [
+					"none"
+				],
+				keywords: [
+					"none",
+					"hidden",
+					"dotted",
+					"dashed",
+					"solid",
+					"double",
+					"groove",
+					"ridge",
+					"inset",
+					"outset"
+				]
+			},
+			"border-width": {
+				types: [
+					"Length",
+					"Perc"
+				],
+				"default": [
+					"medium"
+				],
+				keywords: [
+					"thin",
+					"medium",
+					"thick"
+				]
+			}
+		}
+	},
+	"border-color": {
+		shorthand: "border"
+	},
+	"border-style": {
+		shorthand: "border"
+	},
+	"border-width": {
+		shorthand: "border"
+	},
 	outline: {
 		shorthand: "outline",
 		pattern: "outline-color outline-style outline-width",
@@ -479,12 +582,10 @@ var map = {
 					"Color"
 				],
 				"default": [
-					"currentColor",
-					"invert"
+					"currentColor"
 				],
 				keywords: [
-					"currentColor",
-					"invert"
+					"currentColor"
 				]
 			},
 			"outline-style": {
@@ -822,6 +923,7 @@ var map = {
 				"default": [
 					"transparent"
 				],
+				multiple: true,
 				keywords: [
 				]
 			},
@@ -842,6 +944,7 @@ var map = {
 				"default": [
 					"scroll"
 				],
+				multiple: true,
 				keywords: [
 					"scroll",
 					"fixed",
@@ -854,6 +957,7 @@ var map = {
 				"default": [
 					"border-box"
 				],
+				multiple: true,
 				keywords: [
 					"border-box",
 					"padding-box",
@@ -867,6 +971,7 @@ var map = {
 				"default": [
 					"padding-box"
 				],
+				multiple: true,
 				keywords: [
 					"border-box",
 					"padding-box",
@@ -1456,7 +1561,8 @@ function hsl2rgb(h, s, l, a = null) {
 }
 
 function render(data, opt = {}) {
-    const options = Object.assign(opt.compress ? {
+    const startTime = performance.now();
+    const options = Object.assign(opt.minify ?? true ? {
         indent: '',
         newLine: '',
         removeComments: true
@@ -1474,7 +1580,9 @@ function render(data, opt = {}) {
         }
         return acc + renderToken(curr, options);
     }
-    return { code: doRender(data, options, reducer, 0) };
+    return { code: doRender(data, options, reducer, 0), stats: {
+            total: `${(performance.now() - startTime).toFixed(2)}ms`
+        } };
 }
 // @ts-ignore
 function doRender(data, options, reducer, level = 0, indents = []) {
@@ -1503,7 +1611,7 @@ function doRender(data, options, reducer, level = 0, indents = []) {
         case 'AtRule':
         case 'Rule':
             if (data.typ == 'AtRule' && !('chi' in data)) {
-                return `${indent}@${data.nam} ${data.val};`;
+                return `${indent}@${data.nam}${data.val === '' ? '' : options.indent || ' '}${data.val};`;
             }
             // @ts-ignore
             let children = data.chi.reduce((css, node) => {
@@ -1515,7 +1623,7 @@ function doRender(data, options, reducer, level = 0, indents = []) {
                     str = `${node.nam}:${options.indent}${node.val.reduce(reducer, '').trimEnd()};`;
                 }
                 else if (node.typ == 'AtRule' && !('chi' in node)) {
-                    str = `@${node.nam} ${node.val};`;
+                    str = `${data.val === '' ? '' : options.indent || ' '}${data.val};`;
                 }
                 else {
                     str = doRender(node, options, reducer, level + 1, indents);
@@ -1532,7 +1640,7 @@ function doRender(data, options, reducer, level = 0, indents = []) {
                 children = children.slice(0, -1);
             }
             if (data.typ == 'AtRule') {
-                return `@${data.nam}${data.val ? ' ' + data.val + options.indent : ''}{${options.newLine}` + (children === '' ? '' : indentSub + children + options.newLine) + indent + `}`;
+                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 + `}`;
     }
@@ -1541,8 +1649,11 @@ function doRender(data, options, reducer, level = 0, indents = []) {
 function renderToken(token, options = {}) {
     switch (token.typ) {
         case 'Color':
-            if (options.compress || options.colorConvert) {
-                let value = token.kin == 'hex' ? token.val.toLowerCase() : '';
+            if (options.minify || options.colorConvert) {
+                if (token.kin == 'lit' && token.val.toLowerCase() == 'currentcolor') {
+                    return 'currentcolor';
+                }
+                let value = token.kin == 'hex' ? token.val.toLowerCase() : (token.kin == 'lit' ? COLORS_NAMES[token.val.toLowerCase()] : '');
                 if (token.val == 'rgb' || token.val == 'rgba') {
                     value = rgb2Hex(token);
                 }
@@ -1586,7 +1697,7 @@ function renderToken(token, options = {}) {
         case 'UrlFunc':
         case 'Pseudo-class-func':
             // @ts-ignore
-            return ( /* options.compress && 'Pseudo-class-func' == token.typ && token.val.slice(0, 2) == '::' ? token.val.slice(1) :*/token.val ?? '') + '(' + token.chi.reduce((acc, curr) => {
+            return ( /* options.minify && 'Pseudo-class-func' == token.typ && token.val.slice(0, 2) == '::' ? token.val.slice(1) :*/token.val ?? '') + '(' + token.chi.reduce((acc, curr) => {
                 if (options.removeComments && curr.typ == 'Comment') {
                     if (!options.preserveLicense || !curr.val.startsWith('/*!')) {
                         return acc;
@@ -1677,21 +1788,47 @@ function renderToken(token, options = {}) {
         case 'String':
         case 'Iden':
         case 'Delim':
-            return /* options.compress && 'Pseudo-class' == token.typ && '::' == token.val.slice(0, 2) ? token.val.slice(1) :  */ token.val;
+            return /* options.minify && 'Pseudo-class' == token.typ && '::' == token.val.slice(0, 2) ? token.val.slice(1) :  */ token.val;
     }
-    throw new Error(`unexpected token ${JSON.stringify(token, null, 1)}`);
+    console.error(`unexpected token ${JSON.stringify(token, null, 1)}`);
+    // throw  new Error(`unexpected token ${JSON.stringify(token, null, 1)}`);
+    return '';
 }
 
 function eq(a, b) {
-    if ((typeof a != 'object') || typeof b != 'object') {
+    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);
-    return k1.length == k2.length &&
-        k1.every((key) => {
-            return eq(a[key], b[key]);
-        });
+    if (k1.length != k2.length) {
+        return false;
+    }
+    let key;
+    for (key of k1) {
+        if (!eq(a[key], b[key])) {
+            return false;
+        }
+    }
+    return true;
 }
 
 class PropertySet {
@@ -1703,8 +1840,7 @@ class PropertySet {
     }
     add(declaration) {
         if (declaration.nam == this.config.shorthand) {
-            this.declarations.clear();
-            this.declarations.set(declaration.nam, declaration);
+            this.declarations = new Map;
         }
         else {
             // expand shorthand
@@ -1727,6 +1863,10 @@ class PropertySet {
                     }
                     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) {
@@ -1742,10 +1882,6 @@ class PropertySet {
                     this.declarations.delete(this.config.shorthand);
                     for (const values of tokens) {
                         this.config.properties.forEach((property, index) => {
-                            // if (property == declaration.nam) {
-                            //
-                            //     return;
-                            // }
                             if (!this.declarations.has(property)) {
                                 this.declarations.set(property, {
                                     typ: 'Declaration',
@@ -1774,30 +1910,20 @@ class PropertySet {
                 this.declarations.set(declaration.nam, declaration);
                 return this;
             }
-            // declaration.chi = declaration.chi.reduce((acc: Token[], token: Token) => {
-            //
-            //     if (this.config.types.includes(token.typ) || ('0' == (<DimensionToken>token).chi && (
-            //         this.config.types.includes('Length') ||
-            //         this.config.types.includes('Angle') ||
-            //     this.config.types.includes('Dimension'))) || (token.typ == 'Iden' && this.config.keywords.includes(token.chi))) {
-            //
-            //         acc.push(token);
-            //     }
-            //
-            //     return acc;
-            // }, <Token[]>[]);
-            this.declarations.set(declaration.nam, declaration);
         }
+        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 || this.config.properties.some((property, index) => {
-            return !declarations.has(property) || (index > 0 &&
-                // @ts-ignore
-                declarations.get(property).val.length != declarations.get(this.config.properties[Math.floor(index / 2)]).val.length);
-        })) {
+        if (declarations.size < this.config.properties.length) {
             iterator = declarations.values();
         }
         else {
@@ -1855,17 +1981,20 @@ class PropertySet {
                         return acc;
                     }, [])
                 }][Symbol.iterator]();
-            return {
-                next() {
-                    return iterator.next();
-                }
-            };
+            // return {
+            //     next() {
+            //
+            //         return iterator.next();
+            //     }
+            // }
         }
-        return {
-            next() {
-                return iterator.next();
-            }
-        };
+        return iterator;
+        // return {
+        //     next() {
+        //
+        //         return iterator.next();
+        //     }
+        // }
     }
 }
 
@@ -1880,34 +2009,7 @@ function matchType(val, properties) {
     return false;
 }
 
-function getTokenType(val) {
-    if (val == 'transparent' || val == 'currentcolor') {
-        return {
-            typ: 'Color',
-            val,
-            kin: 'lit'
-        };
-    }
-    if (val.endsWith('%')) {
-        return {
-            typ: 'Perc',
-            val: val.slice(0, -1)
-        };
-    }
-    return {
-        typ: isNumber(val) ? 'Number' : 'Iden',
-        val
-    };
-}
-function parseString(val) {
-    return val.split(/\s/).map(getTokenType).reduce((acc, curr) => {
-        if (acc.length > 0) {
-            acc.push({ typ: 'Whitespace' });
-        }
-        acc.push(curr);
-        return acc;
-    }, []);
-}
+const propertiesConfig = getConfig();
 class PropertyMap {
     config;
     declarations;
@@ -1922,7 +2024,7 @@ class PropertyMap {
     }
     add(declaration) {
         if (declaration.nam == this.config.shorthand) {
-            this.declarations.clear();
+            this.declarations = new Map;
             this.declarations.set(declaration.nam, declaration);
         }
         else {
@@ -1999,8 +2101,7 @@ class PropertyMap {
                             const defaults = parseString(props.default[0]);
                             if (!(property in tokens)) {
                                 tokens[property] = [
-                                    [...defaults
-                                    ]
+                                    [...defaults]
                                 ];
                             }
                             else {
@@ -2034,145 +2135,229 @@ class PropertyMap {
                     }, new Map);
                 }
             }
-            this.declarations.set(declaration.nam, declaration);
+            // @ts-ignore
+            const config = propertiesConfig.properties[declaration.nam];
+            let property = declaration.nam;
+            if (config != null) {
+                property = config.shorthand;
+                let value = this.declarations.get(property);
+                if (!(value instanceof PropertySet)) {
+                    // @ts-ignore
+                    this.declarations.set(property, new PropertySet(propertiesConfig.properties[config.shorthand]));
+                    // Token[]
+                    if (value != null) {
+                        // @ts-ignore
+                        this.declarations.get(property).add(value);
+                    }
+                }
+                this.declarations.get(property).add(declaration);
+            }
+            else {
+                this.declarations.set(declaration.nam, declaration);
+            }
         }
         return this;
     }
     [Symbol.iterator]() {
-        let requiredCount = Object.keys(this.config.properties).reduce((acc, curr) => this.declarations.has(curr) && this.config.properties[curr].required ? ++acc : acc, 0);
-        if (requiredCount == 0) {
-            requiredCount = this.declarations.size;
-        }
-        if (requiredCount < this.requiredCount) {
-            // if (this.declarations.size == 1 && this.declarations.has(this.config.shorthand)) {
-            //
-            //     this.declarations
-            // }
-            return this.declarations.values();
-        }
-        let count = 0;
-        const separator = this.config.separator;
-        const tokens = {};
-        // @ts-ignore
-        const valid = Object.entries(this.config.properties).reduce((acc, curr) => {
-            if (!this.declarations.has(curr[0])) {
-                if (curr[1].required) {
-                    acc.push(curr[0]);
+        let iterable;
+        let requiredCount = 0;
+        let property;
+        let isShorthand = true;
+        for (property of Object.keys(this.config.properties)) {
+            if (this.config.properties[property].required) {
+                if (!this.declarations.has(property)) {
+                    isShorthand = false;
+                    break;
                 }
-                return acc;
-            }
-            let current = 0;
-            const props = this.config.properties[curr[0]];
-            // @ts-ignore
-            for (const val of this.declarations.get(curr[0]).val) {
-                if (separator != null && separator.typ == val.typ && eq(separator, val)) {
-                    current++;
-                    if (tokens[curr[0]].length == current) {
-                        tokens[curr[0]].push([]);
+                else {
+                    const val = this.declarations.get(property);
+                    if (val instanceof PropertySet && !val.isShortHand()) {
+                        isShorthand = false;
+                        break;
                     }
-                    continue;
-                }
-                if (val.typ == 'Whitespace' || val.typ == 'Comment') {
-                    continue;
-                }
-                if (props.multiple && props.separator != null && props.separator.typ == val.typ && eq(val, props.separator)) {
-                    continue;
-                }
-                if (matchType(val, curr[1])) {
-                    if (!(curr[0] in tokens)) {
-                        tokens[curr[0]] = [[]];
+                    else {
+                        requiredCount++;
                     }
-                    // is default value
-                    tokens[curr[0]][current].push(val);
-                    continue;
                 }
-                acc.push(curr[0]);
-                break;
-            }
-            if (count == 0) {
-                count = current;
             }
-            return acc;
-        }, []);
-        if (valid.length > 0 || Object.values(tokens).every(v => v.every(v => v.length == count))) {
-            return this.declarations.values();
         }
-        const values = Object.entries(tokens).reduce((acc, curr) => {
-            const props = this.config.properties[curr[0]];
-            for (let i = 0; i < curr[1].length; i++) {
-                if (acc.length == i) {
-                    acc.push([]);
-                }
-                let values = curr[1][i].reduce((acc, curr) => {
-                    if (acc.length > 0) {
-                        acc.push({ typ: 'Whitespace' });
+        if (requiredCount == 0) {
+            requiredCount = this.declarations.size;
+        }
+        if (!isShorthand || requiredCount < this.requiredCount) {
+            // @ts-ignore
+            iterable = this.declarations.values();
+        }
+        else {
+            let count = 0;
+            const separator = this.config.separator;
+            const tokens = {};
+            // @ts-ignore
+            /* const valid: string[] =*/ Object.entries(this.config.properties).reduce((acc, curr) => {
+                if (!this.declarations.has(curr[0])) {
+                    if (curr[1].required) {
+                        acc.push(curr[0]);
                     }
-                    acc.push(curr);
                     return acc;
-                }, []);
-                if (props.default.includes(curr[1][i].reduce((acc, curr) => acc + renderToken(curr) + ' ', '').trimEnd())) {
-                    continue;
                 }
-                values = values.filter((val) => {
+                let current = 0;
+                const props = this.config.properties[curr[0]];
+                const declaration = this.declarations.get(curr[0]);
+                // @ts-ignore
+                for (const val of (declaration instanceof PropertySet ? [...declaration][0] : declaration).val) {
+                    if (separator != null && separator.typ == val.typ && eq(separator, val)) {
+                        current++;
+                        if (tokens[curr[0]].length == current) {
+                            tokens[curr[0]].push([]);
+                        }
+                        continue;
+                    }
                     if (val.typ == 'Whitespace' || val.typ == 'Comment') {
-                        return false;
+                        continue;
                     }
-                    return !(val.typ == 'Iden' && props.default.includes(val.val));
-                });
-                if (values.length > 0) {
-                    if ('mapping' in props) {
-                        // @ts-ignore
-                        if (!('constraints' in props) || !('max' in props.constraints) || values.length <= props.constraints.mapping.max) {
-                            let i = values.length;
-                            while (i--) {
+                    if (props.multiple && props.separator != null && props.separator.typ == val.typ && eq(props.separator, val)) {
+                        continue;
+                    }
+                    if (matchType(val, curr[1])) {
+                        if (!(curr[0] in tokens)) {
+                            tokens[curr[0]] = [[]];
+                        }
+                        // is default value
+                        tokens[curr[0]][current].push(val);
+                        // continue;
+                    }
+                    else {
+                        acc.push(curr[0]);
+                        break;
+                    }
+                }
+                if (count == 0) {
+                    count = current;
+                }
+                return acc;
+            }, []);
+            count++;
+            if (!Object.values(tokens).every(v => v.length == count)) {
+                // @ts-ignore
+                iterable = this.declarations.values();
+            }
+            else {
+                const values = Object.entries(tokens).reduce((acc, curr) => {
+                    const props = this.config.properties[curr[0]];
+                    for (let i = 0; i < curr[1].length; i++) {
+                        if (acc.length == i) {
+                            acc.push([]);
+                        }
+                        let values = curr[1][i].reduce((acc, curr) => {
+                            if (acc.length > 0) {
+                                acc.push({ typ: 'Whitespace' });
+                            }
+                            acc.push(curr);
+                            return acc;
+                        }, []);
+                        // @todo remove renderToken call
+                        if (props.default.includes(curr[1][i].reduce((acc, curr) => acc + renderToken(curr) + ' ', '').trimEnd())) {
+                            continue;
+                        }
+                        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))) {
+                                    doFilterDefault = false;
+                                    break;
+                                }
+                            }
+                        }
+                        // remove default values
+                        values = values.filter((val) => {
+                            if (val.typ == 'Whitespace' || val.typ == 'Comment') {
+                                return false;
+                            }
+                            return !doFilterDefault || !(val.typ == 'Iden' && props.default.includes(val.val));
+                        });
+                        if (values.length > 0) {
+                            if ('mapping' in props) {
                                 // @ts-ignore
-                                if (values[i].typ == 'Iden' && values[i].val in props.mapping) {
-                                    // @ts-ignore
-                                    values.splice(i, 1, ...parseString(props.mapping[values[i].val]));
+                                if (!('constraints' in props) || !('max' in props.constraints) || values.length <= props.constraints.mapping.max) {
+                                    let i = values.length;
+                                    while (i--) {
+                                        // @ts-ignore
+                                        if (values[i].typ == 'Iden' && values[i].val in props.mapping) {
+                                            // @ts-ignore
+                                            values.splice(i, 1, ...parseString(props.mapping[values[i].val]));
+                                        }
+                                    }
                                 }
                             }
+                            if ('prefix' in props) {
+                                // @ts-ignore
+                                acc[i].push({ ...props.prefix });
+                            }
+                            else if (acc[i].length > 0) {
+                                acc[i].push({ typ: 'Whitespace' });
+                            }
+                            acc[i].push(...values.reduce((acc, curr) => {
+                                if (acc.length > 0) {
+                                    // @ts-ignore
+                                    acc.push({ ...(props.separator ?? { typ: 'Whitespace' }) });
+                                }
+                                // @ts-ignore
+                                acc.push(curr);
+                                return acc;
+                            }, []));
                         }
                     }
-                    if ('prefix' in props) {
-                        // @ts-ignore
-                        acc[i].push({ ...props.prefix });
+                    return acc;
+                }, []).reduce((acc, curr) => {
+                    if (acc.length > 0) {
+                        acc.push({ ...separator });
                     }
-                    else if (acc[i].length > 0) {
-                        acc[i].push({ typ: 'Whitespace' });
+                    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(curr);
+                            return acc;
+                        }, []));
                     }
-                    acc[i].push(...values.reduce((acc, curr) => {
-                        if (acc.length > 0) {
+                    acc.push(...curr);
+                    return acc;
+                }, []);
+                iterable = [{
+                        typ: 'Declaration',
+                        nam: this.config.shorthand,
+                        val: values
+                    }][Symbol.iterator]();
+            }
+        }
+        const iterators = [];
+        return {
+            // @ts-ignore
+            next() {
+                let v = iterable.next();
+                while (v.done || v.value instanceof PropertySet) {
+                    if (v.value instanceof PropertySet) {
+                        // @ts-ignore
+                        iterators.push(iterable);
+                        iterable = v.value[Symbol.iterator]();
+                        v = iterable.next();
+                    }
+                    if (v.done) {
+                        if (iterators.length > 0) {
                             // @ts-ignore
-                            acc.push({ ...(props.separator ?? { typ: 'Whitespace' }) });
+                            iterable = iterators.pop();
+                            v = iterable.next();
                         }
-                        // @ts-ignore
-                        acc.push(curr);
-                        return acc;
-                    }, []));
+                        if (v.done && iterators.length == 0) {
+                            break;
+                        }
+                    }
                 }
+                return v;
             }
-            return acc;
-        }, []).reduce((acc, curr) => {
-            if (acc.length > 0) {
-                acc.push({ ...separator });
-            }
-            if (curr.length == 0) {
-                curr.push(...this.config.default[0].split(/\s/).map(getTokenType).reduce((acc, curr) => {
-                    if (acc.length > 0) {
-                        acc.push({ typ: 'Whitespace' });
-                    }
-                    acc.push(curr);
-                    return acc;
-                }, []));
-            }
-            acc.push(...curr);
-            return acc;
-        }, []);
-        return [{
-                typ: 'Declaration',
-                nam: this.config.shorthand,
-                val: values
-            }][Symbol.iterator]();
+        };
     }
 }
 
@@ -2182,33 +2367,61 @@ class PropertyList {
     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;
         }
-        const propertyName = declaration.nam;
+        let propertyName = declaration.nam;
+        let shortHandType;
+        let shorthand;
         if (propertyName in config.properties) {
             // @ts-ignore
-            const shorthand = config.properties[propertyName].shorthand;
+            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 PropertySet(config.properties[shorthand]));
+                this.declarations.set(shorthand, new PropertyMap(config.map[shorthand]));
             }
+            // @ts-ignore
             this.declarations.get(shorthand).add(declaration);
-            return this;
+            // return this;
         }
-        if (propertyName in config.map) {
+        // @ts-ignore
+        else if (shortHandType == 'set') {
             // @ts-ignore
-            const shorthand = config.map[propertyName].shorthand;
+            // const shorthand: string = <string>config.properties[propertyName].shorthand;
             if (!this.declarations.has(shorthand)) {
                 // @ts-ignore
-                this.declarations.set(shorthand, new PropertyMap(config.map[shorthand]));
+                this.declarations.set(shorthand, new PropertySet(config.properties[shorthand]));
             }
+            // @ts-ignore
             this.declarations.get(shorthand).add(declaration);
-            return this;
+            // return this;
+        }
+        else {
+            this.declarations.set(propertyName, declaration);
         }
-        this.declarations.set(propertyName, declaration);
         return this;
     }
     [Symbol.iterator]() {
@@ -2237,56 +2450,300 @@ class PropertyList {
     }
 }
 
-const configuration = getConfig();
 const combinators = ['+', '>', '~'];
 const notEndingWith = ['(', '['].concat(combinators);
-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', {
-        enumerable: false,
-        writable: true,
+function minify(ast, options = {}, recursive = false) {
+    function wrapNodes(previous, node, match, ast, i, nodeIndex) {
         // @ts-ignore
-        value: match.match.map(t => t.slice())
-    });
-    if (pSel == '&' || pSel === '') {
+        let pSel = match.selector1.reduce(reducer, []).join(',');
         // @ts-ignore
-        wrapper.chi.push(...previous.chi);
+        let nSel = match.selector2.reduce(reducer, []).join(',');
         // @ts-ignore
-        if ((nSel == '&' || nSel === '') && hasOnlyDeclarations(previous)) {
+        const wrapper = { ...previous, chi: [], sel: match.match.reduce(reducer, []).join(',') };
+        // @ts-ignore
+        Object.defineProperty(wrapper, 'raw', {
+            enumerable: false,
+            writable: true,
+            // @ts-ignore
+            value: match.match.map(t => t.slice())
+        });
+        if (pSel == '&' || pSel === '') {
+            // @ts-ignore
+            wrapper.chi.push(...previous.chi);
             // @ts-ignore
-            wrapper.chi.push(...node.chi);
+            if ((nSel == '&' || nSel === '') && hasOnlyDeclarations(previous)) {
+                // @ts-ignore
+                wrapper.chi.push(...node.chi);
+            }
+            else {
+                // @ts-ignore
+                wrapper.chi.push(node);
+            }
         }
         else {
             // @ts-ignore
-            wrapper.chi.push(node);
+            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;
     }
-    else {
+    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);
+            }
+        }
+        else if (ast.typ == 'Rule' && (isIdent(curr[0]) || isFunction(curr[0]))) {
+            curr.unshift('&', ' ');
+        }
+        acc.push(curr.join(''));
+        return acc;
+    }
+    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) {
+            // @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', { enumerable: false, writable: true, value: raw1 });
+        }
+        if (raw2 != null) {
+            Object.defineProperty(node2, 'raw', { enumerable: false, writable: true, value: raw2 });
+        }
+        const intersect = [];
+        while (i--) {
+            if (node1.chi[i].typ == 'Comment') {
+                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;
+                    }
+                }
+            }
+        }
         // @ts-ignore
-        wrapper.chi.push(previous, node);
+        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 + render(curr, options).code.length, 0) <= [node1, node2, result].reduce((acc, curr) => curr.chi.length == 0 ? acc : acc + render(curr, options).code.length, 0)) {
+            // @ts-ignore
+            return null;
+        }
+        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([]);
+            }
+            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 != 'Rule') {
+            for (const part of match) {
+                if (part.length > 0 && combinators.includes(part[0].charAt(0))) {
+                    return null;
+                }
+            }
+        }
+        if (match.length > 1) {
+            console.error(`unsupported multilevel matching`);
+            console.error({ match, selector1, selector2 });
+            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
+        };
     }
-    // @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 deduplicate(ast, options = {}, recursive = false) {
     // @ts-ignore
     if (('chi' in ast) && ast.chi?.length > 0) {
         let i = 0;
@@ -2312,11 +2769,27 @@ function deduplicate(ast, options = {}, recursive = false) {
             if (node.typ == 'AtRule' && node.nam == 'font-face') {
                 continue;
             }
-            if (node.typ == 'AtRule' && node.val == 'all') {
+            if (node.typ == 'AtRule') {
+                if (node.nam == 'media' && node.val == 'all') {
+                    // @ts-ignore
+                    ast.chi?.splice(i, 1, ...node.chi);
+                    i--;
+                    continue;
+                }
+                // console.debug({previous, node});
                 // @ts-ignore
-                ast.chi?.splice(i, 1, ...node.chi);
-                i--;
-                continue;
+                if (previous?.typ == 'AtRule' &&
+                    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 (node.typ == 'Rule') {
@@ -2326,7 +2799,8 @@ function deduplicate(ast, options = {}, recursive = false) {
                 // @ts-ignore
                 if (options.nestingRules) {
                     // @ts-ignore
-                    if (previous != null && previous.typ == 'Rule') {
+                    if (previous?.typ == 'Rule') {
+                        // @ts-ignore
                         reduceRuleSelector(previous);
                         // @ts-ignore
                         match = matchSelectors(previous.raw, node.raw, ast.typ);
@@ -2365,7 +2839,7 @@ function deduplicate(ast, options = {}, recursive = false) {
                         nodeIndex = --i;
                         // @ts-ignore
                         previous = ast.chi[nodeIndex];
-                        deduplicate(wrapper, options, recursive);
+                        minify(wrapper, options, recursive);
                         continue;
                     }
                     // @ts-ignore
@@ -2414,13 +2888,24 @@ function deduplicate(ast, options = {}, recursive = false) {
                         }
                         else if (combinators.includes(curr[0])) {
                             curr.unshift('&');
+                            wrap = false;
                         }
                         // @ts-ignore
-                        acc.push(curr.map(t => t.replaceAll('&', node.optimized.optimized[0])).join(''));
+                        acc.push(curr);
                         return acc;
                     }, []);
+                    if (!wrap) {
+                        wrap = selector.some(s => s[0] != '&');
+                    }
+                    const rule = selector.map(s => {
+                        if (s[0] == '&') {
+                            // @ts-ignore
+                            s[0] = node.optimized.optimized[0];
+                        }
+                        return s.join('');
+                    }).join(',');
                     // @ts-ignore
-                    node.sel = (wrap ? node.optimized.optimized[0] : '') + `:is(${selector.join(',')})`;
+                    node.sel = wrap ? node.optimized.optimized[0] + `:is(${rule})` : rule;
                 }
             }
             // @ts-ignore
@@ -2451,10 +2936,10 @@ function deduplicate(ast, options = {}, recursive = false) {
                             // @ts-ignore
                             if (hasDeclaration(node)) {
                                 // @ts-ignore
-                                deduplicateRule(node);
+                                minifyRule(node);
                             }
                             else {
-                                deduplicate(node, options, recursive);
+                                minify(node, options, recursive);
                             }
                             i--;
                             previous = node;
@@ -2496,10 +2981,10 @@ function deduplicate(ast, options = {}, recursive = false) {
                     // @ts-ignore
                     if (hasDeclaration(previous)) {
                         // @ts-ignore
-                        deduplicateRule(previous);
+                        minifyRule(previous);
                     }
                     else {
-                        deduplicate(previous, options, recursive);
+                        minify(previous, options, recursive);
                     }
                 }
             }
@@ -2510,18 +2995,97 @@ function deduplicate(ast, options = {}, recursive = false) {
         if (recursive && node != null && ('chi' in node)) {
             // @ts-ignore
             if (node.chi.some(n => n.typ == 'Declaration')) {
-                deduplicateRule(node);
+                minifyRule(node);
             }
             else {
                 // @ts-ignore
                 if (!(node.typ == 'AtRule' && node.nam != 'font-face')) {
-                    deduplicate(node, options, recursive);
+                    minify(node, options, recursive);
                 }
             }
         }
     }
     return ast;
 }
+function reduceSelector(selector) {
+    if (selector.length == 0) {
+        return null;
+    }
+    const optimized = [];
+    const k = selector.reduce((acc, curr) => acc == 0 ? curr.length : (curr.length == 0 ? acc : Math.min(acc, curr.length)), 0);
+    let i = 0;
+    let j;
+    let match;
+    for (; i < k; i++) {
+        const item = selector[0][i];
+        match = true;
+        for (j = 1; j < selector.length; j++) {
+            if (item != selector[j][i]) {
+                match = false;
+                break;
+            }
+        }
+        if (!match) {
+            break;
+        }
+        optimized.push(item);
+    }
+    while (optimized.length > 0) {
+        const last = optimized.at(-1);
+        if ((last == ' ' || combinators.includes(last))) {
+            optimized.pop();
+            continue;
+        }
+        break;
+    }
+    selector.forEach((selector) => selector.splice(0, optimized.length));
+    // combinator
+    if (combinators.includes(optimized.at(-1))) {
+        const combinator = optimized.pop();
+        selector.forEach(selector => selector.unshift(combinator));
+    }
+    let reducible = optimized.length == 1;
+    if (optimized[0] == '&' && optimized[1] == ' ') {
+        optimized.splice(0, 2);
+    }
+    if (optimized.length == 0 ||
+        (optimized[0].charAt(0) == '&' ||
+            selector.length == 1)) {
+        return {
+            match: false,
+            optimized,
+            selector: selector.map(selector => selector[0] == '&' && selector[1] == ' ' ? selector.slice(2) : selector),
+            reducible: selector.length > 1 && selector.every((selector) => !combinators.includes(selector[0]))
+        };
+    }
+    return {
+        match: true,
+        optimized,
+        selector: selector.reduce((acc, curr) => {
+            let hasCompound = true;
+            if (hasCompound && curr.length > 0) {
+                hasCompound = !['&'].concat(combinators).includes(curr[0].charAt(0));
+            }
+            // @ts-ignore
+            if (hasCompound && curr[0] == ' ') {
+                hasCompound = false;
+                curr.unshift('&');
+            }
+            if (curr.length == 0) {
+                curr.push('&');
+                hasCompound = false;
+            }
+            if (reducible) {
+                const chr = curr[0].charAt(0);
+                // @ts-ignore
+                reducible = chr == '.' || chr == ':' || isIdentStart(chr.codePointAt(0));
+            }
+            acc.push(hasCompound ? ['&'].concat(curr) : curr);
+            return acc;
+        }, []),
+        reducible: selector.every((selector) => !['>', '+', '~', '&'].includes(selector[0]))
+    };
+}
 function hasOnlyDeclarations(node) {
     let k = node.chi.length;
     while (k--) {
@@ -2544,7 +3108,7 @@ function hasDeclaration(node) {
     }
     return true;
 }
-function deduplicateRule(ast) {
+function minifyRule(ast) {
     // @ts-ignore
     if (!('chi' in ast) || ast.chi?.length <= 1) {
         return ast;
@@ -2552,45 +3116,19 @@ function deduplicateRule(ast) {
     // @ts-ignore
     const j = ast.chi.length;
     let k = 0;
-    let map = new Map;
+    let properties = new PropertyList();
     // @ts-ignore
     for (; k < j; k++) {
         // @ts-ignore
         const node = ast.chi[k];
-        if (node.typ == 'Comment') {
-            // @ts-ignore
-            map.set(node, node);
+        if (node.typ == 'Comment' || node.typ == 'Declaration') {
+            properties.add(node);
             continue;
         }
-        else if (node.typ != 'Declaration') {
-            break;
-        }
-        if (node.nam in configuration.map ||
-            node.nam in configuration.properties) {
-            // @ts-ignore
-            const shorthand = node.nam in configuration.map ? configuration.map[node.nam].shorthand : configuration.properties[node.nam].shorthand;
-            if (!map.has(shorthand)) {
-                map.set(shorthand, new PropertyList());
-            }
-            map.get(shorthand).add(node);
-        }
-        else {
-            map.set(node.nam, node);
-        }
-    }
-    const children = [];
-    for (let child of map.values()) {
-        if (child instanceof PropertyList) {
-            // @ts-ignore
-            children.push(...child);
-        }
-        else {
-            // @ts-ignore
-            children.push(child);
-        }
+        break;
     }
     // @ts-ignore
-    ast.chi = children.concat(ast.chi?.slice(k));
+    ast.chi = [...properties].concat(ast.chi.slice(k));
     return ast;
 }
 function splitRule(buffer) {
@@ -2716,345 +3254,485 @@ function reduceRuleSelector(node) {
     }
     // }
 }
-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) {
-        // @ts-ignore
-        return null;
-    }
-    // @ts-ignore
-    const raw1 = node1.raw;
-    // @ts-ignore
-    // const optimized1 = node1.optimized;
-    // @ts-ignore
-    const raw2 = node2.raw;
+
+function* walk(node) {
     // @ts-ignore
-    // const optimized2 = node2.optimized;
-    node1 = { ...node1, chi: node1.chi.slice() };
-    node2 = { ...node2, chi: node2.chi.slice() };
-    if (raw1 != null) {
-        Object.defineProperty(node1, 'raw', { enumerable: false, writable: true, value: raw1 });
-    }
-    // if (optimized1 != null) {
-    //     Object.defineProperty(node1, 'optimized', {enumerable: false, writable: true, value: optimized1});
-    // }
-    if (raw2 != null) {
-        Object.defineProperty(node2, 'raw', { enumerable: false, writable: true, value: raw2 });
-    }
-    // if (optimized2 != null) {
-    //     Object.defineProperty(node2, 'optimized', {enumerable: false, writable: true, value: optimized2});
-    // }
-    const intersect = [];
-    while (i--) {
-        if (node1.chi[i].typ == 'Comment') {
-            continue;
-        }
-        j = node2.chi.length;
-        if (j == 0) {
-            break;
+    yield* doWalk(node, null, null);
+}
+function* doWalk(node, parent, root) {
+    yield { node, parent, root };
+    if ('chi' in node) {
+        for (const child of node.chi) {
+            yield* doWalk(child, node, (root ?? node));
         }
-        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;
-                }
-            }
+    }
+}
+
+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;
     }
-    // @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 + render(curr, options).code.length, 0) <= [node1, node2, result].reduce((acc, curr) => curr.chi.length == 0 ? acc : acc + render(curr, options).code.length, 0)) {
-        // @ts-ignore
-        return null;
+    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;
     }
-    return { result, node1: exchanged ? node2 : node1, node2: exchanged ? node2 : 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;
-            }
+    function* consumeString(quoteStr) {
+        const quote = quoteStr;
+        let value;
+        let hasNewLine = false;
+        if (buffer.length > 0) {
+            yield pushToken(buffer);
+            buffer = '';
         }
-        if (matching) {
-            l = 0;
-            for (; l < selector2.length; l++) {
-                if (selector2[l][i] != token) {
-                    matching = false;
+        buffer += quoteStr;
+        while (value = peek()) {
+            // if (ind >= iterator.length) {
+            //
+            //     yield pushToken(buffer, hasNewLine ? 'Bad-string' : 'Unclosed-string');
+            //     break;
+            // }
+            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;
                 }
+                // not hex or new line
+                // @ts-ignore
+                if (i == 1 && !isNewLine(codepoint)) {
+                    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);
+                    continue;
+                }
+                // buffer += value;
+                // if (ind >= iterator.length) {
+                //
+                //     // drop '\\' at the end
+                //     yield pushToken(buffer);
+                //     break;
+                // }
+                buffer += next(2);
+                continue;
             }
-        }
-        if (!matching) {
-            break;
-        }
-        if (token == ',') {
-            match.push([]);
-        }
-        else {
-            if (token.endsWith('(')) {
-                matchFunction++;
-            }
-            if (token.endsWith('[')) {
-                inAttr++;
+            if (value == quote) {
+                buffer += value;
+                yield pushToken(buffer, hasNewLine ? 'Bad-string' : 'String');
+                next();
+                // i += value.length;
+                buffer = '';
+                break;
             }
-            else if (token == ')') {
-                matchFunction--;
+            if (isNewLine(value.charCodeAt(0))) {
+                hasNewLine = true;
             }
-            else if (token == ']') {
-                inAttr--;
+            if (hasNewLine && value == ';') {
+                yield pushToken(buffer, 'Bad-string');
+                buffer = '';
+                break;
             }
-            match.at(-1).push(token);
+            buffer += value;
+            // i += value.length;
+            next();
         }
     }
-    // invalid function
-    if (matchFunction != 0 || inAttr != 0) {
-        return null;
-    }
-    if (parentType != 'Rule') {
-        for (const part of match) {
-            if (part.length > 0 && combinators.includes(part[0].charAt(0))) {
-                return null;
-            }
+    function peek(count = 1) {
+        if (count == 1) {
+            return iterator.charAt(ind + 1);
         }
+        return iterator.slice(ind + 1, ind + count + 1);
     }
-    if (match.length > 1) {
-        console.error(`unsupported multilevel matching`);
-        console.error({ match, selector1, selector2 });
-        return null;
+    function prev(count = 1) {
+        if (count == 1) {
+            return ind == 0 ? '' : iterator.charAt(ind - 1);
+        }
+        return iterator.slice(ind - 1 - count, ind - 1);
     }
-    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;
+    function next(count = 1) {
+        let char = '';
+        while (count-- > 0 && ind < iterator.length) {
+            const codepoint = iterator.charCodeAt(++ind);
+            if (isNaN(codepoint)) {
+                return char;
+            }
+            char += iterator.charAt(ind);
+            if (isNewLine(codepoint)) {
+                lin++;
+                col = 0;
+            }
+            else {
+                col++;
             }
-            break;
         }
+        return char;
     }
-    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;
+    while (value = next()) {
+        if (ind >= iterator.length) {
+            if (buffer.length > 0) {
+                yield pushToken(buffer);
+                buffer = '';
             }
             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 (isWhiteSpace(value.charCodeAt(0))) {
+            if (buffer.length > 0) {
+                yield pushToken(buffer);
+                buffer = '';
+            }
+            while (value = next()) {
+                if (ind >= iterator.length) {
+                    break;
+                }
+                if (!isWhiteSpace(value.charCodeAt(0))) {
+                    break;
+                }
+            }
+            yield pushToken('', 'Whitespace');
+            buffer = '';
+            if (ind >= iterator.length) {
+                break;
+            }
         }
-        if (curr[0] == ':is(') {
-            let inFunction = 0;
-            let canReduce = true;
-            const isCompound = curr.reduce((acc, token, index) => {
-                if (index == 0) {
-                    inFunction++;
-                    canReduce = curr[1] == '&';
+        switch (value) {
+            case '/':
+                if (buffer.length > 0) {
+                    yield pushToken(buffer);
+                    buffer = '';
+                    if (peek() != '*') {
+                        yield pushToken(value);
+                        break;
+                    }
                 }
-                else if (token.endsWith('(')) {
-                    if (inFunction == 0) {
-                        canReduce = false;
+                buffer += value;
+                if (peek() == '*') {
+                    buffer += '*';
+                    // i++;
+                    next();
+                    while (value = next()) {
+                        if (ind >= iterator.length) {
+                            yield pushToken(buffer, 'Bad-comment');
+                            break;
+                        }
+                        if (value == '\\') {
+                            buffer += value;
+                            value = next();
+                            if (ind >= iterator.length) {
+                                yield pushToken(buffer, 'Bad-comment');
+                                break;
+                            }
+                            buffer += value;
+                            continue;
+                        }
+                        if (value == '*') {
+                            buffer += value;
+                            value = next();
+                            if (ind >= iterator.length) {
+                                yield pushToken(buffer, 'Bad-comment');
+                                break;
+                            }
+                            buffer += value;
+                            if (value == '/') {
+                                yield pushToken(buffer, 'Comment');
+                                buffer = '';
+                                break;
+                            }
+                        }
+                        else {
+                            buffer += value;
+                        }
                     }
-                    inFunction++;
                 }
-                else if (token == ')') {
-                    inFunction--;
+                break;
+            case '<':
+                if (buffer.length > 0) {
+                    yield pushToken(buffer);
+                    buffer = '';
                 }
-                else if (token == ',') {
-                    if (!canReduce) {
-                        canReduce = curr[index + 1] == '&';
-                    }
-                    acc.push([]);
+                buffer += value;
+                value = next();
+                if (ind >= iterator.length) {
+                    break;
                 }
-                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(',');
+                if (peek(3) == '!--') {
+                    while (value = next()) {
+                        if (ind >= iterator.length) {
+                            break;
+                        }
+                        buffer += value;
+                        if (value == '>' && prev(2) == '--') {
+                            yield pushToken(buffer, 'CDOCOMM');
+                            buffer = '';
+                            break;
+                        }
                     }
-                    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 reduceSelector(selector) {
-    if (selector.length == 0) {
-        return null;
-    }
-    const optimized = [];
-    const k = selector.reduce((acc, curr) => acc == 0 ? curr.length : (curr.length == 0 ? acc : Math.min(acc, curr.length)), 0);
-    let i = 0;
-    let j;
-    let match;
-    for (; i < k; i++) {
-        const item = selector[0][i];
-        match = true;
-        for (j = 1; j < selector.length; j++) {
-            if (item != selector[j][i]) {
-                match = false;
+                }
+                if (ind >= iterator.length) {
+                    yield pushToken(buffer, 'BADCDO');
+                    buffer = '';
+                }
                 break;
-            }
-        }
-        if (!match) {
-            break;
-        }
-        optimized.push(item);
-    }
-    while (optimized.length > 0) {
-        const last = optimized.at(-1);
-        if ((last == ' ' || combinators.includes(last))) {
-            optimized.pop();
-            continue;
-        }
-        break;
-    }
-    selector.forEach((selector) => selector.splice(0, optimized.length));
-    // combinator
-    if (combinators.includes(optimized.at(-1))) {
-        const combinator = optimized.pop();
-        selector.forEach(selector => selector.unshift(combinator));
-    }
-    let reducible = optimized.length == 1;
-    if (optimized[0] == '&' && optimized[1] == ' ') {
-        optimized.splice(0, 2);
-    }
-    if (optimized.length == 0 ||
-        (optimized[0].charAt(0) == '&' ||
-            selector.length == 1)) {
-        return {
-            match: false,
-            optimized,
-            selector: selector.map(selector => selector[0] == '&' && selector[1] == ' ' ? selector.slice(2) : selector),
-            reducible: selector.length > 1 && selector.every((selector) => !combinators.includes(selector[0]))
-        };
-    }
-    return {
-        match: true,
-        optimized,
-        selector: selector.reduce((acc, curr) => {
-            let hasCompound = true;
-            if (hasCompound && curr.length > 0) {
-                hasCompound = !['&'].concat(combinators).includes(curr[0].charAt(0));
-            }
-            // @ts-ignore
-            if (hasCompound && curr[0] == ' ') {
-                hasCompound = false;
-                curr.unshift('&');
-            }
-            if (curr.length == 0) {
-                curr.push('&');
-                hasCompound = false;
-            }
-            if (reducible) {
-                const chr = curr[0].charAt(0);
+            case '\\':
+                value = next();
+                // EOF
+                if (ind + 1 >= iterator.length) {
+                    // end of stream ignore \\
+                    yield pushToken(buffer);
+                    buffer = '';
+                    break;
+                }
+                buffer += prev() + value;
+                break;
+            case '"':
+            case "'":
+                yield* consumeString(value);
+                break;
+            case '~':
+            case '|':
+                if (buffer.length > 0) {
+                    yield pushToken(buffer);
+                    buffer = '';
+                }
+                buffer += value;
+                value = next();
+                if (ind >= iterator.length) {
+                    yield pushToken(buffer);
+                    buffer = '';
+                    break;
+                }
+                if (value == '=') {
+                    buffer += value;
+                    yield pushToken(buffer, buffer[0] == '~' ? 'Includes' : 'Dash-matches');
+                    buffer = '';
+                    break;
+                }
+                yield pushToken(buffer);
+                while (isWhiteSpace(value.charCodeAt(0))) {
+                    value = next();
+                }
+                buffer = value;
+                break;
+            case '>':
+                if (buffer !== '') {
+                    yield pushToken(buffer);
+                    buffer = '';
+                }
+                yield pushToken('', 'Gt');
+                consumeWhiteSpace();
+                break;
+            case '.':
+                const codepoint = peek().charCodeAt(0);
+                if (!isDigit(codepoint) && buffer !== '') {
+                    yield pushToken(buffer);
+                    buffer = value;
+                    break;
+                }
+                buffer += value;
+                break;
+            case '+':
+            case ':':
+            case ',':
+            case '=':
+                if (buffer.length > 0) {
+                    yield pushToken(buffer);
+                    buffer = '';
+                }
+                if (value == ':' && ':' == peek()) {
+                    buffer += value + next();
+                    break;
+                }
+                yield pushToken(value);
+                buffer = '';
+                if (value == '+' && isWhiteSpace(peek().charCodeAt(0))) {
+                    yield pushToken(next());
+                }
+                while (isWhiteSpace(peek().charCodeAt(0))) {
+                    next();
+                }
+                break;
+            case ')':
+                if (buffer.length > 0) {
+                    yield pushToken(buffer);
+                    buffer = '';
+                }
+                yield pushToken('', 'End-parens');
+                break;
+            case '(':
+                if (buffer.length == 0) {
+                    yield pushToken('', 'Start-parens');
+                    break;
+                }
+                buffer += value;
                 // @ts-ignore
-                reducible = chr == '.' || chr == ':' || isIdentStart(chr.codePointAt(0));
-            }
-            acc.push(hasCompound ? ['&'].concat(curr) : curr);
-            return acc;
-        }, []),
-        reducible: selector.every((selector) => !['>', '+', '~', '&'].includes(selector[0]))
-    };
-}
-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] == ' ') {
-            curr.splice(0, 2);
-        }
-        else if (combinators.includes(curr[1])) {
-            curr.splice(0, 1);
+                if (buffer == 'url(') {
+                    yield pushToken(buffer);
+                    buffer = '';
+                    // consume either string or url token
+                    let whitespace = '';
+                    value = peek();
+                    while (isWhiteSpace(value.charCodeAt(0))) {
+                        whitespace += value;
+                    }
+                    if (whitespace.length > 0) {
+                        next(whitespace.length);
+                    }
+                    value = peek();
+                    if (value == '"' || value == "'") {
+                        yield* consumeString(next());
+                        break;
+                    }
+                    else {
+                        buffer = '';
+                        do {
+                            let cp = value.charCodeAt(0);
+                            // EOF -
+                            if (cp == null) {
+                                yield pushToken('', 'Bad-url-token');
+                                break;
+                            }
+                            // ')'
+                            if (cp == 0x29 || cp == null) {
+                                if (buffer.length == 0) {
+                                    yield pushToken(buffer, 'Bad-url-token');
+                                }
+                                else {
+                                    yield pushToken(buffer, 'Url-token');
+                                }
+                                if (cp != null) {
+                                    yield pushToken(next());
+                                }
+                                break;
+                            }
+                            if (isWhiteSpace(cp)) {
+                                whitespace = next();
+                                while (true) {
+                                    value = peek();
+                                    cp = value.charCodeAt(0);
+                                    if (isWhiteSpace(cp)) {
+                                        whitespace += value;
+                                        continue;
+                                    }
+                                    break;
+                                }
+                                if (cp == null || cp == 0x29) {
+                                    continue;
+                                }
+                                // bad url token
+                                buffer += next(whitespace.length);
+                                do {
+                                    value = peek();
+                                    cp = value.charCodeAt(0);
+                                    if (cp == null || cp == 0x29) {
+                                        break;
+                                    }
+                                    buffer += next();
+                                } while (true);
+                                yield pushToken(buffer, 'Bad-url-token');
+                                continue;
+                            }
+                            buffer += next();
+                            value = peek();
+                        } while (true);
+                        buffer = '';
+                    }
+                    break;
+                }
+                yield pushToken(buffer);
+                buffer = '';
+                break;
+            case '[':
+            case ']':
+            case '{':
+            case '}':
+            case ';':
+                if (buffer.length > 0) {
+                    yield pushToken(buffer);
+                    buffer = '';
+                }
+                yield pushToken(value);
+                break;
+            case '!':
+                if (buffer.length > 0) {
+                    yield pushToken(buffer);
+                    buffer = '';
+                }
+                const important = peek(9);
+                if (important == 'important') {
+                    yield pushToken('', 'Important');
+                    next(9);
+                    buffer = '';
+                    break;
+                }
+                buffer = '!';
+                break;
+            default:
+                buffer += value;
+                break;
         }
     }
-    acc.push(curr.join(''));
-    return acc;
+    if (buffer.length > 0) {
+        yield pushToken(buffer);
+    }
 }
 
 const urlTokenMatcher = /^(["']?)[a-zA-Z0-9_/.-][a-zA-Z0-9_/:.#?-]+(\1)$/;
 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 = {
         src: '',
         sourcemap: false,
-        compress: false,
+        minify: true,
         nestingRules: false,
         resolveImport: false,
         resolveUrls: false,
@@ -3064,201 +3742,57 @@ async function parse$1(iterator, opt = {}) {
     if (options.resolveImport) {
         options.resolveUrls = true;
     }
-    let ind = -1;
-    let lin = 1;
-    let col = 0;
-    const tokens = [];
     const src = options.src;
     const stack = [];
     const ast = {
         typ: "StyleSheet",
         chi: []
     };
-    const position = {
-        ind: Math.max(ind, 0),
-        lin: lin,
-        col: Math.max(col, 1)
-    };
-    let value;
-    let buffer = '';
-    let total = iterator.length;
-    let bytesIn = total;
+    let tokens = [];
     let map = new Map;
+    let bytesIn = 0;
     let context = ast;
     if (options.sourcemap) {
         ast.loc = {
             sta: {
-                ind: ind,
-                lin: lin,
-                col: col
+                ind: 0,
+                lin: 1,
+                col: 1
             },
             src: ''
         };
     }
-    function getType(val) {
-        if (val === '') {
-            throw new Error('empty string?');
+    async function parseNode(results) {
+        let tokens = results.map(mapToken);
+        let i;
+        let loc;
+        for (i = 0; i < tokens.length; i++) {
+            if (tokens[i].typ == 'Comment') {
+                // @ts-ignore
+                context.chi.push(tokens[i]);
+                const position = map.get(tokens[i]);
+                loc = {
+                    sta: position,
+                    src
+                };
+                if (options.sourcemap) {
+                    tokens[i].loc = loc;
+                }
+            }
+            else if (tokens[i].typ != 'Whitespace') {
+                break;
+            }
         }
-        if (val == ':') {
-            return { typ: 'Colon' };
+        tokens = tokens.slice(i);
+        if (tokens.length == 0) {
+            return null;
         }
-        if (val == ')') {
-            return { typ: 'End-parens' };
+        let delim = tokens.at(-1);
+        if (delim.typ == 'Semi-colon' || delim.typ == 'Block-start' || delim.typ == 'Block-end') {
+            tokens.pop();
         }
-        if (val == '(') {
-            return { typ: 'Start-parens' };
-        }
-        if (val == '=') {
-            return { typ: 'Delim', val };
-        }
-        if (val == ';') {
-            return { typ: 'Semi-colon' };
-        }
-        if (val == ',') {
-            return { typ: 'Comma' };
-        }
-        if (val == '<') {
-            return { typ: 'Lt' };
-        }
-        if (val == '>') {
-            return { typ: 'Gt' };
-        }
-        if (isPseudo(val)) {
-            return val.endsWith('(') ? {
-                typ: 'Pseudo-class-func',
-                val: val.slice(0, -1),
-                chi: []
-            }
-                : {
-                    typ: 'Pseudo-class',
-                    val
-                };
-        }
-        if (isAtKeyword(val)) {
-            return {
-                typ: 'At-rule',
-                val: val.slice(1)
-            };
-        }
-        if (isFunction(val)) {
-            val = val.slice(0, -1);
-            return {
-                typ: val == 'url' ? 'UrlFunc' : 'Func',
-                val,
-                chi: []
-            };
-        }
-        if (isNumber(val)) {
-            return {
-                typ: 'Number',
-                val
-            };
-        }
-        if (isDimension(val)) {
-            return parseDimension(val);
-        }
-        if (isPercentage(val)) {
-            return {
-                typ: 'Perc',
-                val: val.slice(0, -1)
-            };
-        }
-        if (val == 'currentColor') {
-            return {
-                typ: 'Color',
-                val,
-                kin: 'lit'
-            };
-        }
-        if (isIdent(val)) {
-            return {
-                typ: 'Iden',
-                val
-            };
-        }
-        if (val.charAt(0) == '#' && isHash(val)) {
-            return {
-                typ: 'Hash',
-                val
-            };
-        }
-        if ('"\''.includes(val.charAt(0))) {
-            return {
-                typ: 'Unclosed-string',
-                val
-            };
-        }
-        return {
-            typ: 'Literal',
-            val
-        };
-    }
-    // consume and throw away
-    function consume(open, close) {
-        let count = 1;
-        let chr;
-        while (true) {
-            chr = next();
-            if (chr == '\\') {
-                if (peek() === '') {
-                    break;
-                }
-                continue;
-            }
-            else if (chr == '/' && peek() == '*') {
-                next();
-                while (true) {
-                    chr = next();
-                    if (chr === '') {
-                        break;
-                    }
-                    if (chr == '*' && peek() == '/') {
-                        next();
-                        break;
-                    }
-                }
-            }
-            else if (chr == close) {
-                count--;
-            }
-            else if (chr == open) {
-                count++;
-            }
-            if (chr === '' || count == 0) {
-                break;
-            }
-        }
-    }
-    async function parseNode(tokens) {
-        let i;
-        let loc;
-        for (i = 0; i < tokens.length; i++) {
-            if (tokens[i].typ == 'Comment') {
-                // @ts-ignore
-                context.chi.push(tokens[i]);
-                const position = map.get(tokens[i]);
-                loc = {
-                    sta: position,
-                    src
-                };
-                if (options.sourcemap) {
-                    tokens[i].loc = loc;
-                }
-            }
-            else if (tokens[i].typ != 'Whitespace') {
-                break;
-            }
-        }
-        tokens = tokens.slice(i);
-        if (tokens.length == 0) {
-            return null;
-        }
-        let delim = tokens.at(-1);
-        if (delim.typ == 'Semi-colon' || delim.typ == 'Block-start' || delim.typ == 'Block-end') {
-            tokens.pop();
-        }
-        else {
-            delim = { typ: 'Semi-colon' };
+        else {
+            delim = { typ: 'Semi-colon' };
         }
         // @ts-ignore
         while (['Whitespace', 'Bad-string', 'Bad-comment'].includes(tokens.at(-1)?.typ)) {
@@ -3327,12 +3861,12 @@ async function parse$1(iterator, opt = {}) {
                             // @ts-ignore
                             const root = await options.load(url, options.src).then((src) => {
                                 return parse$1(src, Object.assign({}, options, {
-                                    compress: false,
+                                    minify: false,
                                     // @ts-ignore
                                     src: options.resolve(url, options.src).absolute
                                 }));
                             });
-                            bytesIn += root.bytesIn;
+                            bytesIn += root.stats.bytesIn;
                             if (root.ast.chi.length > 0) {
                                 context.chi.push(...root.ast.chi);
                             }
@@ -3378,20 +3912,17 @@ async function parse$1(iterator, opt = {}) {
             // rule
             if (delim.typ == 'Block-start') {
                 const position = map.get(tokens[0]);
-                if (context.typ == 'Rule') {
-                    if (tokens[0]?.typ == 'Iden') {
-                        errors.push({ action: 'drop', message: 'invalid nesting rule', location: { src, ...position } });
-                        return null;
-                    }
-                }
                 const uniq = new Map;
-                parseTokens(tokens, 'Rule', { compress: options.compress }).reduce((acc, curr, index, array) => {
+                parseTokens(tokens, { minify: options.minify }).reduce((acc, curr, index, array) => {
                     if (curr.typ == 'Whitespace') {
-                        if (array[index - 1]?.val == '+' || array[index + 1]?.val == '+') {
+                        if (array[index - 1]?.typ == 'Gt' ||
+                            array[index + 1]?.typ == 'Gt' ||
+                            combinators.includes(array[index - 1]?.val) ||
+                            combinators.includes(array[index + 1]?.val)) {
                             return acc;
                         }
                     }
-                    let t = renderToken(curr, { compress: true });
+                    let t = renderToken(curr, { minify: true });
                     if (t == ',') {
                         acc.push([]);
                     }
@@ -3409,595 +3940,310 @@ async function parse$1(iterator, opt = {}) {
                     sel: [...uniq.keys()].join(','),
                     chi: []
                 };
-                let raw = [...uniq.values()];
-                Object.defineProperty(node, 'raw', { enumerable: false, writable: true, value: raw });
-                loc = {
-                    sta: position,
-                    src
-                };
-                if (options.sourcemap) {
-                    node.loc = loc;
-                }
-                // @ts-ignore
-                context.chi.push(node);
-                return node;
-            }
-            else {
-                // declaration
-                // @ts-ignore
-                let name = null;
-                // @ts-ignore
-                let value = null;
-                for (let i = 0; i < tokens.length; i++) {
-                    if (tokens[i].typ == 'Comment') {
-                        continue;
-                    }
-                    if (tokens[i].typ == 'Colon') {
-                        name = tokens.slice(0, i);
-                        value = parseTokens(tokens.slice(i + 1), 'Declaration', {
-                            parseColor: true,
-                            src: options.src,
-                            resolveUrls: options.resolveUrls,
-                            resolve: options.resolve,
-                            cwd: options.cwd
-                        });
-                    }
-                }
-                if (name == null) {
-                    name = tokens;
-                }
-                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') {
-                            errors.push({
-                                action: 'drop',
-                                message: 'invalid declaration',
-                                location: { src, ...position }
-                            });
-                            return null;
-                        }
-                    }
-                }
-                if (value == null) {
-                    errors.push({ action: 'drop', message: 'invalid declaration', location: { src, ...position } });
-                    return null;
-                }
-                if (value.length == 0) {
-                    errors.push({ action: 'drop', message: 'invalid declaration', location: { src, ...position } });
-                    return null;
-                }
-                const node = {
-                    typ: 'Declaration',
-                    // @ts-ignore
-                    nam: renderToken(name.shift(), { removeComments: true }),
-                    // @ts-ignore
-                    val: value
-                };
-                while (node.val[0]?.typ == 'Whitespace') {
-                    node.val.shift();
-                }
-                if (node.val.length == 0) {
-                    errors.push({ action: 'drop', message: 'invalid declaration', location: { src, ...position } });
-                    return null;
-                }
-                // @ts-ignore
-                context.chi.push(node);
-                return null;
-            }
-        }
-    }
-    function peek(count = 1) {
-        if (count == 1) {
-            return iterator.charAt(ind + 1);
-        }
-        return iterator.slice(ind + 1, ind + count + 1);
-    }
-    function prev(count = 1) {
-        if (count == 1) {
-            return ind == 0 ? '' : iterator.charAt(ind - 1);
-        }
-        return iterator.slice(ind - 1 - count, ind - 1);
-    }
-    function next(count = 1) {
-        let char = '';
-        while (count-- > 0 && ind < total) {
-            const codepoint = iterator.charCodeAt(++ind);
-            if (isNaN(codepoint)) {
-                return char;
-            }
-            char += iterator.charAt(ind);
-            if (isNewLine(codepoint)) {
-                lin++;
-                col = 0;
-            }
-            else {
-                col++;
-            }
-        }
-        return char;
-    }
-    function pushToken(token) {
-        tokens.push(token);
-        map.set(token, { ...position });
-        position.ind = ind;
-        position.lin = lin;
-        position.col = col == 0 ? 1 : col;
-    }
-    function consumeWhiteSpace() {
-        let count = 0;
-        while (isWhiteSpace(iterator.charAt(count + ind + 1).charCodeAt(0))) {
-            count++;
-        }
-        next(count);
-        return count;
-    }
-    function consumeString(quoteStr) {
-        const quote = quoteStr;
-        let value;
-        let hasNewLine = false;
-        if (buffer.length > 0) {
-            pushToken(getType(buffer));
-            buffer = '';
-        }
-        buffer += quoteStr;
-        while (ind < total) {
-            value = peek();
-            if (ind >= total) {
-                pushToken({ typ: hasNewLine ? 'Bad-string' : 'Unclosed-string', val: buffer });
-                break;
-            }
-            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;
-                }
-                // not hex or new line
-                // @ts-ignore
-                if (i == 1 && !isNewLine(codepoint)) {
-                    buffer += 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);
-                    continue;
-                }
-                // buffer += value;
-                if (ind >= total) {
-                    // drop '\\' at the end
-                    pushToken(getType(buffer));
-                    break;
-                }
-                buffer += next(2);
-                continue;
-            }
-            if (value == quote) {
-                buffer += value;
-                pushToken({ typ: hasNewLine ? 'Bad-string' : 'String', val: buffer });
-                next();
-                // i += value.length;
-                buffer = '';
-                break;
-            }
-            if (isNewLine(value.charCodeAt(0))) {
-                hasNewLine = true;
-            }
-            if (hasNewLine && value == ';') {
-                pushToken({ typ: 'Bad-string', val: buffer });
-                buffer = '';
-                break;
-            }
-            buffer += value;
-            // i += value.length;
-            next();
-        }
-    }
-    while (ind < total) {
-        value = next();
-        if (ind >= total) {
-            if (buffer.length > 0) {
-                pushToken(getType(buffer));
-                buffer = '';
-            }
-            break;
-        }
-        if (isWhiteSpace(value.charCodeAt(0))) {
-            if (buffer.length > 0) {
-                pushToken(getType(buffer));
-                buffer = '';
-            }
-            while (ind < total) {
-                value = next();
-                if (ind >= total) {
-                    break;
-                }
-                if (!isWhiteSpace(value.charCodeAt(0))) {
-                    break;
-                }
-            }
-            pushToken({ typ: 'Whitespace' });
-            buffer = '';
-            if (ind >= total) {
-                break;
-            }
-        }
-        switch (value) {
-            case '/':
-                if (buffer.length > 0 && tokens.at(-1)?.typ == 'Whitespace') {
-                    pushToken(getType(buffer));
-                    buffer = '';
-                    if (peek() != '*') {
-                        pushToken(getType(value));
-                        break;
-                    }
-                }
-                buffer += value;
-                if (peek() == '*') {
-                    buffer += '*';
-                    // i++;
-                    next();
-                    while (ind < total) {
-                        value = next();
-                        if (ind >= total) {
-                            pushToken({
-                                typ: 'Bad-comment', val: buffer
-                            });
-                            break;
-                        }
-                        if (value == '\\') {
-                            buffer += value;
-                            value = next();
-                            if (ind >= total) {
-                                pushToken({
-                                    typ: 'Bad-comment',
-                                    val: buffer
-                                });
-                                break;
-                            }
-                            buffer += value;
-                            continue;
-                        }
-                        if (value == '*') {
-                            buffer += value;
-                            value = next();
-                            if (ind >= total) {
-                                pushToken({
-                                    typ: 'Bad-comment', val: buffer
-                                });
-                                break;
-                            }
-                            buffer += value;
-                            if (value == '/') {
-                                pushToken({ typ: 'Comment', val: buffer });
-                                buffer = '';
-                                break;
-                            }
-                        }
-                        else {
-                            buffer += value;
-                        }
-                    }
-                }
-                break;
-            case '<':
-                if (buffer.length > 0) {
-                    pushToken(getType(buffer));
-                    buffer = '';
-                }
-                buffer += value;
-                value = next();
-                if (ind >= total) {
-                    break;
-                }
-                if (peek(3) == '!--') {
-                    while (ind < total) {
-                        value = next();
-                        if (ind >= total) {
-                            break;
-                        }
-                        buffer += value;
-                        if (value == '>' && prev(2) == '--') {
-                            pushToken({
-                                typ: 'CDOCOMM',
-                                val: buffer
-                            });
-                            buffer = '';
-                            break;
-                        }
-                    }
-                }
-                if (ind >= total) {
-                    pushToken({ typ: 'BADCDO', val: buffer });
-                    buffer = '';
-                }
-                break;
-            case '\\':
-                value = next();
-                // EOF
-                if (ind + 1 >= total) {
-                    // end of stream ignore \\
-                    pushToken(getType(buffer));
-                    buffer = '';
-                    break;
-                }
-                buffer += value;
-                break;
-            case '"':
-            case "'":
-                consumeString(value);
-                break;
-            case '~':
-            case '|':
-                if (tokens.at(-1)?.typ == 'Whitespace') {
-                    tokens.pop();
-                }
-                if (buffer.length > 0) {
-                    pushToken(getType(buffer));
-                    buffer = '';
-                }
-                buffer += value;
-                value = next();
-                if (ind >= total) {
-                    pushToken(getType(buffer));
-                    buffer = '';
-                    break;
-                }
-                if (value == '=') {
-                    buffer += value;
-                    pushToken({
-                        typ: buffer[0] == '~' ? 'Includes' : 'Dash-matches',
-                        val: buffer
-                    });
-                    buffer = '';
-                    break;
-                }
-                pushToken(getType(buffer));
-                while (isWhiteSpace(value.charCodeAt(0))) {
-                    value = next();
-                }
-                buffer = value;
-                break;
-            case '>':
-                if (buffer !== '') {
-                    pushToken(getType(buffer));
-                    buffer = '';
-                }
-                if (tokens[tokens.length - 1]?.typ == 'Whitespace') {
-                    tokens.pop();
-                }
-                pushToken({ typ: 'Gt' });
-                consumeWhiteSpace();
-                break;
-            case '.':
-                const codepoint = peek().charCodeAt(0);
-                if (!isDigit(codepoint) && buffer !== '') {
-                    pushToken(getType(buffer));
-                    buffer = value;
-                    break;
-                }
-                buffer += value;
-                break;
-            case '+':
-            case ':':
-            case ',':
-            case '=':
-                if (buffer.length > 0) {
-                    pushToken(getType(buffer));
-                    buffer = '';
-                }
-                if (value == ':' && ':' == peek()) {
-                    buffer += value + next();
-                    break;
-                }
-                pushToken(getType(value));
-                buffer = '';
-                if (value == '+' && isWhiteSpace(peek().charCodeAt(0))) {
-                    pushToken(getType(next()));
-                }
-                while (isWhiteSpace(peek().charCodeAt(0))) {
-                    next();
+                let raw = [...uniq.values()];
+                Object.defineProperty(node, 'raw', { enumerable: false, writable: true, value: raw });
+                loc = {
+                    sta: position,
+                    src
+                };
+                if (options.sourcemap) {
+                    node.loc = loc;
                 }
-                break;
-            case ')':
-                if (buffer.length > 0) {
-                    pushToken(getType(buffer));
-                    buffer = '';
+                // @ts-ignore
+                context.chi.push(node);
+                return node;
+            }
+            else {
+                // declaration
+                // @ts-ignore
+                let name = null;
+                // @ts-ignore
+                let value = null;
+                for (let i = 0; i < tokens.length; i++) {
+                    if (tokens[i].typ == 'Comment') {
+                        continue;
+                    }
+                    if (tokens[i].typ == 'Colon') {
+                        name = tokens.slice(0, i);
+                        value = parseTokens(tokens.slice(i + 1), {
+                            parseColor: true,
+                            src: options.src,
+                            resolveUrls: options.resolveUrls,
+                            resolve: options.resolve,
+                            cwd: options.cwd
+                        });
+                    }
                 }
-                pushToken({ typ: 'End-parens' });
-                break;
-            case '(':
-                if (buffer.length == 0) {
-                    pushToken({ typ: 'Start-parens' });
+                if (name == null) {
+                    name = tokens;
                 }
-                else {
-                    buffer += value;
-                    pushToken(getType(buffer));
-                    buffer = '';
-                    const token = tokens[tokens.length - 1];
-                    if (token.typ == 'UrlFunc') {
-                        // consume either string or url token
-                        let whitespace = '';
-                        value = peek();
-                        while (isWhiteSpace(value.charCodeAt(0))) {
-                            whitespace += value;
-                        }
-                        if (whitespace.length > 0) {
-                            next(whitespace.length);
-                        }
-                        value = peek();
-                        if (value == '"' || value == "'") {
-                            consumeString(next());
-                            let token = tokens[tokens.length - 1];
-                            if (['String', 'Literal'].includes(token.typ) && urlTokenMatcher.test(token.val)) {
-                                if (token.val.slice(1, 6) != 'data:') {
-                                    if (token.typ == 'String') {
-                                        token.val = token.val.slice(1, -1);
-                                    }
-                                    // @ts-ignore
-                                    token.typ = 'Url-token';
-                                }
-                            }
-                            break;
-                        }
-                        else {
-                            buffer = '';
-                            do {
-                                let cp = value.charCodeAt(0);
-                                // EOF -
-                                if (cp == null) {
-                                    pushToken({ typ: 'Bad-url-token', val: buffer });
-                                    break;
-                                }
-                                // ')'
-                                if (cp == 0x29 || cp == null) {
-                                    if (buffer.length == 0) {
-                                        pushToken({ typ: 'Bad-url-token', val: '' });
-                                    }
-                                    else {
-                                        pushToken({ typ: 'Url-token', val: buffer });
-                                    }
-                                    if (cp != null) {
-                                        pushToken(getType(next()));
-                                    }
-                                    break;
-                                }
-                                if (isWhiteSpace(cp)) {
-                                    whitespace = next();
-                                    while (true) {
-                                        value = peek();
-                                        cp = value.charCodeAt(0);
-                                        if (isWhiteSpace(cp)) {
-                                            whitespace += value;
-                                            continue;
-                                        }
-                                        break;
-                                    }
-                                    if (cp == null || cp == 0x29) {
-                                        continue;
-                                    }
-                                    // bad url token
-                                    buffer += next(whitespace.length);
-                                    do {
-                                        value = peek();
-                                        cp = value.charCodeAt(0);
-                                        if (cp == null || cp == 0x29) {
-                                            break;
-                                        }
-                                        buffer += next();
-                                    } while (true);
-                                    pushToken({ typ: 'Bad-url-token', val: buffer });
-                                    continue;
-                                }
-                                buffer += next();
-                                value = peek();
-                            } while (true);
-                            buffer = '';
+                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') {
+                            errors.push({
+                                action: 'drop',
+                                message: 'invalid declaration',
+                                location: { src, ...position }
+                            });
+                            return null;
                         }
                     }
                 }
-                break;
-            case '[':
-            case ']':
-            case '{':
-            case '}':
-            case ';':
-                if (buffer.length > 0) {
-                    pushToken(getType(buffer));
-                    buffer = '';
+                if (value == null) {
+                    errors.push({
+                        action: 'drop',
+                        message: 'invalid declaration',
+                        location: { src, ...position }
+                    });
+                    return null;
                 }
-                pushToken(getBlockType(value));
-                let node = null;
-                if (value == '{' || value == ';') {
-                    node = await parseNode(tokens);
-                    if (node != null) {
-                        stack.push(node);
-                        // @ts-ignore
-                        context = node;
-                    }
-                    else if (value == '{') {
-                        // node == null
-                        // consume and throw away until the closing '}' or EOF
-                        consume('{', '}');
-                    }
-                    tokens.length = 0;
-                    map.clear();
+                if (value.length == 0) {
+                    errors.push({
+                        action: 'drop',
+                        message: 'invalid declaration',
+                        location: { src, ...position }
+                    });
+                    return null;
                 }
-                else if (value == '}') {
-                    await parseNode(tokens);
-                    const previousNode = stack.pop();
+                const node = {
+                    typ: 'Declaration',
                     // @ts-ignore
-                    context = stack[stack.length - 1] || ast;
+                    nam: renderToken(name.shift(), { removeComments: true }),
                     // @ts-ignore
-                    if (options.removeEmpty && previousNode != null && previousNode.chi.length == 0 && context.chi[context.chi.length - 1] == previousNode) {
-                        context.chi.pop();
-                    }
-                    tokens.length = 0;
-                    map.clear();
-                    buffer = '';
-                }
-                break;
-            case '!':
-                if (buffer.length > 0) {
-                    pushToken(getType(buffer));
-                    buffer = '';
+                    val: value
+                };
+                while (node.val[0]?.typ == 'Whitespace') {
+                    node.val.shift();
                 }
-                const important = peek(9);
-                if (important == 'important') {
-                    if (tokens[tokens.length - 1]?.typ == 'Whitespace') {
-                        tokens.pop();
-                    }
-                    pushToken({ typ: 'Important' });
-                    next(9);
-                    buffer = '';
-                    break;
+                if (node.val.length == 0) {
+                    errors.push({
+                        action: 'drop',
+                        message: 'invalid declaration',
+                        location: { src, ...position }
+                    });
+                    return null;
                 }
-                buffer = '!';
-                break;
-            default:
-                buffer += value;
-                break;
+                // @ts-ignore
+                context.chi.push(node);
+                return null;
+            }
         }
     }
-    if (buffer.length > 0) {
-        pushToken(getType(buffer));
+    function mapToken(token) {
+        const node = getTokenType(token.token, token.hint);
+        map.set(node, token.position);
+        return node;
+    }
+    const iter = tokenize(iterator);
+    let item;
+    while (true) {
+        item = iter.next().value;
+        if (item == null) {
+            break;
+        }
+        tokens.push(item);
+        bytesIn = item.bytesIn;
+        if (item.token == ';' || item.token == '{') {
+            let node = await parseNode(tokens);
+            if (node != null) {
+                stack.push(node);
+                // @ts-ignore
+                context = node;
+            }
+            else if (item.token == '{') {
+                // node == null
+                // consume and throw away until the closing '}' or EOF
+                let inBlock = 1;
+                do {
+                    item = iter.next().value;
+                    if (item == null) {
+                        break;
+                    }
+                    if (item.token == '{') {
+                        inBlock++;
+                    }
+                    else if (item.token == '}') {
+                        inBlock--;
+                    }
+                } while (inBlock != 0);
+            }
+            tokens = [];
+            map = new Map;
+        }
+        else if (item.token == '}') {
+            await parseNode(tokens);
+            const previousNode = stack.pop();
+            // @ts-ignore
+            context = stack[stack.length - 1] || ast;
+            // @ts-ignore
+            if (options.removeEmpty && previousNode != null && previousNode.chi.length == 0 && context.chi[context.chi.length - 1] == previousNode) {
+                context.chi.pop();
+            }
+            tokens = [];
+            map = new Map;
+        }
     }
     if (tokens.length > 0) {
         await parseNode(tokens);
     }
-    if (options.compress) {
+    const endParseTime = performance.now();
+    if (options.minify) {
         if (ast.chi.length > 0) {
-            deduplicate(ast, options, true);
+            minify(ast, options, true);
+        }
+    }
+    const endTime = performance.now();
+    return {
+        ast, errors, stats: {
+            bytesIn,
+            parse: `${(endParseTime - startTime).toFixed(2)}ms`,
+            minify: `${(endTime - endParseTime).toFixed(2)}ms`,
+            total: `${(endTime - startTime).toFixed(2)}ms`
+        }
+    };
+}
+function parseString(src, options = { location: false }) {
+    return [...tokenize(src)].map(t => {
+        const token = getTokenType(t.token, t.hint);
+        if (options.location) {
+            Object.assign(token, { loc: t.position });
         }
+        return token;
+    });
+}
+function getTokenType(val, hint) {
+    if (val === '' && hint == null) {
+        throw new Error('empty string?');
+    }
+    if (hint != null) {
+        return ([
+            'Whitespace', 'Semi-colon', 'Colon', 'Block-start',
+            'Block-start', 'Attr-start', 'Attr-end', 'Start-parens', 'End-parens',
+            'Comma', 'Gt', 'Lt'
+        ].includes(hint) ? { typ: hint } : { typ: hint, val });
+    }
+    if (val == ' ') {
+        return { typ: 'Whitespace' };
+    }
+    if (val == ';') {
+        return { typ: 'Semi-colon' };
+    }
+    if (val == '{') {
+        return { typ: 'Block-start' };
+    }
+    if (val == '}') {
+        return { typ: 'Block-end' };
+    }
+    if (val == '[') {
+        return { typ: 'Attr-start' };
+    }
+    if (val == ']') {
+        return { typ: 'Attr-end' };
+    }
+    if (val == ':') {
+        return { typ: 'Colon' };
+    }
+    if (val == ')') {
+        return { typ: 'End-parens' };
+    }
+    if (val == '(') {
+        return { typ: 'Start-parens' };
+    }
+    if (val == '=') {
+        return { typ: 'Delim', val };
+    }
+    if (val == ';') {
+        return { typ: 'Semi-colon' };
+    }
+    if (val == ',') {
+        return { typ: 'Comma' };
+    }
+    if (val == '<') {
+        return { typ: 'Lt' };
+    }
+    if (val == '>') {
+        return { typ: 'Gt' };
+    }
+    if (isPseudo(val)) {
+        return val.endsWith('(') ? {
+            typ: 'Pseudo-class-func',
+            val: val.slice(0, -1),
+            chi: []
+        }
+            : {
+                typ: 'Pseudo-class',
+                val
+            };
+    }
+    if (isAtKeyword(val)) {
+        return {
+            typ: 'At-rule',
+            val: val.slice(1)
+        };
+    }
+    if (isFunction(val)) {
+        val = val.slice(0, -1);
+        return {
+            typ: val == 'url' ? 'UrlFunc' : 'Func',
+            val,
+            chi: []
+        };
+    }
+    if (isNumber(val)) {
+        return {
+            typ: 'Number',
+            val
+        };
+    }
+    if (isDimension(val)) {
+        return parseDimension(val);
     }
-    return { ast, errors, bytesIn };
+    if (isPercentage(val)) {
+        return {
+            typ: 'Perc',
+            val: val.slice(0, -1)
+        };
+    }
+    const v = val.toLowerCase();
+    if (v == 'currentcolor' || val == 'transparent' || v in COLORS_NAMES) {
+        return {
+            typ: 'Color',
+            val,
+            kin: 'lit'
+        };
+    }
+    if (isIdent(val)) {
+        return {
+            typ: 'Iden',
+            val
+        };
+    }
+    if (val.charAt(0) == '#' && isHexColor(val)) {
+        return {
+            typ: 'Color',
+            val,
+            kin: 'hex'
+        };
+    }
+    if (val.charAt(0) == '#' && isHash(val)) {
+        return {
+            typ: 'Hash',
+            val
+        };
+    }
+    if ('"\''.includes(val.charAt(0))) {
+        return {
+            typ: 'Unclosed-string',
+            val
+        };
+    }
+    return {
+        typ: 'Literal',
+        val
+    };
 }
-function parseTokens(tokens, nodeType, options = {}) {
+function parseTokens(tokens, options = {}) {
     for (let i = 0; i < tokens.length; i++) {
         const t = tokens[i];
         if (t.typ == 'Whitespace' && ((i == 0 ||
@@ -4051,7 +4297,7 @@ function parseTokens(tokens, nodeType, options = {}) {
                 if (t.chi.length > 1) {
                     /*(<AttrToken>t).chi =*/
                     // @ts-ignore
-                    parseTokens(t.chi, t.typ, options);
+                    parseTokens(t.chi, t.typ);
                 }
                 // @ts-ignore
                 t.chi.forEach(val => {
@@ -4163,8 +4409,8 @@ function parseTokens(tokens, nodeType, options = {}) {
             // @ts-ignore
             if (t.chi.length > 0) {
                 // @ts-ignore
-                parseTokens(t.chi, t.typ, options);
-                if (t.typ == 'Pseudo-class-func' && t.val == ':is' && options.compress) {
+                parseTokens(t.chi, t.typ);
+                if (t.typ == 'Pseudo-class-func' && t.val == ':is' && options.minify) {
                     //
                     const count = t.chi.filter(t => t.typ != 'Comment').length;
                     if (count == 1 ||
@@ -4202,54 +4448,21 @@ function parseTokens(tokens, nodeType, options = {}) {
     }
     return tokens;
 }
-function getBlockType(chr) {
-    if (chr == ';') {
-        return { typ: 'Semi-colon' };
-    }
-    if (chr == '{') {
-        return { typ: 'Block-start' };
-    }
-    if (chr == '}') {
-        return { typ: 'Block-end' };
-    }
-    if (chr == '[') {
-        return { typ: 'Attr-start' };
-    }
-    if (chr == ']') {
-        return { typ: 'Attr-end' };
-    }
-    throw new Error(`unhandled token: '${chr}'`);
-}
-
-function* walk(node) {
-    // @ts-ignore
-    yield* doWalk(node, null, null);
-}
-function* doWalk(node, parent, root) {
-    yield { node, parent, root };
-    if ('chi' in node) {
-        for (const child of node.chi) {
-            yield* doWalk(child, node, (root ?? node));
-        }
-    }
-}
 
 async function transform$1(css, options = {}) {
-    options = { compress: true, removeEmpty: true, ...options };
+    options = { minify: true, removeEmpty: true, ...options };
     const startTime = performance.now();
-    const parseResult = await parse$1(css, options);
-    const renderTime = performance.now();
-    const rendered = render(parseResult.ast, options);
-    const endTime = performance.now();
-    return {
-        ...parseResult, ...rendered, stats: {
-            bytesIn: parseResult.bytesIn,
-            bytesOut: rendered.code.length,
-            parse: `${(renderTime - startTime).toFixed(2)}ms`,
-            render: `${(endTime - renderTime).toFixed(2)}ms`,
-            total: `${(endTime - startTime).toFixed(2)}ms`
-        }
-    };
+    return parse$1(css, options).then((parseResult) => {
+        const rendered = render(parseResult.ast, options);
+        return {
+            ...parseResult, ...rendered, stats: {
+                bytesOut: rendered.code.length,
+                ...parseResult.stats,
+                render: rendered.stats.total,
+                total: `${(performance.now() - startTime).toFixed(2)}ms`
+            }
+        };
+    });
 }
 
 const matchUrl = /^(https?:)?\/\//;
@@ -4369,16 +4582,42 @@ function transform(css, options = {}) {
     return transform$1(css, Object.assign(options, { load, resolve, cwd: options.cwd ?? process.cwd() }));
 }
 
-exports.deduplicate = deduplicate;
-exports.deduplicateRule = deduplicateRule;
+exports.combinators = combinators;
 exports.dirname = dirname;
+exports.getConfig = getConfig;
 exports.hasDeclaration = hasDeclaration;
+exports.isAngle = isAngle;
+exports.isAtKeyword = isAtKeyword;
+exports.isDigit = isDigit;
+exports.isDimension = isDimension;
+exports.isFrequency = isFrequency;
+exports.isFunction = isFunction;
+exports.isHash = isHash;
+exports.isHexColor = isHexColor;
+exports.isHexDigit = isHexDigit;
+exports.isIdent = isIdent;
+exports.isIdentCodepoint = isIdentCodepoint;
+exports.isIdentStart = isIdentStart;
+exports.isLength = isLength;
+exports.isNewLine = isNewLine;
+exports.isNumber = isNumber;
+exports.isPercentage = isPercentage;
+exports.isPseudo = isPseudo;
+exports.isResolution = isResolution;
+exports.isTime = isTime;
+exports.isWhiteSpace = isWhiteSpace;
 exports.load = load;
 exports.matchUrl = matchUrl;
+exports.minify = minify;
+exports.minifyRule = minifyRule;
 exports.parse = parse;
+exports.parseDimension = parseDimension;
+exports.parseString = parseString;
 exports.reduceSelector = reduceSelector;
 exports.render = render;
 exports.renderToken = renderToken;
 exports.resolve = resolve;
+exports.tokenize = tokenize;
 exports.transform = transform;
+exports.urlTokenMatcher = urlTokenMatcher;
 exports.walk = walk;