@master/eslint-plugin-css 2.0.0-rc.4 → 2.0.0-rc.41

package/dist/utils/extract-classnames-from-value.cjs

@@ -0,0 +1,34 @@
+'use strict';
+
+const separatorRegEx = /([\t\n\f\r ]+)/;
+function extractClassnamesFromValue(classStr) {
+    if (typeof classStr !== 'string') {
+        return {
+            classNames: [],
+            whitespaces: [],
+            headSpace: false,
+            tailSpace: false
+        };
+    }
+    const parts = classStr.split(separatorRegEx);
+    if (parts[0] === '') {
+        parts.shift();
+    }
+    if (parts[parts.length - 1] === '') {
+        parts.pop();
+    }
+    const headSpace = separatorRegEx.test(parts[0]);
+    const tailSpace = separatorRegEx.test(parts[parts.length - 1]);
+    const isClass = (_, i)=>headSpace ? i % 2 !== 0 : i % 2 === 0;
+    const isNotClass = (_, i)=>headSpace ? i % 2 === 0 : i % 2 !== 0;
+    const classNames = parts.filter(isClass);
+    const whitespaces = parts.filter(isNotClass);
+    return {
+        classNames: classNames,
+        whitespaces: whitespaces,
+        headSpace: headSpace,
+        tailSpace: tailSpace
+    };
+}
+
+module.exports = extractClassnamesFromValue;

package/dist/utils/extract-classnames-from-value.mjs

@@ -1 +1,32 @@
-const a=/([\t\n\f\r ]+)/;function f(c){if(typeof c!="string")return{classNames:[],whitespaces:[],headSpace:!1,tailSpace:!1};const s=c.split(a);s[0]===""&&s.shift(),s[s.length-1]===""&&s.pop();const t=a.test(s[0]),l=a.test(s[s.length-1]),n=(r,e)=>t?e%2!==0:e%2===0,p=(r,e)=>t?e%2===0:e%2!==0,i=s.filter(n),o=s.filter(p);return{classNames:i,whitespaces:o,headSpace:t,tailSpace:l}}export{f as default};
+const separatorRegEx = /([\t\n\f\r ]+)/;
+function extractClassnamesFromValue(classStr) {
+    if (typeof classStr !== 'string') {
+        return {
+            classNames: [],
+            whitespaces: [],
+            headSpace: false,
+            tailSpace: false
+        };
+    }
+    const parts = classStr.split(separatorRegEx);
+    if (parts[0] === '') {
+        parts.shift();
+    }
+    if (parts[parts.length - 1] === '') {
+        parts.pop();
+    }
+    const headSpace = separatorRegEx.test(parts[0]);
+    const tailSpace = separatorRegEx.test(parts[parts.length - 1]);
+    const isClass = (_, i)=>headSpace ? i % 2 !== 0 : i % 2 === 0;
+    const isNotClass = (_, i)=>headSpace ? i % 2 === 0 : i % 2 !== 0;
+    const classNames = parts.filter(isClass);
+    const whitespaces = parts.filter(isNotClass);
+    return {
+        classNames: classNames,
+        whitespaces: whitespaces,
+        headSpace: headSpace,
+        tailSpace: tailSpace
+    };
+}
+
+export { extractClassnamesFromValue as default };

package/dist/utils/extract-range-from-node.cjs

@@ -0,0 +1,18 @@
+'use strict';
+
+function extractRangeFromNode(node) {
+    if (node.type === 'TextAttribute' && node.name === 'class') {
+        return [
+            node.valueSpan.fullStart.offset,
+            node.valueSpan.end.offset
+        ];
+    }
+    switch(node.value.type){
+        case 'JSXExpressionContainer':
+            return node.value.expression.range;
+        default:
+            return node.value.range;
+    }
+}
+
+module.exports = extractRangeFromNode;

package/dist/utils/extract-range-from-node.mjs

@@ -1 +1,16 @@
-function t(e){if(e.type==="TextAttribute"&&e.name==="class")return[e.valueSpan.fullStart.offset,e.valueSpan.end.offset];switch(e.value.type){case"JSXExpressionContainer":return e.value.expression.range;default:return e.value.range}}export{t as default};
+function extractRangeFromNode(node) {
+    if (node.type === 'TextAttribute' && node.name === 'class') {
+        return [
+            node.valueSpan.fullStart.offset,
+            node.valueSpan.end.offset
+        ];
+    }
+    switch(node.value.type){
+        case 'JSXExpressionContainer':
+            return node.value.expression.range;
+        default:
+            return node.value.range;
+    }
+}
+
+export { extractRangeFromNode as default };

package/dist/utils/extract-value-from-node.cjs

@@ -0,0 +1,23 @@
+'use strict';
+
+function extractValueFromNode(node) {
+    if (node.type === 'TextAttribute' && node.name === 'class') {
+        return node.value;
+    }
+    switch(node.value.type){
+        case 'JSXExpressionContainer':
+            return node.value.expression.value;
+        case 'VExpressionContainer':
+            switch(node.value.expression.type){
+                case 'ArrayExpression':
+                    return node.value.expression.elements;
+                case 'ObjectExpression':
+                    return node.value.expression.properties;
+            }
+            return node.value.expression.value;
+        default:
+            return node.value.value;
+    }
+}
+
+module.exports = extractValueFromNode;

package/dist/utils/extract-value-from-node.mjs

@@ -1 +1,21 @@
-function r(e){if(e.type==="TextAttribute"&&e.name==="class")return e.value;switch(e.value.type){case"JSXExpressionContainer":return e.value.expression.value;case"VExpressionContainer":switch(e.value.expression.type){case"ArrayExpression":return e.value.expression.elements;case"ObjectExpression":return e.value.expression.properties}return e.value.expression.value;default:return e.value.value}}export{r as default};
+function extractValueFromNode(node) {
+    if (node.type === 'TextAttribute' && node.name === 'class') {
+        return node.value;
+    }
+    switch(node.value.type){
+        case 'JSXExpressionContainer':
+            return node.value.expression.value;
+        case 'VExpressionContainer':
+            switch(node.value.expression.type){
+                case 'ArrayExpression':
+                    return node.value.expression.elements;
+                case 'ObjectExpression':
+                    return node.value.expression.properties;
+            }
+            return node.value.expression.value;
+        default:
+            return node.value.value;
+    }
+}
+
+export { extractValueFromNode as default };

package/dist/utils/find-loc.cjs

@@ -0,0 +1,48 @@
+'use strict';
+
+var indexOfAll = require('./index-of-all.cjs');
+
+function findLoc(text, lines, startLine, endLine) {
+    const targetLines = text.match(/.+(?:\r\n|\n)?/g);
+    let checkingTargetLine = 0;
+    let resultStart = null;
+    let checking = false;
+    for(let i = startLine; i <= endLine; i++){
+        const sourceCodeLine = lines[i - 1];
+        const content = targetLines[checkingTargetLine].replace(/\r\n|\n/, '');
+        const indexes = indexOfAll.indexOfAll(sourceCodeLine, content);
+        if (indexes.length > 0) {
+            for (const index of indexes){
+                if (index !== 0 && sourceCodeLine[index - 1].match(/\w/) || index + content.length < sourceCodeLine.length && sourceCodeLine[index + content.length].match(/\w/)) {
+                    continue;
+                }
+                if (checkingTargetLine === 0) {
+                    resultStart = {
+                        line: i,
+                        column: index
+                    };
+                }
+                if (checkingTargetLine === targetLines.length - 1) {
+                    return {
+                        start: resultStart,
+                        end: {
+                            line: i,
+                            column: index + text.length
+                        }
+                    };
+                }
+                checking = true;
+                checkingTargetLine++;
+            }
+        } else {
+            if (checking) {
+                checking = false;
+                checkingTargetLine = 0;
+                resultStart = null;
+            }
+        }
+    }
+    return null;
+}
+
+module.exports = findLoc;

package/dist/utils/find-loc.mjs

@@ -1 +1,46 @@
-function s(r,o,u,f){const c=r.match(/.+(?:\r\n|\n)?/g);let e=0,l=null,t=!1;for(let n=u;n<=f;n++){const i=o[n-1].indexOf(c[e].replace(/\r\n|\n/,""));if(i!==-1){if(e===0&&(l={line:n,column:i}),e===c.length-1)return{start:l,end:{line:n,column:i+r.length}};t=!0,e++}else t&&(t=!1,e=0,l=null)}return null}export{s as default};
+import { indexOfAll } from './index-of-all.mjs';
+
+function findLoc(text, lines, startLine, endLine) {
+    const targetLines = text.match(/.+(?:\r\n|\n)?/g);
+    let checkingTargetLine = 0;
+    let resultStart = null;
+    let checking = false;
+    for(let i = startLine; i <= endLine; i++){
+        const sourceCodeLine = lines[i - 1];
+        const content = targetLines[checkingTargetLine].replace(/\r\n|\n/, '');
+        const indexes = indexOfAll(sourceCodeLine, content);
+        if (indexes.length > 0) {
+            for (const index of indexes){
+                if (index !== 0 && sourceCodeLine[index - 1].match(/\w/) || index + content.length < sourceCodeLine.length && sourceCodeLine[index + content.length].match(/\w/)) {
+                    continue;
+                }
+                if (checkingTargetLine === 0) {
+                    resultStart = {
+                        line: i,
+                        column: index
+                    };
+                }
+                if (checkingTargetLine === targetLines.length - 1) {
+                    return {
+                        start: resultStart,
+                        end: {
+                            line: i,
+                            column: index + text.length
+                        }
+                    };
+                }
+                checking = true;
+                checkingTargetLine++;
+            }
+        } else {
+            if (checking) {
+                checking = false;
+                checkingTargetLine = 0;
+                resultStart = null;
+            }
+        }
+    }
+    return null;
+}
+
+export { findLoc as default };

package/dist/utils/get-template-element-body.cjs

@@ -0,0 +1,12 @@
+'use strict';
+
+function getTemplateElementBody(text, prefix, suffix) {
+    let arr = text.split(prefix);
+    arr.shift();
+    const body = arr.join(prefix);
+    arr = body.split(suffix);
+    arr.pop();
+    return arr.join(suffix);
+}
+
+module.exports = getTemplateElementBody;

package/dist/utils/get-template-element-body.mjs

@@ -1 +1,10 @@
-function l(n,o,e){let t=n.split(o);return t.shift(),t=t.join(o).split(e),t.pop(),t.join(e)}export{l as default};
+function getTemplateElementBody(text, prefix, suffix) {
+    let arr = text.split(prefix);
+    arr.shift();
+    const body = arr.join(prefix);
+    arr = body.split(suffix);
+    arr.pop();
+    return arr.join(suffix);
+}
+
+export { getTemplateElementBody as default };

package/dist/utils/get-template-element-prefix.cjs

@@ -0,0 +1,11 @@
+'use strict';
+
+function getTemplateElementPrefix(text, raw) {
+    const idx = text.indexOf(raw);
+    if (idx === 0) {
+        return '';
+    }
+    return text.split(raw).shift();
+}
+
+module.exports = getTemplateElementPrefix;

package/dist/utils/get-template-element-prefix.mjs

@@ -1 +1,9 @@
-function i(e,t){return e.indexOf(t)===0?"":e.split(t).shift()}export{i as default};
+function getTemplateElementPrefix(text, raw) {
+    const idx = text.indexOf(raw);
+    if (idx === 0) {
+        return '';
+    }
+    return text.split(raw).shift();
+}
+
+export { getTemplateElementPrefix as default };

package/dist/utils/get-template-element-suffix.cjs

@@ -0,0 +1,10 @@
+'use strict';
+
+function getTemplateElementSuffix(text, raw) {
+    if (text.indexOf(raw) === -1) {
+        return '';
+    }
+    return text.split(raw).pop();
+}
+
+module.exports = getTemplateElementSuffix;

package/dist/utils/get-template-element-suffix.mjs

@@ -1 +1,8 @@
-function f(e,t){return e.indexOf(t)===-1?"":e.split(t).pop()}export{f as default};
+function getTemplateElementSuffix(text, raw) {
+    if (text.indexOf(raw) === -1) {
+        return '';
+    }
+    return text.split(raw).pop();
+}
+
+export { getTemplateElementSuffix as default };

package/dist/utils/index-of-all.cjs

@@ -0,0 +1,12 @@
+'use strict';
+
+function indexOfAll(arr, value) {
+    const result = [];
+    let i = -1;
+    while((i = arr.indexOf(value, i + 1)) !== -1){
+        result.push(i);
+    }
+    return result;
+}
+
+exports.indexOfAll = indexOfAll;

package/dist/utils/index-of-all.d.ts

@@ -0,0 +1 @@
+export declare function indexOfAll(arr: any[] | string, value: any): number[];

package/dist/utils/index-of-all.mjs

@@ -0,0 +1,10 @@
+function indexOfAll(arr, value) {
+    const result = [];
+    let i = -1;
+    while((i = arr.indexOf(value, i + 1)) !== -1){
+        result.push(i);
+    }
+    return result;
+}
+
+export { indexOfAll };

package/dist/utils/parse-node-recursive.cjs

@@ -0,0 +1,130 @@
+'use strict';
+
+var getTemplateElementPrefix = require('./get-template-element-prefix.cjs');
+var getTemplateElementSuffix = require('./get-template-element-suffix.cjs');
+var extractValueFromNode = require('./extract-value-from-node.cjs');
+var extractClassnamesFromValue = require('./extract-classnames-from-value.cjs');
+var extractRangeFromNode = require('./extract-range-from-node.cjs');
+
+/**
+ * Inspect and parse an abstract syntax node and run a callback function
+ *
+ * @param {ASTNode} rootNode The current root node being parsed by eslint
+ * @param {ASTNode} childNode The AST node child argument being checked
+ * @param {Function} cb The callback function
+ * @param {Boolean} skipConditional Optional, indicate distinct parsing for conditional nodes
+ * @param {Boolean} isolate Optional, set internally to isolate parsing and validation on conditional children
+ * @param {Array} ignoredKeys Optional, set object keys which should not be parsed e.g. for `cva`
+ * @returns {void}
+ */ function parseNodeRecursive(rootNode, childNode, cb, skipConditional = false, isolate = false, ignoredKeys = [], context) {
+    // TODO allow vue non litteral
+    let originalClassNamesValue;
+    let classNames;
+    let start = null;
+    let end = null;
+    let prefix = '';
+    let suffix = '';
+    if (childNode === null) {
+        originalClassNamesValue = extractValueFromNode(rootNode);
+        ({ classNames } = extractClassnamesFromValue(originalClassNamesValue));
+        classNames = [
+            ...new Set(classNames)
+        ];
+        if (classNames.length === 0) {
+            // Don't run for empty className
+            return;
+        }
+        const range = extractRangeFromNode(rootNode);
+        if (rootNode.type === 'TextAttribute') {
+            start = range[0];
+            end = range[1];
+        } else {
+            start = range[0] + 1;
+            end = range[1] - 1;
+        }
+        cb(classNames, rootNode, originalClassNamesValue, start, end, prefix, suffix);
+    } else if (childNode === undefined) {
+        // Ignore invalid child candidates (probably inside complex TemplateLiteral)
+        return;
+    } else {
+        const forceIsolation = skipConditional ? true : isolate;
+        let expStrings = [];
+        switch(childNode.type){
+            case 'TemplateLiteral':
+                childNode.expressions.forEach((exp)=>{
+                    parseNodeRecursive(rootNode, exp, cb, skipConditional, forceIsolation, ignoredKeys, context);
+                });
+                const sourceCode = context.sourceCode;
+                originalClassNamesValue = sourceCode.getText(childNode);
+                originalClassNamesValue = originalClassNamesValue.substring(1, originalClassNamesValue.length - 1);
+                expStrings = originalClassNamesValue.match(/\$\{(?:(?<!\\\\)(['"`]).*?(?<!\\\\)\1|[^}])*?\}/g) ?? [];
+                for(let i = 0; i < expStrings.length; i++){
+                    originalClassNamesValue = originalClassNamesValue.replace(expStrings[i], `EXPRESSION_STRING_NUM_${i}`);
+                }
+                break;
+            case 'ConditionalExpression':
+                parseNodeRecursive(rootNode, childNode.consequent, cb, skipConditional, forceIsolation, ignoredKeys, context);
+                parseNodeRecursive(rootNode, childNode.alternate, cb, skipConditional, forceIsolation, ignoredKeys, context);
+                return;
+            case 'LogicalExpression':
+                parseNodeRecursive(rootNode, childNode.right, cb, skipConditional, forceIsolation, ignoredKeys, context);
+                return;
+            case 'ArrayExpression':
+                childNode.elements.forEach((el)=>{
+                    parseNodeRecursive(rootNode, el, cb, skipConditional, forceIsolation, ignoredKeys, context);
+                });
+                return;
+            case 'ObjectExpression':
+                childNode.properties.forEach((prop)=>{
+                    const isUsedByClassNamesPlugin = rootNode.callee && rootNode.callee.name === 'classnames';
+                    if (prop.type === 'SpreadElement') {
+                        // Ignore spread elements
+                        return;
+                    }
+                    if (prop.key.type === 'Identifier' && ignoredKeys.includes(prop.key.name)) {
+                        // Ignore specific keys defined in settings
+                        return;
+                    }
+                    parseNodeRecursive(rootNode, isUsedByClassNamesPlugin ? prop.key : prop.value, cb, skipConditional, forceIsolation, ignoredKeys, context);
+                });
+                return;
+            case 'Property':
+                parseNodeRecursive(rootNode, childNode.key, cb, skipConditional, forceIsolation, ignoredKeys, context);
+                return;
+            case 'Literal':
+                originalClassNamesValue = childNode.value;
+                start = childNode.range[0] + 1;
+                end = childNode.range[1] - 1;
+                break;
+            case 'SvelteLiteral':
+                originalClassNamesValue = childNode.value;
+                start = childNode.range[0];
+                end = childNode.range[1];
+                break;
+            case 'TemplateElement':
+                originalClassNamesValue = childNode.value.raw;
+                start = childNode.range[0];
+                end = childNode.range[1];
+                // eslint-disable-next-line no-case-declarations
+                const txt = context?.sourceCode.getText(childNode) ?? '';
+                prefix = getTemplateElementPrefix(txt, originalClassNamesValue);
+                suffix = getTemplateElementSuffix(txt, originalClassNamesValue);
+                break;
+        }
+        for(let i = 0; i < expStrings.length; i++){
+            originalClassNamesValue = originalClassNamesValue.replace(`EXPRESSION_STRING_NUM_${i}`, expStrings[i]);
+        }
+        ({ classNames } = extractClassnamesFromValue(originalClassNamesValue));
+        classNames = [
+            ...new Set(classNames)
+        ];
+        if (classNames.length === 0) {
+            // Don't run for empty className
+            return;
+        }
+        const targetNode = isolate ? null : rootNode;
+        cb(classNames, targetNode, originalClassNamesValue, start, end, prefix, suffix);
+    }
+}
+
+exports.parseNodeRecursive = parseNodeRecursive;

package/dist/utils/parse-node-recursive.d.ts

@@ -1,4 +1,4 @@
-import { Rule } from 'eslint';
+import type { RuleContext } from '@typescript-eslint/utils/ts-eslint';
 /**
  * Inspect and parse an abstract syntax node and run a callback function
  *
@@ -10,4 +10,4 @@ import { Rule } from 'eslint';
  * @param {Array} ignoredKeys Optional, set object keys which should not be parsed e.g. for `cva`
  * @returns {void}
  */
-export declare function parseNodeRecursive(rootNode: any, childNode: any, cb: any, skipConditional?: boolean, isolate?: boolean, ignoredKeys?: any[], context?: Rule.RuleContext): void;
+export declare function parseNodeRecursive(rootNode: any, childNode: any, cb: any, skipConditional: boolean, isolate: boolean, ignoredKeys: any[], context: RuleContext<any, any>): void;

package/dist/utils/parse-node-recursive.mjs

@@ -1 +1,128 @@
-import L from"./get-template-element-prefix.mjs";import y from"./get-template-element-suffix.mjs";import F from"./extract-value-from-node.mjs";import c from"./extract-classnames-from-value.mjs";import P from"./extract-range-from-node.mjs";function f(t,e,s,l=!1,g=!1,m=[],R=null){let n,u,x=null,E=null,p="",v="";if(e===null){if(n=F(t),{classNames:u}=c(n),u=[...new Set(u)],u.length===0)return;const a=P(t);t.type==="TextAttribute"?(x=a[0],E=a[1]):(x=a[0]+1,E=a[1]-1),s(u,t,n,x,E,p,v)}else{if(e===void 0)return;{const a=l?!0:g;let S=!1;switch(e.type){case"TemplateLiteral":e.expressions.forEach(r=>{f(t,r,s,l,a,m)}),e.quasis.forEach(r=>{f(t,r,s,l,g,m)});return;case"ConditionalExpression":f(t,e.consequent,s,l,a,m),f(t,e.alternate,s,l,a,m);return;case"LogicalExpression":f(t,e.right,s,l,a,m);return;case"ArrayExpression":e.elements.forEach(r=>{f(t,r,s,l,a,m)});return;case"ObjectExpression":e.properties.forEach(r=>{const w=t.callee&&t.callee.name==="classnames";r.type!=="SpreadElement"&&(r.key.type==="Identifier"&&m.includes(r.key.name)||f(t,w?r.key:r.value,s,l,a,m))});return;case"Property":f(t,e.key,s,l,a,m);return;case"Literal":S=!0,n=e.value,x=e.range[0]+1,E=e.range[1]-1;break;case"SvelteLiteral":n=e.value,x=e.range[0],E=e.range[1];break;case"TemplateElement":n=e.value.raw,x=e.range[0],E=e.range[1];const T=R?.sourceCode.getText(e)??"";p=L(T,n),v=y(T,n);break}if({classNames:u}=c(n),u=[...new Set(u)],u.length===0)return;s(u,g?null:t,n,x,E,p,v)}}}export{f as parseNodeRecursive};
+import getTemplateElementPrefix from './get-template-element-prefix.mjs';
+import getTemplateElementSuffix from './get-template-element-suffix.mjs';
+import extractValueFromNode from './extract-value-from-node.mjs';
+import extractClassnamesFromValue from './extract-classnames-from-value.mjs';
+import extractRangeFromNode from './extract-range-from-node.mjs';
+
+/**
+ * Inspect and parse an abstract syntax node and run a callback function
+ *
+ * @param {ASTNode} rootNode The current root node being parsed by eslint
+ * @param {ASTNode} childNode The AST node child argument being checked
+ * @param {Function} cb The callback function
+ * @param {Boolean} skipConditional Optional, indicate distinct parsing for conditional nodes
+ * @param {Boolean} isolate Optional, set internally to isolate parsing and validation on conditional children
+ * @param {Array} ignoredKeys Optional, set object keys which should not be parsed e.g. for `cva`
+ * @returns {void}
+ */ function parseNodeRecursive(rootNode, childNode, cb, skipConditional = false, isolate = false, ignoredKeys = [], context) {
+    // TODO allow vue non litteral
+    let originalClassNamesValue;
+    let classNames;
+    let start = null;
+    let end = null;
+    let prefix = '';
+    let suffix = '';
+    if (childNode === null) {
+        originalClassNamesValue = extractValueFromNode(rootNode);
+        ({ classNames } = extractClassnamesFromValue(originalClassNamesValue));
+        classNames = [
+            ...new Set(classNames)
+        ];
+        if (classNames.length === 0) {
+            // Don't run for empty className
+            return;
+        }
+        const range = extractRangeFromNode(rootNode);
+        if (rootNode.type === 'TextAttribute') {
+            start = range[0];
+            end = range[1];
+        } else {
+            start = range[0] + 1;
+            end = range[1] - 1;
+        }
+        cb(classNames, rootNode, originalClassNamesValue, start, end, prefix, suffix);
+    } else if (childNode === undefined) {
+        // Ignore invalid child candidates (probably inside complex TemplateLiteral)
+        return;
+    } else {
+        const forceIsolation = skipConditional ? true : isolate;
+        let expStrings = [];
+        switch(childNode.type){
+            case 'TemplateLiteral':
+                childNode.expressions.forEach((exp)=>{
+                    parseNodeRecursive(rootNode, exp, cb, skipConditional, forceIsolation, ignoredKeys, context);
+                });
+                const sourceCode = context.sourceCode;
+                originalClassNamesValue = sourceCode.getText(childNode);
+                originalClassNamesValue = originalClassNamesValue.substring(1, originalClassNamesValue.length - 1);
+                expStrings = originalClassNamesValue.match(/\$\{(?:(?<!\\\\)(['"`]).*?(?<!\\\\)\1|[^}])*?\}/g) ?? [];
+                for(let i = 0; i < expStrings.length; i++){
+                    originalClassNamesValue = originalClassNamesValue.replace(expStrings[i], `EXPRESSION_STRING_NUM_${i}`);
+                }
+                break;
+            case 'ConditionalExpression':
+                parseNodeRecursive(rootNode, childNode.consequent, cb, skipConditional, forceIsolation, ignoredKeys, context);
+                parseNodeRecursive(rootNode, childNode.alternate, cb, skipConditional, forceIsolation, ignoredKeys, context);
+                return;
+            case 'LogicalExpression':
+                parseNodeRecursive(rootNode, childNode.right, cb, skipConditional, forceIsolation, ignoredKeys, context);
+                return;
+            case 'ArrayExpression':
+                childNode.elements.forEach((el)=>{
+                    parseNodeRecursive(rootNode, el, cb, skipConditional, forceIsolation, ignoredKeys, context);
+                });
+                return;
+            case 'ObjectExpression':
+                childNode.properties.forEach((prop)=>{
+                    const isUsedByClassNamesPlugin = rootNode.callee && rootNode.callee.name === 'classnames';
+                    if (prop.type === 'SpreadElement') {
+                        // Ignore spread elements
+                        return;
+                    }
+                    if (prop.key.type === 'Identifier' && ignoredKeys.includes(prop.key.name)) {
+                        // Ignore specific keys defined in settings
+                        return;
+                    }
+                    parseNodeRecursive(rootNode, isUsedByClassNamesPlugin ? prop.key : prop.value, cb, skipConditional, forceIsolation, ignoredKeys, context);
+                });
+                return;
+            case 'Property':
+                parseNodeRecursive(rootNode, childNode.key, cb, skipConditional, forceIsolation, ignoredKeys, context);
+                return;
+            case 'Literal':
+                originalClassNamesValue = childNode.value;
+                start = childNode.range[0] + 1;
+                end = childNode.range[1] - 1;
+                break;
+            case 'SvelteLiteral':
+                originalClassNamesValue = childNode.value;
+                start = childNode.range[0];
+                end = childNode.range[1];
+                break;
+            case 'TemplateElement':
+                originalClassNamesValue = childNode.value.raw;
+                start = childNode.range[0];
+                end = childNode.range[1];
+                // eslint-disable-next-line no-case-declarations
+                const txt = context?.sourceCode.getText(childNode) ?? '';
+                prefix = getTemplateElementPrefix(txt, originalClassNamesValue);
+                suffix = getTemplateElementSuffix(txt, originalClassNamesValue);
+                break;
+        }
+        for(let i = 0; i < expStrings.length; i++){
+            originalClassNamesValue = originalClassNamesValue.replace(`EXPRESSION_STRING_NUM_${i}`, expStrings[i]);
+        }
+        ({ classNames } = extractClassnamesFromValue(originalClassNamesValue));
+        classNames = [
+            ...new Set(classNames)
+        ];
+        if (classNames.length === 0) {
+            // Don't run for empty className
+            return;
+        }
+        const targetNode = isolate ? null : rootNode;
+        cb(classNames, targetNode, originalClassNamesValue, start, end, prefix, suffix);
+    }
+}
+
+export { parseNodeRecursive };

package/dist/utils/resolve-context.cjs

@@ -0,0 +1,35 @@
+'use strict';
+
+var settings = require('../settings.cjs');
+var exploreConfig = require('@master/css-explore-config');
+var css = require('@master/css');
+
+const cssCaches = [];
+function resolveContext(context) {
+    const resolvedSettings = Object.assign({}, settings, context.settings?.['@master/css']);
+    let css$1 = cssCaches.find((cache)=>cache.settings.config === resolvedSettings.config && cache.cwd === context.cwd)?.css;
+    if (!css$1) {
+        let config;
+        if (typeof resolvedSettings.config === 'object') {
+            config = resolvedSettings.config;
+        } else {
+            config = exploreConfig({
+                name: resolvedSettings.config,
+                found: undefined
+            });
+        }
+        css$1 = new css.MasterCSS(config);
+        cssCaches.push({
+            cwd: context.cwd,
+            settings: resolvedSettings,
+            css: css$1
+        });
+    }
+    return {
+        settings: resolvedSettings,
+        options: context.options[0] || {},
+        css: css$1
+    };
+}
+
+module.exports = resolveContext;