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

package/dist/index.cjs

@@ -53,7 +53,7 @@ function isIdent(name) {
     // -
     if (codepoint == 0x2d) {
         const nextCodepoint = name.charCodeAt(1);
-        if (nextCodepoint == null) {
+        if (Number.isNaN(nextCodepoint)) {
             return false;
         }
         // -
@@ -102,6 +102,9 @@ function isNumber(name) {
     let codepoint = name.charCodeAt(0);
     let i = 0;
     const j = name.length;
+    if (j == 1 && !isDigit(codepoint)) {
+        return false;
+    }
     // '+' '-'
     if ([0x2b, 0x2d].includes(codepoint)) {
         i++;
@@ -245,7 +248,9 @@ function isNewLine(codepoint) {
     return codepoint == 0xa || codepoint == 0xc || codepoint == 0xd;
 }
 function isWhiteSpace(codepoint) {
-    return codepoint == 0x9 || codepoint == 0x20 || isNewLine(codepoint);
+    return codepoint == 0x9 || codepoint == 0x20 ||
+        // isNewLine
+        codepoint == 0xa || codepoint == 0xc || codepoint == 0xd;
 }
 
 var properties = {
@@ -1450,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: '',
@@ -1468,24 +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' &&
-                        original[index - 1].kin != 'hex' &&
-                        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));
     }
@@ -1499,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;
                 }
@@ -1526,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;
@@ -1534,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);
@@ -1587,11 +1578,15 @@ function renderToken(token, options = {}) {
             if (token.kin == 'hex' || token.kin == 'lit') {
                 return token.val;
             }
+        case 'Start-parens':
+            if (!('chi' in token)) {
+                return '(';
+            }
         case 'Func':
         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.compress && '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;
@@ -1607,8 +1602,6 @@ function renderToken(token, options = {}) {
             return '<';
         case 'Gt':
             return '>';
-        case 'Start-parens':
-            return '(';
         case 'End-parens':
             return ')';
         case 'Attr-start':
@@ -1684,7 +1677,7 @@ 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.compress && '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)}`);
 }
@@ -2245,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) {
@@ -2260,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;
             }
@@ -2270,6 +2319,111 @@ function deduplicate(ast, options = {}, recursive = false) {
                 continue;
             }
             // @ts-ignore
+            if (node.typ == 'Rule') {
+                reduceRuleSelector(node);
+                let wrapper;
+                let match;
+                // @ts-ignore
+                if (options.nestingRules) {
+                    // @ts-ignore
+                    if (previous != null && previous.typ == 'Rule') {
+                        reduceRuleSelector(previous);
+                        // @ts-ignore
+                        match = matchSelectors(previous.raw, node.raw, ast.typ);
+                        // @ts-ignore
+                        if (match != null) {
+                            // @ts-ignore
+                            wrapper = wrapNodes(previous, node, match, ast, i, nodeIndex);
+                            nodeIndex = i - 1;
+                            // @ts-ignore
+                            previous = ast.chi[nodeIndex];
+                        }
+                    }
+                    // @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') {
+                                // i--;
+                                // previous = wrapper;
+                                // nodeIndex = i;
+                                break;
+                            }
+                            reduceRuleSelector(nextNode);
+                            // @ts-ignore
+                            match = matchSelectors(wrapper.raw, nextNode.raw, ast.typ);
+                            // @ts-ignore
+                            if (match == null) {
+                                break;
+                            }
+                            // @ts-ignore
+                            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
+                            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 {
+                                    curr.splice(0, 1);
+                                }
+                            }
+                        }
+                        else if (combinators.includes(curr[0])) {
+                            curr.unshift('&');
+                        }
+                        // @ts-ignore
+                        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
             if (previous != null && 'chi' in previous && ('chi' in node)) {
                 // @ts-ignore
                 if (previous.typ == node.typ) {
@@ -2289,13 +2443,14 @@ function deduplicate(ast, options = {}, recursive = false) {
                         // @ts-ignore
                         if ((node.typ == 'Rule' && node.sel == previous.sel) ||
                             // @ts-ignore
-                            (node.typ == 'AtRule') && node.val == previous.val) {
+                            (node.typ == 'AtRule') && node.val != 'font-face' && node.val == previous.val) {
                             // @ts-ignore
                             node.chi.unshift(...previous.chi);
                             // @ts-ignore
                             ast.chi.splice(nodeIndex, 1);
                             // @ts-ignore
                             if (hasDeclaration(node)) {
+                                // @ts-ignore
                                 deduplicateRule(node);
                             }
                             else {
@@ -2311,19 +2466,26 @@ function deduplicate(ast, options = {}, recursive = false) {
                             if (intersect != null) {
                                 if (intersect.node1.chi.length == 0) {
                                     // @ts-ignore
-                                    ast.chi.splice(i, 1);
+                                    ast.chi.splice(i--, 1);
+                                    // @ts-ignore
+                                    node = ast.chi[i];
                                 }
                                 else {
                                     // @ts-ignore
                                     ast.chi.splice(i, 1, intersect.node1);
+                                    node = intersect.node1;
                                 }
                                 if (intersect.node2.chi.length == 0) {
                                     // @ts-ignore
                                     ast.chi.splice(nodeIndex, 1, intersect.result);
+                                    previous = intersect.result;
                                 }
                                 else {
                                     // @ts-ignore
                                     ast.chi.splice(nodeIndex, 1, intersect.result, intersect.node2);
+                                    previous = intersect.result;
+                                    // @ts-ignore
+                                    i = nodeIndex;
                                 }
                             }
                         }
@@ -2333,6 +2495,7 @@ function deduplicate(ast, options = {}, recursive = false) {
                 if (recursive && previous != node) {
                     // @ts-ignore
                     if (hasDeclaration(previous)) {
+                        // @ts-ignore
                         deduplicateRule(previous);
                     }
                     else {
@@ -2350,12 +2513,25 @@ function deduplicate(ast, options = {}, recursive = false) {
                 deduplicateRule(node);
             }
             else {
-                deduplicate(node, options, recursive);
+                // @ts-ignore
+                if (!(node.typ == 'AtRule' && node.nam != 'font-face')) {
+                    deduplicate(node, options, recursive);
+                }
             }
         }
     }
     return ast;
 }
+function hasOnlyDeclarations(node) {
+    let k = node.chi.length;
+    while (k--) {
+        if (node.chi[k].typ == 'Comment') {
+            continue;
+        }
+        return node.chi[k].typ == 'Declaration';
+    }
+    return true;
+}
 function hasDeclaration(node) {
     // @ts-ignore
     for (let i = 0; i < node.chi?.length; i++) {
@@ -2368,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;
@@ -2415,42 +2591,42 @@ function deduplicateRule(ast, options = {}) {
     }
     // @ts-ignore
     ast.chi = children.concat(ast.chi?.slice(k));
-    /*
-    // @ts-ignore
-
-    const properties: PropertyList = new PropertyList();
-
-    for (; k < j; k++) {
-
-        // @ts-ignore
-        if ('Comment' == ast.chi[k].typ || 'Declaration' == ast.chi[k].typ) {
-
-            // @ts-ignore
-            properties.add(ast.chi[k]);
-            continue;
-        }
-
-        break;
-    }
-
-    // @ts-ignore
-    ast.chi = [...properties].concat(ast.chi.slice(k));
-    */
-    //
-    // @ts-ignore
-    // ast.chi.splice(0, k - 1, ...properties);
     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;
@@ -2497,14 +2673,49 @@ function splitRule(buffer) {
                 }
             }
             i = k;
-            continue;
         }
     }
     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.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;
     let node2 = n2;
@@ -2521,8 +2732,28 @@ function diff(n1, n2, options = {}) {
         // @ts-ignore
         return null;
     }
+    // @ts-ignore
+    const raw1 = node1.raw;
+    // @ts-ignore
+    // const optimized1 = node1.optimized;
+    // @ts-ignore
+    const raw2 = node2.raw;
+    // @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') {
@@ -2550,7 +2781,7 @@ function diff(n1, n2, options = {}) {
     const result = (intersect.length == 0 ? null : {
         ...node1,
         // @ts-ignore
-        sel: [...new Set([...(n1.raw || splitRule(n1.sel)).concat(n2.raw || 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)) {
@@ -2559,6 +2790,262 @@ 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 == 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 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;
+}
 
 const urlTokenMatcher = /^(["']?)[a-zA-Z0-9_/.-][a-zA-Z0-9_/:.#?-]+(\1)$/;
 const funcLike = ['Start-parens', 'Func', 'UrlFunc', 'Pseudo-class-func'];
@@ -2568,6 +3055,7 @@ async function parse$1(iterator, opt = {}) {
         src: '',
         sourcemap: false,
         compress: false,
+        nestingRules: false,
         resolveImport: false,
         resolveUrls: false,
         removeEmpty: true,
@@ -2838,11 +3326,16 @@ async function parse$1(iterator, opt = {}) {
                         try {
                             // @ts-ignore
                             const root = await options.load(url, options.src).then((src) => {
-                                bytesIn += src.length;
-                                // @ts-ignore
-                                return parse$1(src, Object.assign({}, options, { src: options.resolve(url, options.src).absolute }));
+                                return parse$1(src, Object.assign({}, options, {
+                                    compress: false,
+                                    // @ts-ignore
+                                    src: options.resolve(url, options.src).absolute
+                                }));
                             });
-                            context.chi.push(...root.ast.chi);
+                            bytesIn += root.bytesIn;
+                            if (root.ast.chi.length > 0) {
+                                context.chi.push(...root.ast.chi);
+                            }
                             if (root.errors.length > 0) {
                                 errors.push(...root.errors);
                             }
@@ -2857,20 +3350,16 @@ 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) => {
+                acc.push(renderToken(curr, { removeComments: true }));
+                return acc;
+            }, []);
             const node = {
                 typ: 'AtRule',
                 nam: renderToken(atRule, { removeComments: true }),
-                val: tokens.reduce((acc, curr, index, array) => {
-                    if (curr.typ == 'Whitespace') {
-                        if (array[index + 1]?.typ == 'Start-parens' ||
-                            array[index - 1]?.typ == 'End-parens' ||
-                            array[index - 1]?.typ == 'Func') {
-                            return acc;
-                        }
-                    }
-                    return acc + renderToken(curr, { removeComments: true });
-                }, '')
+                val: raw.join('')
             };
+            Object.defineProperty(node, 'raw', { enumerable: false, writable: false, value: raw });
             if (delim.typ == 'Block-start') {
                 node.chi = [];
             }
@@ -2895,23 +3384,33 @@ async function parse$1(iterator, opt = {}) {
                         return null;
                     }
                 }
-                const sel = parseTokens(tokens, { compress: options.compress }).map(curr => renderToken(curr, { compress: true }));
-                const raw = [...new Set(sel.reduce((acc, curr) => {
-                        if (curr == ',') {
-                            acc.push('');
-                        }
-                        else {
-                            acc[acc.length - 1] += curr;
+                const uniq = new Map;
+                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;
                         }
-                        return acc;
-                    }, ['']))];
+                    }
+                    let t = renderToken(curr, { compress: true });
+                    if (t == ',') {
+                        acc.push([]);
+                    }
+                    else {
+                        acc[acc.length - 1].push(t);
+                    }
+                    return acc;
+                }, [[]]).reduce((acc, curr) => {
+                    acc.set(curr.join(''), curr);
+                    return acc;
+                }, uniq);
                 const node = {
                     typ: 'Rule',
                     // @ts-ignore
-                    sel: raw.join(','),
+                    sel: [...uniq.keys()].join(','),
                     chi: []
                 };
-                Object.defineProperty(node, 'raw', { enumerable: false, get: () => raw });
+                let raw = [...uniq.values()];
+                Object.defineProperty(node, 'raw', { enumerable: false, writable: true, value: raw });
                 loc = {
                     sta: position,
                     src
@@ -2935,7 +3434,13 @@ async function parse$1(iterator, opt = {}) {
                     }
                     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 });
+                        value = parseTokens(tokens.slice(i + 1), 'Declaration', {
+                            parseColor: true,
+                            src: options.src,
+                            resolveUrls: options.resolveUrls,
+                            resolve: options.resolve,
+                            cwd: options.cwd
+                        });
                     }
                 }
                 if (name == null) {
@@ -2954,11 +3459,6 @@ async function parse$1(iterator, opt = {}) {
                         }
                     }
                 }
-                // if (name.length == 0) {
-                //
-                //     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;
@@ -2981,16 +3481,6 @@ async function parse$1(iterator, opt = {}) {
                     errors.push({ action: 'drop', message: 'invalid declaration', location: { src, ...position } });
                     return null;
                 }
-                // // location not needed for declaration
-                // loc = <Location>{
-                //     sta: position,
-                //     src
-                // };
-                //
-                // if (options.sourcemap) {
-                //
-                //     node.loc = loc
-                // }
                 // @ts-ignore
                 context.chi.push(node);
                 return null;
@@ -3033,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;
@@ -3215,11 +3704,6 @@ async function parse$1(iterator, opt = {}) {
                         }
                     }
                 }
-                // else {
-                //
-                //     pushToken(getType(buffer));
-                //     buffer = '';
-                // }
                 break;
             case '<':
                 if (buffer.length > 0) {
@@ -3270,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 = '';
@@ -3291,15 +3778,32 @@ async function parse$1(iterator, opt = {}) {
                     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 '=':
@@ -3311,12 +3815,11 @@ async function parse$1(iterator, opt = {}) {
                     buffer += value + next();
                     break;
                 }
-                // if (value == ',' && tokens[tokens.length - 1]?.typ == 'Whitespace') {
-                //
-                //     tokens.pop();
-                // }
                 pushToken(getType(value));
                 buffer = '';
+                if (value == '+' && isWhiteSpace(peek().charCodeAt(0))) {
+                    pushToken(getType(next()));
+                }
                 while (isWhiteSpace(peek().charCodeAt(0))) {
                     next();
                 }
@@ -3337,7 +3840,7 @@ async function parse$1(iterator, opt = {}) {
                     pushToken(getType(buffer));
                     buffer = '';
                     const token = tokens[tokens.length - 1];
-                    if (token.typ == 'UrlFunc' /* && token.chi == 'url' */) {
+                    if (token.typ == 'UrlFunc') {
                         // consume either string or url token
                         let whitespace = '';
                         value = peek();
@@ -3454,15 +3957,6 @@ async function parse$1(iterator, opt = {}) {
                     if (options.removeEmpty && previousNode != null && previousNode.chi.length == 0 && context.chi[context.chi.length - 1] == previousNode) {
                         context.chi.pop();
                     }
-                    else if (previousNode != null && previousNode != ast && options.compress) {
-                        // @ts-ignore
-                        if (hasDeclaration(previousNode)) {
-                            deduplicateRule(previousNode);
-                        }
-                        else {
-                            deduplicate(previousNode, options);
-                        }
-                    }
                     tokens.length = 0;
                     map.clear();
                     buffer = '';
@@ -3497,28 +3991,22 @@ async function parse$1(iterator, opt = {}) {
         await parseNode(tokens);
     }
     if (options.compress) {
-        while (stack.length > 0) {
-            const node = stack.pop();
-            if (hasDeclaration(node)) {
-                deduplicateRule(node, options);
-            }
-            else {
-                deduplicate(node, options);
-            }
-        }
         if (ast.chi.length > 0) {
-            deduplicate(ast, options);
+            deduplicate(ast, options, true);
         }
     }
     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', 'Start-parens'].includes(tokens[i + 1].typ) ||
-            (i > 0 && funcLike.includes(tokens[i - 1].typ))))) {
+            ['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);
             continue;
         }
@@ -3563,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 => {
@@ -3616,9 +4104,9 @@ function parseTokens(tokens, options = {}) {
                 // @ts-ignore
                 t.chi.pop();
             }
+            let isColor = true;
             // @ts-ignore
             if (options.parseColor && ['rgb', 'rgba', 'hsl', 'hsla', 'hwb', 'device-cmyk'].includes(t.val)) {
-                let isColor = true;
                 // @ts-ignore
                 for (const v of t.chi) {
                     if (v.typ == 'Func' && v.val == 'var') {
@@ -3626,37 +4114,38 @@ function parseTokens(tokens, options = {}) {
                         break;
                     }
                 }
-                if (!isColor) {
-                    continue;
-                }
-                // @ts-ignore
-                t.typ = 'Color';
-                // @ts-ignore
-                t.kin = t.val;
-                // @ts-ignore
-                let m = t.chi.length;
-                while (m-- > 0) {
+                if (isColor) {
+                    // @ts-ignore
+                    t.typ = 'Color';
                     // @ts-ignore
-                    if (t.chi[m].typ == 'Literal') {
+                    t.kin = t.val;
+                    // @ts-ignore
+                    let m = t.chi.length;
+                    while (m-- > 0) {
                         // @ts-ignore
-                        if (t.chi[m + 1]?.typ == 'Whitespace') {
+                        if (t.chi[m].typ == 'Literal') {
                             // @ts-ignore
-                            t.chi.splice(m + 1, 1);
-                        }
-                        // @ts-ignore
-                        if (t.chi[m - 1]?.typ == 'Whitespace') {
+                            if (t.chi[m + 1]?.typ == 'Whitespace') {
+                                // @ts-ignore
+                                t.chi.splice(m + 1, 1);
+                            }
                             // @ts-ignore
-                            t.chi.splice(m - 1, 1);
-                            m--;
+                            if (t.chi[m - 1]?.typ == 'Whitespace') {
+                                // @ts-ignore
+                                t.chi.splice(m - 1, 1);
+                                m--;
+                            }
                         }
                     }
+                    continue;
                 }
             }
-            else if (t.typ == 'UrlFunc') {
+            if (t.typ == 'UrlFunc') {
                 // @ts-ignore
                 if (t.chi[0]?.typ == 'String') {
                     // @ts-ignore
                     const value = t.chi[0].val.slice(1, -1);
+                    // @ts-ignore
                     if (t.chi[0].val.slice(1, 5) != 'data:' && urlTokenMatcher.test(value)) {
                         // @ts-ignore
                         t.chi[0].typ = 'Url-token';
@@ -3674,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;
@@ -3740,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));
         }
     }
 }
@@ -3874,12 +4363,10 @@ async function load(url, currentFile) {
 }
 
 function parse(iterator, opt = {}) {
-    Object.assign(opt, { load, resolve, cwd: opt.cwd ?? process.cwd() });
-    return parse$1(iterator, opt);
+    return parse$1(iterator, Object.assign(opt, { load, resolve, cwd: opt.cwd ?? process.cwd() }));
 }
 function transform(css, options = {}) {
-    Object.assign(options, { load, resolve, cwd: options.cwd ?? process.cwd() });
-    return transform$1(css, options);
+    return transform$1(css, Object.assign(options, { load, resolve, cwd: options.cwd ?? process.cwd() }));
 }
 
 exports.deduplicate = deduplicate;
@@ -3889,6 +4376,7 @@ exports.hasDeclaration = hasDeclaration;
 exports.load = load;
 exports.matchUrl = matchUrl;
 exports.parse = parse;
+exports.reduceSelector = reduceSelector;
 exports.render = render;
 exports.renderToken = renderToken;
 exports.resolve = resolve;