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

package/dist/index.cjs

@@ -1455,7 +1455,6 @@ function hsl2rgb(h, s, l, a = null) {
     return values;
 }
 
-const indents = [];
 function render(data, opt = {}) {
     const options = Object.assign(opt.compress ? {
         indent: '',
@@ -1473,27 +1472,12 @@ function render(data, opt = {}) {
                 return acc;
             }
         }
-        // if (options.compress && curr.typ == 'Whitespace') {
-        //
-        //     if (original[index + 1]?.typ == 'Start-parens' ||
-        //         (index > 0 && (original[index - 1].typ == 'Pseudo-class-func' ||
-        //         original[index - 1].typ == 'End-parens' ||
-        //         original[index - 1].typ == 'UrlFunc' ||
-        //         original[index - 1].typ == 'Func' ||
-        //         (
-        //             original[index - 1].typ == 'Color' &&
-        //             (<ColorToken>original[index - 1]).kin != 'hex' &&
-        //             (<ColorToken>original[index - 1]).kin != 'lit')))) {
-        //
-        //         return acc;
-        //     }
-        // }
         return acc + renderToken(curr, options);
     }
-    return { code: doRender(data, options, reducer) };
+    return { code: doRender(data, options, reducer, 0) };
 }
 // @ts-ignore
-function doRender(data, options, reducer, level = 0) {
+function doRender(data, options, reducer, level = 0, indents = []) {
     if (indents.length < level + 1) {
         indents.push(options.indent.repeat(level));
     }
@@ -1507,7 +1491,7 @@ function doRender(data, options, reducer, level = 0) {
             return options.removeComments ? '' : data.val;
         case 'StyleSheet':
             return data.chi.reduce((css, node) => {
-                const str = doRender(node, options, reducer, level);
+                const str = doRender(node, options, reducer, level, indents);
                 if (str === '') {
                     return css;
                 }
@@ -1534,7 +1518,7 @@ function doRender(data, options, reducer, level = 0) {
                     str = `@${node.nam} ${node.val};`;
                 }
                 else {
-                    str = doRender(node, options, reducer, level + 1);
+                    str = doRender(node, options, reducer, level + 1, indents);
                 }
                 if (css === '') {
                     return str;
@@ -1542,8 +1526,7 @@ function doRender(data, options, reducer, level = 0) {
                 if (str === '') {
                     return css;
                 }
-                if (str !== '')
-                    return `${css}${options.newLine}${indentSub}${str}`;
+                return `${css}${options.newLine}${indentSub}${str}`;
             }, '');
             if (children.endsWith(';')) {
                 children = children.slice(0, -1);
@@ -2255,6 +2238,54 @@ 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,
+        // @ts-ignore
+        value: match.match.map(t => t.slice())
+    });
+    if (pSel == '&' || pSel === '') {
+        // @ts-ignore
+        wrapper.chi.push(...previous.chi);
+        // @ts-ignore
+        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(previous, node);
+    }
+    // @ts-ignore
+    ast.chi.splice(i, 1, wrapper);
+    // @ts-ignore
+    ast.chi.splice(nodeIndex, 1);
+    // @ts-ignore
+    previous.sel = pSel;
+    // @ts-ignore
+    previous.raw = match.selector1;
+    // @ts-ignore
+    node.sel = nSel;
+    // @ts-ignore
+    node.raw = match.selector2;
+    reduceRuleSelector(wrapper);
+    return wrapper;
+}
 function deduplicate(ast, options = {}, recursive = false) {
     // @ts-ignore
     if (('chi' in ast) && ast.chi?.length > 0) {
@@ -2270,6 +2301,14 @@ function deduplicate(ast, options = {}, recursive = false) {
             }
             // @ts-ignore
             node = ast.chi[i];
+            // @ts-ignore
+            if (previous == node) {
+                // console.error('idem!');
+                // @ts-ignore
+                ast.chi.splice(i, 1);
+                i--;
+                continue;
+            }
             if (node.typ == 'AtRule' && node.nam == 'font-face') {
                 continue;
             }
@@ -2282,120 +2321,106 @@ function deduplicate(ast, options = {}, recursive = false) {
             // @ts-ignore
             if (node.typ == 'Rule') {
                 reduceRuleSelector(node);
+                let wrapper;
+                let match;
                 // @ts-ignore
-                if (options.nestingRules && node.raw != null && previous?.raw != null && node.raw.length == 1 && previous.raw.length == 1) {
-                    const match = [];
+                if (options.nestingRules) {
                     // @ts-ignore
-                    while (node.raw[0].length > 0 && previous.raw[0].length > 0) {
+                    if (previous != null && previous.typ == 'Rule') {
+                        reduceRuleSelector(previous);
                         // @ts-ignore
-                        if (node.raw[0][0] != previous.raw[0][0]) {
-                            break;
-                        }
-                        // @ts-ignore
-                        match.push(node.raw[0].shift());
-                        // @ts-ignore
-                        previous.raw[0].shift();
-                    }
-                    if (match.length > 0) {
+                        match = matchSelectors(previous.raw, node.raw, ast.typ);
                         // @ts-ignore
-                        const wrapper = { ...previous, chi: [] };
-                        // @ts-ignore
-                        if (previous.raw[0].length == 0) {
+                        if (match != null) {
                             // @ts-ignore
-                            wrapper.chi.push(...previous.chi);
-                        }
-                        else {
+                            wrapper = wrapNodes(previous, node, match, ast, i, nodeIndex);
+                            nodeIndex = i - 1;
                             // @ts-ignore
-                            previous.sel = previous.raw.reduce((acc, curr) => {
-                                acc.push(curr.join(''));
-                                return acc;
-                            }, []).join(',');
-                            // @ts-ignore
-                            wrapper.chi.push(previous);
+                            previous = ast.chi[nodeIndex];
                         }
-                        // @ts-ignore
-                        if (node.raw[0].length == 0) {
-                            // @ts-ignore
-                            if (previous.raw.length == 0) {
-                                // @ts-ignore
-                                wrapper.chi.push(...node.chi);
-                            }
-                            else {
-                                if (hasOnlyDeclarations(wrapper)) {
-                                    wrapper.chi.push(...node.chi);
-                                }
-                                else {
-                                    // @ts-ignore
-                                    node.raw[0].push('&');
-                                    // @ts-ignore
-                                    node.sel = node.raw.reduce((acc, curr) => {
-                                        acc.push(curr.join(''));
-                                        return acc;
-                                    }, []).join(',');
-                                    // @ts-ignore
-                                    wrapper.chi.push(node);
-                                }
-                            }
-                        }
-                        else {
-                            // @ts-ignore
-                            node.sel = node.raw.reduce((acc, curr) => {
-                                acc.push(curr.join(''));
-                                return acc;
-                            }, []).join(',');
-                            // @ts-ignore
-                            wrapper.chi.push(node);
-                        }
-                        Object.defineProperty(wrapper, 'raw', { enumerable: false, writable: true, value: [match] });
-                        // @ts-ignore
-                        ast.chi.splice(i, 1, wrapper);
-                        // @ts-ignore
-                        ast.chi.splice(nodeIndex, 1);
+                    }
+                    // @ts-ignore
+                    if (wrapper != null) {
                         // @ts-ignore
                         while (i < ast.chi.length) {
                             // @ts-ignore
                             const nextNode = ast.chi[i];
                             // @ts-ignore
-                            if (nextNode.typ != 'Rule' || nextNode.raw == null) {
+                            if (nextNode.typ != 'Rule') {
+                                // i--;
+                                // previous = wrapper;
+                                // nodeIndex = i;
                                 break;
                             }
                             reduceRuleSelector(nextNode);
                             // @ts-ignore
-                            if (nextNode.raw.length != 1 || !eq(wrapper.raw[0], nextNode.raw[0].slice(0, wrapper.raw[0].length))) {
+                            match = matchSelectors(wrapper.raw, nextNode.raw, ast.typ);
+                            // @ts-ignore
+                            if (match == null) {
                                 break;
                             }
                             // @ts-ignore
-                            nextNode.raw[0].splice(0, wrapper.raw[0].length);
+                            wrapper = wrapNodes(wrapper, nextNode, match, ast, i, nodeIndex);
+                        }
+                        nodeIndex = --i;
+                        // @ts-ignore
+                        previous = ast.chi[nodeIndex];
+                        deduplicate(wrapper, options, recursive);
+                        continue;
+                    }
+                    // @ts-ignore
+                    else if (node.optimized != null &&
+                        // @ts-ignore
+                        node.optimized.match &&
+                        // @ts-ignore
+                        node.optimized.selector.length > 1) {
+                        // @ts-ignore
+                        wrapper = { ...node, chi: [], sel: node.optimized.optimized[0] };
+                        // @ts-ignore
+                        Object.defineProperty(wrapper, 'raw', {
+                            enumerable: false,
+                            writable: true,
                             // @ts-ignore
-                            if (nextNode.raw[0].length == 0 ||
-                                // @ts-ignore
-                                (nextNode.raw.length == 1 && nextNode.raw[0] == '&')) {
-                                if (hasOnlyDeclarations(wrapper)) {
-                                    wrapper.chi.push(...nextNode.chi);
-                                    // @ts-ignore
-                                    ast.chi.splice(i, 1);
-                                    continue;
+                            value: [[node.optimized.optimized[0]]]
+                        });
+                        // @ts-ignore
+                        node.sel = node.optimized.selector.reduce(reducer, []).join(',');
+                        // @ts-ignore
+                        node.raw = node.optimized.selector.slice();
+                        // @ts-ignore
+                        wrapper.chi.push(node);
+                        // @ts-ignore
+                        ast.chi.splice(i, 1, wrapper);
+                        node = wrapper;
+                    }
+                }
+                // @ts-ignore
+                else if (node.optimized?.match) {
+                    let wrap = true;
+                    // @ts-ignore
+                    const selector = node.optimized.selector.reduce((acc, curr) => {
+                        if (curr[0] == '&') {
+                            if (curr[1] == ' ') {
+                                curr.splice(0, 2);
+                            }
+                            else {
+                                if (ast.typ != 'Rule' && combinators.includes(curr[1])) {
+                                    wrap = false;
                                 }
                                 else {
-                                    // @ts-ignore
-                                    nextNode.raw[0].push('&');
+                                    curr.splice(0, 1);
                                 }
                             }
-                            // @ts-ignore
-                            nextNode.sel = nextNode.raw.reduce((acc, curr) => {
-                                acc.push(curr.join(''));
-                                return acc;
-                            }, []).join(',');
-                            wrapper.chi.push(nextNode);
-                            // @ts-ignore
-                            ast.chi.splice(i, 1);
                         }
-                        deduplicateRule(wrapper);
-                        nodeIndex = --i;
+                        else if (combinators.includes(curr[0])) {
+                            curr.unshift('&');
+                        }
                         // @ts-ignore
-                        previous = ast.chi[i];
-                        continue;
-                    }
+                        acc.push(curr.map(t => t.replaceAll('&', node.optimized.optimized[0])).join(''));
+                        return acc;
+                    }, []);
+                    // @ts-ignore
+                    node.sel = (wrap ? node.optimized.optimized[0] : '') + `:is(${selector.join(',')})`;
                 }
             }
             // @ts-ignore
@@ -2425,6 +2450,7 @@ function deduplicate(ast, options = {}, recursive = false) {
                             ast.chi.splice(nodeIndex, 1);
                             // @ts-ignore
                             if (hasDeclaration(node)) {
+                                // @ts-ignore
                                 deduplicateRule(node);
                             }
                             else {
@@ -2469,6 +2495,7 @@ function deduplicate(ast, options = {}, recursive = false) {
                 if (recursive && previous != node) {
                     // @ts-ignore
                     if (hasDeclaration(previous)) {
+                        // @ts-ignore
                         deduplicateRule(previous);
                     }
                     else {
@@ -2486,6 +2513,7 @@ function deduplicate(ast, options = {}, recursive = false) {
                 deduplicateRule(node);
             }
             else {
+                // @ts-ignore
                 if (!(node.typ == 'AtRule' && node.nam != 'font-face')) {
                     deduplicate(node, options, recursive);
                 }
@@ -2516,7 +2544,7 @@ function hasDeclaration(node) {
     }
     return true;
 }
-function deduplicateRule(ast, options = {}) {
+function deduplicateRule(ast) {
     // @ts-ignore
     if (!('chi' in ast) || ast.chi?.length <= 1) {
         return ast;
@@ -2566,15 +2594,39 @@ function deduplicateRule(ast, options = {}) {
     return ast;
 }
 function splitRule(buffer) {
-    const result = [];
+    const result = [[]];
     let str = '';
     for (let i = 0; i < buffer.length; i++) {
         let chr = buffer.charAt(i);
+        if (isWhiteSpace(chr.charCodeAt(0))) {
+            let k = i;
+            while (k + 1 < buffer.length) {
+                if (isWhiteSpace(buffer[k + 1].charCodeAt(0))) {
+                    k++;
+                    continue;
+                }
+                break;
+            }
+            if (str !== '') {
+                // @ts-ignore
+                result.at(-1).push(str);
+                str = '';
+            }
+            // @ts-ignore
+            if (result.at(-1).length > 0) {
+                // @ts-ignore
+                result.at(-1).push(' ');
+            }
+            i = k;
+            continue;
+        }
         if (chr == ',') {
             if (str !== '') {
-                result.push(str);
+                // @ts-ignore
+                result.at(-1).push(str);
                 str = '';
             }
+            result.push([]);
             continue;
         }
         str += chr;
@@ -2624,38 +2676,45 @@ function splitRule(buffer) {
         }
     }
     if (str !== '') {
-        result.push(str);
+        // @ts-ignore
+        result.at(-1).push(str);
     }
     return result;
 }
 function reduceRuleSelector(node) {
+    if (node.raw == null) {
+        Object.defineProperty(node, 'raw', { enumerable: false, writable: true, value: splitRule(node.sel) });
+    }
     // @ts-ignore
-    if (node.raw != null) {
-        // @ts-ignore
-        let optimized = reduceSelector(node.raw);
-        if (optimized != null) {
-            Object.defineProperty(node, 'optimized', { enumerable: false, writable: true, value: optimized });
-        }
-        if (optimized != null && optimized.match && optimized.reducible) {
-            const raw = [
-                [
-                    optimized.optimized[0], ':is('
-                ].concat(optimized.selector.reduce((acc, curr) => {
-                    if (acc.length > 0) {
-                        acc.push(',');
-                    }
-                    acc.push(...curr);
-                    return acc;
-                }, [])).concat(')')
-            ];
-            const sel = raw[0].join('');
-            if (sel.length < node.sel.length) {
-                node.sel = sel;
-                // node.raw = raw;
-                Object.defineProperty(node, 'raw', { enumerable: false, writable: true, value: raw });
-            }
+    // if (node.raw != null) {
+    // @ts-ignore
+    let optimized = reduceSelector(node.raw.reduce((acc, curr) => {
+        acc.push(curr.slice());
+        return acc;
+    }, []));
+    if (optimized != null) {
+        Object.defineProperty(node, 'optimized', { enumerable: false, writable: true, value: optimized });
+    }
+    if (optimized != null && optimized.match && optimized.reducible && optimized.selector.length > 1) {
+        const raw = [
+            [
+                optimized.optimized[0], ':is('
+            ].concat(optimized.selector.reduce((acc, curr) => {
+                if (acc.length > 0) {
+                    acc.push(',');
+                }
+                acc.push(...curr);
+                return acc;
+            }, [])).concat(')')
+        ];
+        const sel = raw[0].join('');
+        if (sel.length < node.sel.length) {
+            node.sel = sel;
+            // node.raw = raw;
+            Object.defineProperty(node, 'raw', { enumerable: false, writable: true, value: raw });
         }
     }
+    // }
 }
 function diff(n1, n2, options = {}) {
     let node1 = n1;
@@ -2676,25 +2735,25 @@ function diff(n1, n2, options = {}) {
     // @ts-ignore
     const raw1 = node1.raw;
     // @ts-ignore
-    const optimized1 = node1.optimized;
+    // const optimized1 = node1.optimized;
     // @ts-ignore
     const raw2 = node2.raw;
     // @ts-ignore
-    const optimized2 = node2.optimized;
+    // 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 (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 });
-    }
+    // if (optimized2 != null) {
+    //     Object.defineProperty(node2, 'optimized', {enumerable: false, writable: true, value: optimized2});
+    // }
     const intersect = [];
     while (i--) {
         if (node1.chi[i].typ == 'Comment') {
@@ -2722,7 +2781,7 @@ function diff(n1, n2, options = {}) {
     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(),
+        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)) {
@@ -2731,8 +2790,169 @@ function diff(n1, n2, options = {}) {
     }
     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;
+            }
+        }
+        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
+    };
+}
 function reduceSelector(selector) {
-    if (selector.length < 2) {
+    if (selector.length == 0) {
         return null;
     }
     const optimized = [];
@@ -2754,37 +2974,75 @@ function reduceSelector(selector) {
         }
         optimized.push(item);
     }
-    if (optimized.at(-1) == ' ') {
-        optimized.pop();
+    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.length == 0) {
-        return { match: false, optimized, selector, reducible };
+    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) => {
-            const slice = curr.slice(optimized.length);
+            let hasCompound = true;
+            if (hasCompound && curr.length > 0) {
+                hasCompound = !['&'].concat(combinators).includes(curr[0].charAt(0));
+            }
             // @ts-ignore
-            if (slice.length > 0 && slice[0] == ' ') {
-                slice.shift();
+            if (hasCompound && curr[0] == ' ') {
+                hasCompound = false;
+                curr.unshift('&');
             }
-            if (slice.length == 0) {
-                slice.push('&');
+            if (curr.length == 0) {
+                curr.push('&');
+                hasCompound = false;
             }
             if (reducible) {
-                const chr = slice[0].charAt(0);
+                const chr = curr[0].charAt(0);
                 // @ts-ignore
                 reducible = chr == '.' || chr == ':' || isIdentStart(chr.codePointAt(0));
             }
-            acc.push(slice);
+            acc.push(hasCompound ? ['&'].concat(curr) : curr);
             return acc;
         }, []),
-        reducible
+        reducible: selector.every((selector) => !['>', '+', '~', '&'].includes(selector[0]))
     };
 }
-function reducer(acc, curr) {
+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);
+        }
+    }
     acc.push(curr.join(''));
     return acc;
 }
@@ -3092,7 +3350,7 @@ async function parse$1(iterator, opt = {}) {
             // https://www.w3.org/TR/css-nesting-1/#conditionals
             // allowed nesting at-rules
             // there must be a top level rule in the stack
-            const raw = tokens.reduce((acc, curr, index, array) => {
+            const raw = tokens.reduce((acc, curr) => {
                 acc.push(renderToken(curr, { removeComments: true }));
                 return acc;
             }, []);
@@ -3127,7 +3385,12 @@ async function parse$1(iterator, opt = {}) {
                     }
                 }
                 const uniq = new Map;
-                parseTokens(tokens, { compress: options.compress }).reduce((acc, curr) => {
+                parseTokens(tokens, 'Rule', { compress: options.compress }).reduce((acc, curr, index, array) => {
+                    if (curr.typ == 'Whitespace') {
+                        if (array[index - 1]?.val == '+' || array[index + 1]?.val == '+') {
+                            return acc;
+                        }
+                    }
                     let t = renderToken(curr, { compress: true });
                     if (t == ',') {
                         acc.push([]);
@@ -3171,7 +3434,7 @@ async function parse$1(iterator, opt = {}) {
                     }
                     if (tokens[i].typ == 'Colon') {
                         name = tokens.slice(0, i);
-                        value = parseTokens(tokens.slice(i + 1), {
+                        value = parseTokens(tokens.slice(i + 1), 'Declaration', {
                             parseColor: true,
                             src: options.src,
                             resolveUrls: options.resolveUrls,
@@ -3260,7 +3523,6 @@ async function parse$1(iterator, opt = {}) {
         position.ind = ind;
         position.lin = lin;
         position.col = col == 0 ? 1 : col;
-        // }
     }
     function consumeWhiteSpace() {
         let count = 0;
@@ -3492,6 +3754,9 @@ async function parse$1(iterator, opt = {}) {
                 break;
             case '~':
             case '|':
+                if (tokens.at(-1)?.typ == 'Whitespace') {
+                    tokens.pop();
+                }
                 if (buffer.length > 0) {
                     pushToken(getType(buffer));
                     buffer = '';
@@ -3513,19 +3778,32 @@ async function parse$1(iterator, opt = {}) {
                     break;
                 }
                 pushToken(getType(buffer));
+                while (isWhiteSpace(value.charCodeAt(0))) {
+                    value = next();
+                }
                 buffer = value;
                 break;
             case '>':
-                if (tokens[tokens.length - 1]?.typ == 'Whitespace') {
-                    tokens.pop();
-                }
                 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 '=':
@@ -3539,6 +3817,9 @@ async function parse$1(iterator, opt = {}) {
                 }
                 pushToken(getType(value));
                 buffer = '';
+                if (value == '+' && isWhiteSpace(peek().charCodeAt(0))) {
+                    pushToken(getType(next()));
+                }
                 while (isWhiteSpace(peek().charCodeAt(0))) {
                     next();
                 }
@@ -3716,13 +3997,14 @@ async function parse$1(iterator, opt = {}) {
     }
     return { ast, errors, bytesIn };
 }
-function parseTokens(tokens, options = {}) {
+function parseTokens(tokens, nodeType, options = {}) {
     for (let i = 0; i < tokens.length; i++) {
         const t = tokens[i];
         if (t.typ == 'Whitespace' && ((i == 0 ||
             i + 1 == tokens.length ||
             ['Comma'].includes(tokens[i + 1].typ) ||
             (i > 0 &&
+                tokens[i + 1]?.typ != 'Literal' &&
                 funcLike.includes(tokens[i - 1].typ) &&
                 !['var', 'calc'].includes(tokens[i - 1].val))))) {
             tokens.splice(i--, 1);
@@ -3769,7 +4051,7 @@ function parseTokens(tokens, options = {}) {
                 if (t.chi.length > 1) {
                     /*(<AttrToken>t).chi =*/
                     // @ts-ignore
-                    parseTokens(t.chi, options);
+                    parseTokens(t.chi, t.typ, options);
                 }
                 // @ts-ignore
                 t.chi.forEach(val => {
@@ -3881,7 +4163,7 @@ function parseTokens(tokens, options = {}) {
             // @ts-ignore
             if (t.chi.length > 0) {
                 // @ts-ignore
-                parseTokens(t.chi, options);
+                parseTokens(t.chi, t.typ, options);
                 if (t.typ == 'Pseudo-class-func' && t.val == ':is' && options.compress) {
                     //
                     const count = t.chi.filter(t => t.typ != 'Comment').length;
@@ -3947,7 +4229,7 @@ function* doWalk(node, parent, root) {
     yield { node, parent, root };
     if ('chi' in node) {
         for (const child of node.chi) {
-            yield* doWalk(child, node, (root == null ? node : root));
+            yield* doWalk(child, node, (root ?? node));
         }
     }
 }