@tbela99/css-parser 0.0.1-rc5 → 0.0.1-rc7

package/dist/index.d.ts

@@ -477,9 +477,9 @@ interface BorderRadius {
 interface ErrorDescription {
 
     // drop rule or declaration | fix rule or declaration
-    action: 'drop';
+    action: 'drop' | 'ignore';
     message: string;
-    location: {
+    location?: {
         src: string,
         lin: number,
         col: number;
@@ -505,6 +505,7 @@ interface ParserOptions {
 interface RenderOptions {
 
     minify?: boolean;
+    expandNestingRules?: boolean;
     preserveLicense?: boolean;
     indent?: string;
     newLine?: string;
@@ -529,6 +530,7 @@ interface ParseResult {
 
 interface RenderResult {
     code: string ;
+    errors: ErrorDescription[];
     stats: {
         total: string;
     }
@@ -577,7 +579,7 @@ interface Node {
 
 interface AstComment extends Node {
 
-    typ: 'Comment',
+    typ: 'Comment' | 'CDOCOMM',
     val: string;
 }
 interface AstDeclaration extends Node {
@@ -630,6 +632,35 @@ type AstNode =
     | AstRule
     | AstDeclaration;
 
+declare const combinators: string[];
+declare function minify(ast: AstNode, options?: ParserOptions, recursive?: boolean, errors?: ErrorDescription[], nestingContent?: boolean): AstNode;
+declare function reduceSelector(selector: string[][]): {
+    match: boolean;
+    optimized: string[];
+    selector: string[][];
+    reducible: boolean;
+} | null;
+declare function hasDeclaration(node: AstRule): boolean;
+declare function minifyRule(ast: AstRule | AstAtRule): AstRule | AstAtRule;
+declare function splitRule(buffer: string): string[][];
+
+declare function walk(node: AstNode, parent?: AstRuleList, root?: AstRuleList): Generator<{
+    node: AstNode;
+    parent?: AstRuleList;
+    root?: AstRuleList;
+}>;
+declare function walkValues(values: Token[], parent?: Token): Generator<{
+    value: Token;
+    parent: Token | null;
+}>;
+
+declare function expand(ast: AstNode): AstNode;
+declare function replaceCompound(input: string, replace: string): string;
+
+declare const colorsFunc: string[];
+declare function render(data: AstNode, opt?: RenderOptions): RenderResult;
+declare function renderToken(token: Token, options?: RenderOptions, reducer?: (acc: string, curr: Token) => string, errors?: ErrorDescription[]): string;
+
 declare const urlTokenMatcher: RegExp;
 declare function parseString(src: string, options?: {
     location: boolean;
@@ -647,6 +678,7 @@ declare function isIdentStart(codepoint: number): boolean;
 declare function isDigit(codepoint: number): boolean;
 declare function isIdentCodepoint(codepoint: number): boolean;
 declare function isIdent(name: string): boolean;
+declare function isNonPrintable(codepoint: number): boolean;
 declare function isPseudo(name: string): boolean;
 declare function isHash(name: string): boolean;
 declare function isNumber(name: string): boolean;
@@ -654,7 +686,6 @@ declare function isDimension(name: string): boolean;
 declare function isPercentage(name: string): boolean;
 declare function parseDimension(name: string): DimensionToken | LengthToken | AngleToken;
 declare function isHexColor(name: string): boolean;
-declare function isHexDigit(name: string): boolean;
 declare function isFunction(name: string): boolean;
 declare function isAtKeyword(name: string): boolean;
 declare function isNewLine(codepoint: number): boolean;
@@ -665,27 +696,6 @@ declare const getConfig: () => PropertiesConfig;
 declare const funcList: string[];
 declare function matchType(val: Token, properties: PropertyMapType): boolean;
 
-declare const colorsFunc: string[];
-declare function render(data: AstNode, opt?: RenderOptions): RenderResult;
-declare function renderToken(token: Token, options?: RenderOptions, reducer?: (acc: string, curr: Token) => string): string;
-
-declare const combinators: string[];
-declare function minify(ast: AstNode, options?: ParserOptions, recursive?: boolean): AstNode;
-declare function reduceSelector(selector: string[][]): {
-    match: boolean;
-    optimized: string[];
-    selector: string[][];
-    reducible: boolean;
-} | null;
-declare function hasDeclaration(node: AstRule): boolean;
-declare function minifyRule(ast: AstRule | AstAtRule): AstRule | AstAtRule;
-
-declare function walk(node: AstNode): Generator<{
-    node: AstNode;
-    parent?: AstRuleList;
-    root?: AstRuleList;
-}>;
-
 declare function load(url: string, currentFile: string): Promise<string>;
 
 declare const matchUrl: RegExp;
@@ -698,4 +708,4 @@ declare function resolve(url: string, currentDirectory: string, cwd?: string): {
 declare function parse(iterator: string, opt?: ParserOptions): Promise<ParseResult>;
 declare function transform(css: string, options?: TransformOptions): Promise<TransformResult>;
 
-export { colorsFunc, combinators, dirname, funcList, getConfig, hasDeclaration, isAngle, isAtKeyword, isColor, isDigit, isDimension, isFrequency, isFunction, isHash, isHexColor, isHexDigit, isIdent, isIdentCodepoint, isIdentStart, isLength, isNewLine, isNumber, isPercentage, isPseudo, isResolution, isTime, isWhiteSpace, load, matchType, matchUrl, minify, minifyRule, parse, parseDimension, parseString, reduceSelector, render, renderToken, resolve, tokenize, transform, urlTokenMatcher, walk };
+export { colorsFunc, combinators, dirname, expand, funcList, getConfig, hasDeclaration, isAngle, isAtKeyword, isColor, isDigit, isDimension, isFrequency, isFunction, isHash, isHexColor, isIdent, isIdentCodepoint, isIdentStart, isLength, isNewLine, isNonPrintable, isNumber, isPercentage, isPseudo, isResolution, isTime, isWhiteSpace, load, matchType, matchUrl, minify, minifyRule, parse, parseDimension, parseString, reduceSelector, render, renderToken, replaceCompound, resolve, splitRule, tokenize, transform, urlTokenMatcher, walk, walkValues };

package/dist/lib/ast/expand.js

@@ -0,0 +1,159 @@
+import { splitRule, combinators } from './minify.js';
+import { parseString } from '../parser/parse.js';
+import { renderToken } from '../renderer/render.js';
+import '../renderer/utils/color.js';
+import { walkValues } from './walk.js';
+
+function expand(ast) {
+    //
+    if (!['Rule', 'StyleSheet', 'AtRule'].includes(ast.typ)) {
+        return ast;
+    }
+    if ('Rule' == ast.typ) {
+        return {
+            typ: 'StyleSheet',
+            chi: expandRule(ast)
+        };
+    }
+    if (!('chi' in ast)) {
+        return { ...ast };
+    }
+    const result = { ...ast, chi: [] };
+    // @ts-ignore
+    for (let i = 0; i < ast.chi.length; i++) {
+        // @ts-ignore
+        const node = ast.chi[i];
+        if (node.typ == 'Rule') {
+            // @ts-ignore
+            result.chi.push(...expandRule(node));
+            // i += expanded.length - 1;
+        }
+        else if (node.typ == 'AtRule' && 'chi' in node) {
+            let hasRule = false;
+            let j = node.chi.length;
+            while (j--) {
+                if (node.chi[j].typ == 'Rule' || node.chi[j].typ == 'AtRule') {
+                    hasRule = true;
+                    break;
+                }
+            }
+            // @ts-ignore
+            result.chi.push({ ...(hasRule ? expand(node) : node) });
+        }
+        else {
+            // @ts-ignore
+            result.chi.push(node);
+        }
+    }
+    return result;
+}
+function expandRule(node) {
+    const ast = { ...node, chi: node.chi.slice() };
+    const result = [];
+    if (ast.typ == 'Rule') {
+        let i = 0;
+        // @ts-ignore
+        delete ast.raw;
+        // @ts-ignore
+        delete ast.optimized;
+        for (; i < ast.chi.length; i++) {
+            if (ast.chi[i].typ == 'Rule') {
+                const rule = ast.chi[i];
+                if (!rule.sel.includes('&')) {
+                    const selRule = splitRule(rule.sel);
+                    selRule.forEach(arr => combinators.includes(arr[0].charAt(0)) ? arr.unshift(ast.sel) : arr.unshift(ast.sel, ' '));
+                    rule.sel = selRule.reduce((acc, curr) => {
+                        acc.push(curr.join(''));
+                        return acc;
+                    }, []).join(',');
+                }
+                else {
+                    rule.sel = replaceCompound(rule.sel, ast.sel);
+                }
+                delete rule.raw;
+                delete rule.optimized;
+                ast.chi.splice(i--, 1);
+                result.push(...expandRule(rule));
+            }
+            else if (ast.chi[i].typ == 'AtRule') {
+                let astAtRule = ast.chi[i];
+                const values = [];
+                if (astAtRule.nam == 'scope') {
+                    if (astAtRule.val.includes('&')) {
+                        astAtRule.val = replaceCompound(astAtRule.val, ast.sel);
+                    }
+                    // @ts-ignore
+                    astAtRule = expand(astAtRule);
+                }
+                else {
+                    // @ts-ignore
+                    const clone = { ...ast, chi: astAtRule.chi.slice() };
+                    // @ts-ignore
+                    astAtRule.chi.length = 0;
+                    for (const r of expandRule(clone)) {
+                        if (r.typ == 'AtRule' && 'chi' in r) {
+                            if (astAtRule.val !== '' && r.val !== '') {
+                                if (astAtRule.nam == 'media' && r.nam == 'media') {
+                                    r.val = astAtRule.val + ' and ' + r.val;
+                                }
+                                else if (astAtRule.nam == 'layer' && r.nam == 'layer') {
+                                    r.val = astAtRule.val + '.' + r.val;
+                                }
+                            }
+                            // @ts-ignore
+                            values.push(r);
+                        }
+                        else if (r.typ == 'Rule') {
+                            // @ts-ignore
+                            astAtRule.chi.push(...expandRule(r));
+                        }
+                        else {
+                            // @ts-ignore
+                            astAtRule.chi.push(r);
+                        }
+                    }
+                }
+                // @ts-ignore
+                result.push(...(astAtRule.chi.length > 0 ? [astAtRule].concat(values) : values));
+                ast.chi.splice(i--, 1);
+            }
+        }
+    }
+    // @ts-ignore
+    return ast.chi.length > 0 ? [ast].concat(result) : result;
+}
+function replaceCompound(input, replace) {
+    const tokens = parseString(input);
+    for (const t of walkValues(tokens)) {
+        if (t.value.typ == 'Literal') {
+            if (t.value.val == '&') {
+                t.value.val = replace;
+            }
+            else if (t.value.val.length > 1 && t.value.val.charAt(0) == '&') {
+                t.value.val = replaceCompoundLiteral(t.value.val, replace);
+            }
+        }
+    }
+    return tokens.reduce((acc, curr) => acc + renderToken(curr), '');
+}
+function replaceCompoundLiteral(selector, replace) {
+    const tokens = [''];
+    let i = 0;
+    for (; i < selector.length; i++) {
+        if (selector.charAt(i) == '&') {
+            tokens.push('&');
+            tokens.push('');
+        }
+        else {
+            tokens[tokens.length - 1] += selector.charAt(i);
+        }
+    }
+    return tokens.sort((a, b) => {
+        if (a == '&') {
+            return 1;
+        }
+        return b == '&' ? -1 : 0;
+    }).reduce((acc, curr) => acc + (curr == '&' ? replace : curr), '');
+}
+
+export { expand, replaceCompound };

package/dist/lib/ast/minify.js

@@ -1,12 +1,15 @@
-import { isIdentStart, isIdent, isFunction, isWhiteSpace } from '../parser/utils/syntax.js';
+import { isIdentStart, isWhiteSpace, isIdent, isFunction } 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';
+import { render, renderToken } from '../renderer/render.js';
+import { parseString } from '../parser/parse.js';
+import { replaceCompound } from './expand.js';
+import { walkValues } from './walk.js';
 
 const combinators = ['+', '>', '~'];
 const notEndingWith = ['(', '['].concat(combinators);
-function minify(ast, options = {}, recursive = false) {
+const definedPropertySettings = { configurable: true, enumerable: false, writable: true };
+function minify(ast, options = {}, recursive = false, errors, nestingContent) {
     function wrapNodes(previous, node, match, ast, i, nodeIndex) {
         // @ts-ignore
         let pSel = match.selector1.reduce(reducer, []).join(',');
@@ -15,9 +18,7 @@ function minify(ast, options = {}, recursive = false) {
         // @ts-ignore
         const wrapper = { ...previous, chi: [], sel: match.match.reduce(reducer, []).join(',') };
         // @ts-ignore
-        Object.defineProperty(wrapper, 'raw', {
-            enumerable: false,
-            writable: true,
+        Object.defineProperty(wrapper, 'raw', { ...definedPropertySettings,
             // @ts-ignore
             value: match.match.map(t => t.slice())
         });
@@ -25,7 +26,7 @@ function minify(ast, options = {}, recursive = false) {
             // @ts-ignore
             wrapper.chi.push(...previous.chi);
             // @ts-ignore
-            if ((nSel == '&' || nSel === '') && hasOnlyDeclarations(previous)) {
+            if ((nSel == '&' || nSel === '')) {
                 // @ts-ignore
                 wrapper.chi.push(...node.chi);
             }
@@ -96,10 +97,10 @@ function minify(ast, options = {}, recursive = false) {
         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 });
+            Object.defineProperty(node1, 'raw', { ...definedPropertySettings, value: raw1 });
         }
         if (raw2 != null) {
-            Object.defineProperty(node2, 'raw', { enumerable: false, writable: true, value: raw2 });
+            Object.defineProperty(node2, 'raw', { ...definedPropertySettings, value: raw2 });
         }
         const intersect = [];
         while (i--) {
@@ -199,8 +200,7 @@ function minify(ast, options = {}, recursive = false) {
             }
         }
         if (match.length > 1) {
-            console.error(`unsupported multilevel matching`);
-            console.error({ match, selector1, selector2 });
+            errors?.push({ action: 'ignore', message: `minify: unsupported multilevel matching\n${JSON.stringify({ match, selector1, selector2 }, null, 1)}` });
             return null;
         }
         for (const part of match) {
@@ -298,8 +298,28 @@ function minify(ast, options = {}, recursive = false) {
             selector2
         };
     }
+    function fixSelector(node) {
+        // @ts-ignore
+        if (node.sel.includes('&')) {
+            const attributes = parseString(node.sel);
+            for (const attr of walkValues(attributes)) {
+                if (attr.value.typ == 'Pseudo-class-func' && attr.value.val == ':is') {
+                    let i = attr.value.chi.length;
+                    while (i--) {
+                        if (attr.value.chi[i].typ == 'Literal' && attr.value.chi[i].val == '&') {
+                            attr.value.chi.splice(i, 1);
+                        }
+                    }
+                }
+            }
+            node.sel = attributes.reduce((acc, curr) => acc + renderToken(curr), '');
+        }
+    }
     // @ts-ignore
     if (('chi' in ast) && ast.chi?.length > 0) {
+        if (!nestingContent) {
+            nestingContent = options.nestingRules && ast.typ == 'Rule';
+        }
         let i = 0;
         let previous;
         let node;
@@ -314,7 +334,6 @@ function minify(ast, options = {}, recursive = false) {
             node = ast.chi[i];
             // @ts-ignore
             if (previous == node) {
-                // console.error('idem!');
                 // @ts-ignore
                 ast.chi.splice(i, 1);
                 i--;
@@ -330,7 +349,6 @@ function minify(ast, options = {}, recursive = false) {
                     i--;
                     continue;
                 }
-                // console.debug({previous, node});
                 // @ts-ignore
                 if (previous?.typ == 'AtRule' &&
                     previous.nam == node.nam &&
@@ -350,7 +368,7 @@ function minify(ast, options = {}, recursive = false) {
                     minifyRule(node);
                 }
                 else {
-                    minify(node, options, recursive);
+                    minify(node, options, recursive, errors, nestingContent);
                 }
                 previous = node;
                 nodeIndex = i;
@@ -404,7 +422,7 @@ function minify(ast, options = {}, recursive = false) {
                         nodeIndex = --i;
                         // @ts-ignore
                         previous = ast.chi[nodeIndex];
-                        minify(wrapper, options, recursive);
+                        minify(wrapper, options, recursive, errors, nestingContent);
                         continue;
                     }
                     // @ts-ignore
@@ -417,8 +435,7 @@ function minify(ast, options = {}, recursive = false) {
                         wrapper = { ...node, chi: [], sel: node.optimized.optimized[0] };
                         // @ts-ignore
                         Object.defineProperty(wrapper, 'raw', {
-                            enumerable: false,
-                            writable: true,
+                            ...definedPropertySettings,
                             // @ts-ignore
                             value: [[node.optimized.optimized[0]]]
                         });
@@ -438,7 +455,7 @@ function minify(ast, options = {}, recursive = false) {
                     let wrap = true;
                     // @ts-ignore
                     const selector = node.optimized.selector.reduce((acc, curr) => {
-                        if (curr[0] == '&') {
+                        if (curr[0] == '&' && curr.length > 1) {
                             if (curr[1] == ' ') {
                                 curr.splice(0, 2);
                             }
@@ -462,7 +479,7 @@ function minify(ast, options = {}, recursive = false) {
                     if (!wrap) {
                         wrap = selector.some(s => s[0] != '&');
                     }
-                    const rule = selector.map(s => {
+                    let rule = selector.map(s => {
                         if (s[0] == '&') {
                             // @ts-ignore
                             s[0] = node.optimized.optimized[0];
@@ -470,89 +487,119 @@ function minify(ast, options = {}, recursive = false) {
                         return s.join('');
                     }).join(',');
                     // @ts-ignore
-                    node.sel = wrap ? node.optimized.optimized[0] + `:is(${rule})` : rule;
+                    let sel = wrap ? node.optimized.optimized[0] + `:is(${rule})` : rule;
+                    if (rule.includes('&')) {
+                        // @ts-ignore
+                        rule = replaceCompound(rule, node.optimized.optimized[0]);
+                    }
+                    if (sel.length < node.sel.length) {
+                        node.sel = sel;
+                    }
                 }
             }
             // @ts-ignore
-            if (previous != null && 'chi' in previous && ('chi' in node)) {
+            if (previous != null) {
                 // @ts-ignore
-                if (previous.typ == node.typ) {
-                    let shouldMerge = true;
+                if ('chi' in previous && ('chi' in node)) {
                     // @ts-ignore
-                    let k = previous.chi.length;
-                    while (k-- > 0) {
+                    if (previous.typ == node.typ) {
+                        let shouldMerge = true;
                         // @ts-ignore
-                        if (previous.chi[k].typ == 'Comment') {
-                            continue;
-                        }
-                        // @ts-ignore
-                        shouldMerge = previous.chi[k].typ == 'Declaration';
-                        break;
-                    }
-                    if (shouldMerge) {
-                        // @ts-ignore
-                        if ((node.typ == 'Rule' && node.sel == previous.sel) ||
+                        let k = previous.chi.length;
+                        while (k-- > 0) {
                             // @ts-ignore
-                            (node.typ == 'AtRule') && node.val != 'font-face' && node.val == previous.val) {
-                            // @ts-ignore
-                            node.chi.unshift(...previous.chi);
+                            if (previous.chi[k].typ == 'Comment') {
+                                continue;
+                            }
                             // @ts-ignore
-                            ast.chi.splice(nodeIndex, 1);
+                            shouldMerge = previous.chi[k].typ == 'Declaration';
+                            break;
+                        }
+                        if (shouldMerge) {
                             // @ts-ignore
-                            if (hasDeclaration(node)) {
+                            if ((node.typ == 'Rule' && node.sel == previous.sel) ||
                                 // @ts-ignore
-                                minifyRule(node);
-                            }
-                            else {
-                                minify(node, options, recursive);
-                            }
-                            i--;
-                            previous = node;
-                            nodeIndex = i;
-                            continue;
-                        }
-                        else if (node.typ == 'Rule' && previous?.typ == 'Rule') {
-                            const intersect = diff(previous, node, options);
-                            if (intersect != null) {
-                                if (intersect.node1.chi.length == 0) {
-                                    // @ts-ignore
-                                    ast.chi.splice(i--, 1);
+                                (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
-                                    node = ast.chi[i];
+                                    minifyRule(node);
                                 }
                                 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;
+                                    minify(node, options, recursive, errors, nestingContent);
                                 }
-                                else {
-                                    // @ts-ignore
-                                    ast.chi.splice(nodeIndex, 1, intersect.result, intersect.node2);
-                                    previous = intersect.result;
-                                    // @ts-ignore
-                                    i = nodeIndex;
+                                i--;
+                                previous = node;
+                                nodeIndex = i;
+                                continue;
+                            }
+                            else if (node.typ == 'Rule' && previous?.typ == 'Rule') {
+                                const intersect = diff(previous, node, options);
+                                if (intersect != null) {
+                                    if (intersect.node1.chi.length == 0) {
+                                        // @ts-ignore
+                                        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;
+                                    }
                                 }
                             }
                         }
                     }
-                }
-                // @ts-ignore
-                if (recursive && previous != node) {
                     // @ts-ignore
-                    if (hasDeclaration(previous)) {
+                    if (recursive && previous != node) {
                         // @ts-ignore
-                        minifyRule(previous);
+                        if (hasDeclaration(previous)) {
+                            // @ts-ignore
+                            minifyRule(previous);
+                        }
+                        else {
+                            minify(previous, options, recursive, errors, nestingContent);
+                        }
                     }
-                    else {
-                        minify(previous, options, recursive);
+                }
+                else {
+                    if ('chi' in previous) {
+                        // @ts-ignore
+                        if (hasDeclaration(previous)) {
+                            // @ts-ignore
+                            minifyRule(previous);
+                        }
+                        else {
+                            minify(previous, options, recursive, errors, nestingContent);
+                        }
                     }
                 }
             }
+            if (!nestingContent &&
+                // @ts-ignore
+                previous != null &&
+                // previous.optimized != null &&
+                previous.typ == 'Rule' &&
+                previous.sel.includes('&')) {
+                fixSelector(previous);
+            }
             previous = node;
             nodeIndex = i;
         }
@@ -565,10 +612,18 @@ function minify(ast, options = {}, recursive = false) {
             else {
                 // @ts-ignore
                 if (!(node.typ == 'AtRule' && node.nam != 'font-face')) {
-                    minify(node, options, recursive);
+                    minify(node, options, recursive, errors, nestingContent);
                 }
             }
         }
+        if (!nestingContent &&
+            // @ts-ignore
+            node != null &&
+            // previous.optimized != null &&
+            node.typ == 'Rule' &&
+            node.sel.includes('&')) {
+            fixSelector(node);
+        }
     }
     return ast;
 }
@@ -651,16 +706,6 @@ function reduceSelector(selector) {
         reducible: selector.every((selector) => !['>', '+', '~', '&'].includes(selector[0]))
     };
 }
-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++) {
@@ -786,7 +831,7 @@ function splitRule(buffer) {
 }
 function reduceRuleSelector(node) {
     if (node.raw == null) {
-        Object.defineProperty(node, 'raw', { enumerable: false, writable: true, value: splitRule(node.sel) });
+        Object.defineProperty(node, 'raw', { ...definedPropertySettings, value: splitRule(node.sel) });
     }
     // @ts-ignore
     // if (node.raw != null) {
@@ -796,7 +841,7 @@ function reduceRuleSelector(node) {
         return acc;
     }, []));
     if (optimized != null) {
-        Object.defineProperty(node, 'optimized', { enumerable: false, writable: true, value: optimized });
+        Object.defineProperty(node, 'optimized', { ...definedPropertySettings, value: optimized });
     }
     if (optimized != null && optimized.match && optimized.reducible && optimized.selector.length > 1) {
         const raw = [
@@ -814,10 +859,9 @@ function reduceRuleSelector(node) {
         if (sel.length < node.sel.length) {
             node.sel = sel;
             // node.raw = raw;
-            Object.defineProperty(node, 'raw', { enumerable: false, writable: true, value: raw });
+            Object.defineProperty(node, 'raw', { ...definedPropertySettings, value: raw });
         }
     }
-    // }
 }
 
-export { combinators, hasDeclaration, minify, minifyRule, reduceSelector };
+export { combinators, hasDeclaration, minify, minifyRule, reduceSelector, splitRule };