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

package/dist/lib/{parser/deduplicate.js → ast/minify.js}

@@ -1,59 +1,303 @@
-import { isIdentStart, isWhiteSpace } from './utils/syntax.js';
-import { getConfig } from './utils/config.js';
-import { PropertyList } from './declaration/list.js';
-import { eq } from './utils/eq.js';
+import { isIdentStart, isIdent, isFunction, isWhiteSpace } from '../parser/utils/syntax.js';
+import { PropertyList } from '../parser/declaration/list.js';
+import { eq } from '../parser/utils/eq.js';
 import { render } from '../renderer/render.js';
+import '../renderer/utils/color.js';
 
-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;
+    }
+    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;
     }
-    else {
+    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
-        wrapper.chi.push(previous, node);
+        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
+        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 ? 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
+        };
     }
-    // @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;
@@ -93,7 +337,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);
@@ -132,7 +377,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
@@ -181,13 +426,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
@@ -218,10 +474,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;
@@ -263,10 +519,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);
                     }
                 }
             }
@@ -277,18 +533,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--) {
@@ -311,7 +646,7 @@ function hasDeclaration(node) {
     }
     return true;
 }
-function deduplicateRule(ast) {
+function minifyRule(ast) {
     // @ts-ignore
     if (!('chi' in ast) || ast.chi?.length <= 1) {
         return ast;
@@ -319,45 +654,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) {
@@ -483,335 +792,5 @@ 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;
-    // @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;
-        }
-        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
-    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 ? 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;
-}
 
-export { deduplicate, deduplicateRule, hasDeclaration, reduceSelector };
+export { combinators, hasDeclaration, minify, minifyRule, reduceSelector };