@master/eslint-plugin-css 2.0.0-rc.7 → 2.0.0-rc.70

package/dist/utils/is-same-or-child-path.d.ts

@@ -0,0 +1 @@
+export default function isSameOrChildPath(parentPath: string, childPath: string): boolean;

package/dist/utils/is-same-or-child-path.mjs

@@ -0,0 +1,8 @@
+import path from 'node:path';
+
+function isSameOrChildPath(parentPath, childPath) {
+    const relativePath = path.relative(parentPath, childPath);
+    return relativePath === '' || !!relativePath && relativePath !== '..' && !relativePath.startsWith(`..${path.sep}`) && !path.isAbsolute(relativePath);
+}
+
+export { isSameOrChildPath as default };

package/dist/utils/master-css.cjs

@@ -0,0 +1,94 @@
+'use strict';
+
+var css = require('@master/css');
+var cssValidator = require('@master/css-validator');
+var node_module = require('node:module');
+var UtilityType = require('@master/css-schema/utility-type');
+
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+const require$1 = node_module.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('utils/master-css.cjs', document.baseURI).href)));
+const defaultManifest = require$1('@master/css-preset/default-manifest.json');
+const CLASS_ATTRIBUTES = [
+    'class',
+    'className'
+];
+const CLASS_DECLARATIONS = [];
+const CLASS_FUNCTIONS = [
+    'clsx',
+    'cva',
+    'ctl',
+    'cv',
+    'class',
+    'classnames',
+    'classVariant',
+    'styled(?:\\s+)?(?:\\.\\w+)?',
+    'classList(?:\\s+)?\\.(?:add|remove|toggle|replace)'
+];
+const LAYER_ORDER = [
+    'theme',
+    'base',
+    'defaults',
+    'components',
+    'utilities'
+];
+function stable(value) {
+    if (!value || typeof value !== 'object') return JSON.stringify(value);
+    if (Array.isArray(value)) return `[${value.map(stable).join(',')}]`;
+    return `{${Object.entries(value).sort(([a], [b])=>a.localeCompare(b)).map(([key, item])=>`${JSON.stringify(key)}:${stable(item)}`).join(',')}}`;
+}
+function equalDeclarations(a, b) {
+    if (!a || !b || typeof a !== 'object' || typeof b !== 'object') return stable(a) === stable(b);
+    const aKeys = Object.keys(a).sort();
+    const bKeys = Object.keys(b).sort();
+    return stable(aKeys) === stable(bKeys);
+}
+function equalVariants(a, b) {
+    const branchA = a.variantBranchKey;
+    const branchB = b.variantBranchKey;
+    return (branchA !== undefined || branchB !== undefined ? branchA === branchB : a.selectorText === b.selectorText) && a.layerName === b.layerName && stable(a.atRules) === stable(b.atRules);
+}
+function getLayerOrder(layerName) {
+    const index = LAYER_ORDER.indexOf(layerName || 'utilities');
+    return index === -1 ? LAYER_ORDER.length : index;
+}
+function getReadableGroupOrder(rule) {
+    if (rule.atRules) return 3;
+    if (rule.mode) return 2;
+    if (rule.selectorNodes?.length) return 1;
+    return 0;
+}
+function getReadableTypeOrder(rule) {
+    if (rule.fixedClass) return 0;
+    if (rule.type === UtilityType.Semantic) return 1;
+    return 2;
+}
+function sortReadableClasses(classNames, css$1) {
+    return [
+        ...new Set(classNames)
+    ].sort((a, b)=>{
+        const ruleA = css$1.generate(a)[0];
+        const ruleB = css$1.generate(b)[0];
+        if (!ruleA && !ruleB) return a.localeCompare(b);
+        if (!ruleA) return 1;
+        if (!ruleB) return -1;
+        const layerCmp = getLayerOrder(ruleA.layerName) - getLayerOrder(ruleB.layerName);
+        if (layerCmp !== 0) return layerCmp;
+        const groupCmp = getReadableGroupOrder(ruleA) - getReadableGroupOrder(ruleB);
+        if (groupCmp !== 0) return groupCmp;
+        const typeCmp = getReadableTypeOrder(ruleA) - getReadableTypeOrder(ruleB);
+        if (typeCmp !== 0) return typeCmp;
+        return css.compareRulePriority(ruleA, ruleB) || a.localeCompare(b);
+    });
+}
+
+Object.defineProperty(exports, "createCSSWithNativeDeclarations", {
+    enumerable: true,
+    get: function () { return cssValidator.createCSSWithNativeDeclarations; }
+});
+exports.CLASS_ATTRIBUTES = CLASS_ATTRIBUTES;
+exports.CLASS_DECLARATIONS = CLASS_DECLARATIONS;
+exports.CLASS_FUNCTIONS = CLASS_FUNCTIONS;
+exports.defaultManifest = defaultManifest;
+exports.equalDeclarations = equalDeclarations;
+exports.equalVariants = equalVariants;
+exports.sortReadableClasses = sortReadableClasses;

package/dist/utils/master-css.d.ts

@@ -0,0 +1,21 @@
+import { type MasterCSS, type MasterCSSManifest } from '@master/css';
+import { createCSSWithNativeDeclarations } from '@master/css-validator';
+export type { MasterCSS, MasterCSSManifest };
+declare const defaultManifest: MasterCSSManifest;
+export { createCSSWithNativeDeclarations, defaultManifest };
+export declare const CLASS_ATTRIBUTES: string[];
+export declare const CLASS_DECLARATIONS: string[];
+export declare const CLASS_FUNCTIONS: string[];
+export declare function equalDeclarations(a: unknown, b: unknown): boolean;
+export declare function equalVariants(a: {
+    selectorText?: string;
+    atRules?: unknown;
+    layerName?: string;
+    variantBranchKey?: string;
+}, b: {
+    selectorText?: string;
+    atRules?: unknown;
+    layerName?: string;
+    variantBranchKey?: string;
+}): boolean;
+export declare function sortReadableClasses(classNames: string[], css: MasterCSS): string[];

package/dist/utils/master-css.mjs

@@ -0,0 +1,81 @@
+import { compareRulePriority } from '@master/css';
+export { createCSSWithNativeDeclarations } from '@master/css-validator';
+import { createRequire } from 'node:module';
+import UtilityType from '@master/css-schema/utility-type';
+
+const require$1 = createRequire(import.meta.url);
+const defaultManifest = require$1('@master/css-preset/default-manifest.json');
+const CLASS_ATTRIBUTES = [
+    'class',
+    'className'
+];
+const CLASS_DECLARATIONS = [];
+const CLASS_FUNCTIONS = [
+    'clsx',
+    'cva',
+    'ctl',
+    'cv',
+    'class',
+    'classnames',
+    'classVariant',
+    'styled(?:\\s+)?(?:\\.\\w+)?',
+    'classList(?:\\s+)?\\.(?:add|remove|toggle|replace)'
+];
+const LAYER_ORDER = [
+    'theme',
+    'base',
+    'defaults',
+    'components',
+    'utilities'
+];
+function stable(value) {
+    if (!value || typeof value !== 'object') return JSON.stringify(value);
+    if (Array.isArray(value)) return `[${value.map(stable).join(',')}]`;
+    return `{${Object.entries(value).sort(([a], [b])=>a.localeCompare(b)).map(([key, item])=>`${JSON.stringify(key)}:${stable(item)}`).join(',')}}`;
+}
+function equalDeclarations(a, b) {
+    if (!a || !b || typeof a !== 'object' || typeof b !== 'object') return stable(a) === stable(b);
+    const aKeys = Object.keys(a).sort();
+    const bKeys = Object.keys(b).sort();
+    return stable(aKeys) === stable(bKeys);
+}
+function equalVariants(a, b) {
+    const branchA = a.variantBranchKey;
+    const branchB = b.variantBranchKey;
+    return (branchA !== undefined || branchB !== undefined ? branchA === branchB : a.selectorText === b.selectorText) && a.layerName === b.layerName && stable(a.atRules) === stable(b.atRules);
+}
+function getLayerOrder(layerName) {
+    const index = LAYER_ORDER.indexOf(layerName || 'utilities');
+    return index === -1 ? LAYER_ORDER.length : index;
+}
+function getReadableGroupOrder(rule) {
+    if (rule.atRules) return 3;
+    if (rule.mode) return 2;
+    if (rule.selectorNodes?.length) return 1;
+    return 0;
+}
+function getReadableTypeOrder(rule) {
+    if (rule.fixedClass) return 0;
+    if (rule.type === UtilityType.Semantic) return 1;
+    return 2;
+}
+function sortReadableClasses(classNames, css) {
+    return [
+        ...new Set(classNames)
+    ].sort((a, b)=>{
+        const ruleA = css.generate(a)[0];
+        const ruleB = css.generate(b)[0];
+        if (!ruleA && !ruleB) return a.localeCompare(b);
+        if (!ruleA) return 1;
+        if (!ruleB) return -1;
+        const layerCmp = getLayerOrder(ruleA.layerName) - getLayerOrder(ruleB.layerName);
+        if (layerCmp !== 0) return layerCmp;
+        const groupCmp = getReadableGroupOrder(ruleA) - getReadableGroupOrder(ruleB);
+        if (groupCmp !== 0) return groupCmp;
+        const typeCmp = getReadableTypeOrder(ruleA) - getReadableTypeOrder(ruleB);
+        if (typeCmp !== 0) return typeCmp;
+        return compareRulePriority(ruleA, ruleB) || a.localeCompare(b);
+    });
+}
+
+export { CLASS_ATTRIBUTES, CLASS_DECLARATIONS, CLASS_FUNCTIONS, defaultManifest, equalDeclarations, equalVariants, sortReadableClasses };

package/dist/utils/resolve-class-node.cjs

@@ -0,0 +1,147 @@
+'use strict';
+
+var common = require('../common.cjs');
+
+function resolveClassNode(node, context) {
+    const { sourceCode } = context;
+    let value = null;
+    let raw = null;
+    let start = null;
+    let end = null;
+    switch(node.type){
+        case 'Literal':
+            value = node.value;
+            raw = node.raw;
+            start = node.range[0];
+            end = node.range[1];
+            break;
+        case 'VLiteral':
+            value = node.value;
+            raw = sourceCode.getText(node);
+            start = node.range[0];
+            end = node.range[1];
+            break;
+        case 'TextAttribute':
+            value = node.value;
+            start = node.valueSpan.fullStart.offset;
+            end = node.valueSpan.end.offset;
+            raw = sourceCode.getText({
+                ...node,
+                range: [
+                    start,
+                    end
+                ]
+            });
+            break;
+        case 'SvelteLiteral':
+            value = node.value;
+            raw = sourceCode.getText(node);
+            start = node.range[0];
+            end = node.range[1];
+            break;
+        case 'TemplateElement':
+            if (node.parent.expressions.length) {
+                return;
+            }
+            value = node.value.cooked;
+            raw = node.value.raw;
+            start = node.range[0] + 1;
+            end = node.range[1] - 1;
+            break;
+        default:
+            return;
+    }
+    if (typeof value !== 'string') {
+        return;
+    }
+    if (/^(['"`])(.*)\1$/.test(raw)) {
+        raw = raw.slice(1, -1);
+        start = start + 1;
+        end = end - 1;
+    }
+    const nodes = [];
+    const classValues = value.split(common.HALF_WIDTH_WHITESPACE_REGEX);
+    const classRaws = raw.split(common.HALF_WIDTH_WHITESPACE_REGEX);
+    const classValueRawMap = new Map();
+    const classRawValueMap = new Map();
+    for(let i = 0; i < classRaws.length; i++){
+        classValueRawMap.set(classValues[i], classRaws[i]);
+        classRawValueMap.set(classRaws[i], classValues[i]);
+    }
+    let lastIndex = 0;
+    let match;
+    while((match = common.HALF_WIDTH_WHITESPACE_GLOBAL_REGEX.exec(raw)) !== null){
+        const spaceRaw = match[0];
+        const spaceStart = match.index;
+        const spaceEnd = spaceStart + spaceRaw.length;
+        if (spaceStart > lastIndex) {
+            const classRaw = raw.slice(lastIndex, spaceStart);
+            const classValue = classRawValueMap.get(classRaw);
+            if (!classValue) return;
+            const startOffset = start + lastIndex;
+            const endOffset = start + spaceStart;
+            nodes.push({
+                type: 'class',
+                value: classValue,
+                raw: classRaw,
+                range: [
+                    startOffset,
+                    endOffset
+                ],
+                loc: {
+                    start: sourceCode.getLocFromIndex(startOffset),
+                    end: sourceCode.getLocFromIndex(endOffset)
+                }
+            });
+        }
+        const spaceStartOffset = start + spaceStart;
+        const spaceEndOffset = start + spaceEnd;
+        nodes.push({
+            type: 'space',
+            raw: spaceRaw,
+            range: [
+                spaceStartOffset,
+                spaceEndOffset
+            ],
+            loc: {
+                start: sourceCode.getLocFromIndex(spaceStartOffset),
+                end: sourceCode.getLocFromIndex(spaceEndOffset)
+            }
+        });
+        lastIndex = spaceEnd;
+    }
+    if (lastIndex < raw.length) {
+        const classRaw = raw.slice(lastIndex);
+        const classValue = classRawValueMap.get(classRaw);
+        if (!classValue) return;
+        const startOffset = start + lastIndex;
+        const endOffset = start + raw.length;
+        nodes.push({
+            type: 'class',
+            value: classValue,
+            raw: classRaw,
+            range: [
+                startOffset,
+                endOffset
+            ],
+            loc: {
+                start: sourceCode.getLocFromIndex(startOffset),
+                end: sourceCode.getLocFromIndex(endOffset)
+            }
+        });
+    }
+    const classNodes = nodes.filter((node)=>node.type === 'class');
+    return {
+        nodes,
+        start,
+        end,
+        raw,
+        value,
+        classRawValueMap,
+        classValueRawMap,
+        classNodes,
+        classValues: classNodes.map((node)=>node.value)
+    };
+}
+
+module.exports = resolveClassNode;

package/dist/utils/resolve-class-node.d.ts

@@ -0,0 +1,12 @@
+import { RuleContext } from '@typescript-eslint/utils/ts-eslint';
+export default function resolveClassNode(node: any, context: RuleContext<any, any[]>): {
+    nodes: any[];
+    start: number;
+    end: number;
+    raw: string;
+    value: string;
+    classRawValueMap: Map<any, any>;
+    classValueRawMap: Map<any, any>;
+    classNodes: any[];
+    classValues: any[];
+};

package/dist/utils/resolve-class-node.mjs

@@ -0,0 +1,145 @@
+import { HALF_WIDTH_WHITESPACE_REGEX, HALF_WIDTH_WHITESPACE_GLOBAL_REGEX } from '../common.mjs';
+
+function resolveClassNode(node, context) {
+    const { sourceCode } = context;
+    let value = null;
+    let raw = null;
+    let start = null;
+    let end = null;
+    switch(node.type){
+        case 'Literal':
+            value = node.value;
+            raw = node.raw;
+            start = node.range[0];
+            end = node.range[1];
+            break;
+        case 'VLiteral':
+            value = node.value;
+            raw = sourceCode.getText(node);
+            start = node.range[0];
+            end = node.range[1];
+            break;
+        case 'TextAttribute':
+            value = node.value;
+            start = node.valueSpan.fullStart.offset;
+            end = node.valueSpan.end.offset;
+            raw = sourceCode.getText({
+                ...node,
+                range: [
+                    start,
+                    end
+                ]
+            });
+            break;
+        case 'SvelteLiteral':
+            value = node.value;
+            raw = sourceCode.getText(node);
+            start = node.range[0];
+            end = node.range[1];
+            break;
+        case 'TemplateElement':
+            if (node.parent.expressions.length) {
+                return;
+            }
+            value = node.value.cooked;
+            raw = node.value.raw;
+            start = node.range[0] + 1;
+            end = node.range[1] - 1;
+            break;
+        default:
+            return;
+    }
+    if (typeof value !== 'string') {
+        return;
+    }
+    if (/^(['"`])(.*)\1$/.test(raw)) {
+        raw = raw.slice(1, -1);
+        start = start + 1;
+        end = end - 1;
+    }
+    const nodes = [];
+    const classValues = value.split(HALF_WIDTH_WHITESPACE_REGEX);
+    const classRaws = raw.split(HALF_WIDTH_WHITESPACE_REGEX);
+    const classValueRawMap = new Map();
+    const classRawValueMap = new Map();
+    for(let i = 0; i < classRaws.length; i++){
+        classValueRawMap.set(classValues[i], classRaws[i]);
+        classRawValueMap.set(classRaws[i], classValues[i]);
+    }
+    let lastIndex = 0;
+    let match;
+    while((match = HALF_WIDTH_WHITESPACE_GLOBAL_REGEX.exec(raw)) !== null){
+        const spaceRaw = match[0];
+        const spaceStart = match.index;
+        const spaceEnd = spaceStart + spaceRaw.length;
+        if (spaceStart > lastIndex) {
+            const classRaw = raw.slice(lastIndex, spaceStart);
+            const classValue = classRawValueMap.get(classRaw);
+            if (!classValue) return;
+            const startOffset = start + lastIndex;
+            const endOffset = start + spaceStart;
+            nodes.push({
+                type: 'class',
+                value: classValue,
+                raw: classRaw,
+                range: [
+                    startOffset,
+                    endOffset
+                ],
+                loc: {
+                    start: sourceCode.getLocFromIndex(startOffset),
+                    end: sourceCode.getLocFromIndex(endOffset)
+                }
+            });
+        }
+        const spaceStartOffset = start + spaceStart;
+        const spaceEndOffset = start + spaceEnd;
+        nodes.push({
+            type: 'space',
+            raw: spaceRaw,
+            range: [
+                spaceStartOffset,
+                spaceEndOffset
+            ],
+            loc: {
+                start: sourceCode.getLocFromIndex(spaceStartOffset),
+                end: sourceCode.getLocFromIndex(spaceEndOffset)
+            }
+        });
+        lastIndex = spaceEnd;
+    }
+    if (lastIndex < raw.length) {
+        const classRaw = raw.slice(lastIndex);
+        const classValue = classRawValueMap.get(classRaw);
+        if (!classValue) return;
+        const startOffset = start + lastIndex;
+        const endOffset = start + raw.length;
+        nodes.push({
+            type: 'class',
+            value: classValue,
+            raw: classRaw,
+            range: [
+                startOffset,
+                endOffset
+            ],
+            loc: {
+                start: sourceCode.getLocFromIndex(startOffset),
+                end: sourceCode.getLocFromIndex(endOffset)
+            }
+        });
+    }
+    const classNodes = nodes.filter((node)=>node.type === 'class');
+    return {
+        nodes,
+        start,
+        end,
+        raw,
+        value,
+        classRawValueMap,
+        classValueRawMap,
+        classNodes,
+        classValues: classNodes.map((node)=>node.value)
+    };
+}
+
+export { resolveClassNode as default };

package/dist/utils/resolve-context.cjs

@@ -0,0 +1,78 @@
+'use strict';
+
+var settings = require('../settings.cjs');
+var masterCss = require('./master-css.cjs');
+var entries = require('@master/css-project/entries');
+var manifestSync = require('@master/css-project/manifest-sync');
+var path = require('node:path');
+var node_fs = require('node:fs');
+var isSameOrChildPath = require('./is-same-or-child-path.cjs');
+var cssValidator = require('@master/css-validator');
+
+const cssCaches = [];
+const workspaceDirectoriesByCwd = new Map();
+function getContextFilename(context) {
+    const filename = context.physicalFilename || context.filename;
+    if (!filename || filename.startsWith('<')) return;
+    const resolvedFilename = path.isAbsolute(filename) ? filename : path.resolve(context.cwd, filename);
+    return node_fs.existsSync(resolvedFilename) ? resolvedFilename : undefined;
+}
+function getWorkspaceDirectories(cwd) {
+    let directories = workspaceDirectoriesByCwd.get(cwd);
+    if (!directories) {
+        directories = entries.findMasterCSSWorkspaceDirectoriesSync(cwd);
+        workspaceDirectoriesByCwd.set(cwd, directories);
+    }
+    return directories;
+}
+function findNearestPackageDirectory(filename) {
+    let directory = path.dirname(filename);
+    const root = path.parse(directory).root;
+    while(directory !== root){
+        if (node_fs.existsSync(path.join(directory, 'package.json'))) return directory;
+        directory = path.dirname(directory);
+    }
+    return path.dirname(filename);
+}
+function resolveSearchDirectory(context, filename) {
+    const cwd = path.resolve(context.cwd || process.cwd());
+    const root = path.parse(cwd).root;
+    if (cwd !== root && isSameOrChildPath(cwd, filename)) return cwd;
+    return findNearestPackageDirectory(filename);
+}
+function resolveWorkspaceDirectory(context, filename) {
+    const cwd = resolveSearchDirectory(context, filename);
+    let closestDirectory;
+    for (const directory of getWorkspaceDirectories(cwd)){
+        if (isSameOrChildPath(directory, filename) && (!closestDirectory || directory.length > closestDirectory.length)) {
+            closestDirectory = directory;
+        }
+    }
+    return closestDirectory || cwd;
+}
+function resolvePlan(workspaceDir, manifest) {
+    const result = manifestSync.loadProjectManifestSync(workspaceDir);
+    return result.entries.length ? result.manifest : manifest;
+}
+function resolveContext(context) {
+    const resolvedSettings = Object.assign({}, settings, context.settings?.['@master/css']);
+    const filename = getContextFilename(context);
+    const workspaceDir = filename ? resolveWorkspaceDirectory(context, filename) : context.cwd || process.cwd();
+    let css = cssCaches.find((cache)=>cache.manifest === resolvedSettings.manifest && cache.cwd === workspaceDir)?.css;
+    if (!css) {
+        const manifest = filename ? resolvePlan(workspaceDir, resolvedSettings.manifest) : resolvedSettings.manifest;
+        css = cssValidator.createCSSWithNativeDeclarations(manifest || masterCss.defaultManifest);
+        cssCaches.push({
+            cwd: workspaceDir,
+            manifest: resolvedSettings.manifest,
+            css
+        });
+    }
+    return {
+        settings: resolvedSettings,
+        options: context.options[0] || {},
+        css
+    };
+}
+
+module.exports = resolveContext;

package/dist/utils/resolve-context.d.ts

@@ -1,4 +1,13 @@
-export default function resolveContext(context: any): {
-    settings: any;
+import type { RuleContext } from '@typescript-eslint/utils/ts-eslint';
+import { MasterCSS } from './master-css';
+export default function resolveContext(context: RuleContext<any, any[]>): {
+    settings: {
+        classAttributes: string[];
+        classFunctions: string[];
+        classDeclarations: string[];
+        ignoredKeys: string[];
+        manifest: any;
+    };
     options: any;
+    css: MasterCSS;
 };

package/dist/utils/resolve-context.mjs

@@ -1 +1,76 @@
-import s from"../settings.mjs";function e(t){return{settings:Object.assign(s,t.settings?.["@master/css"]),options:t.options[0]||{}}}export{e as default};
+import settings from '../settings.mjs';
+import { defaultManifest } from './master-css.mjs';
+import { findMasterCSSWorkspaceDirectoriesSync } from '@master/css-project/entries';
+import { loadProjectManifestSync } from '@master/css-project/manifest-sync';
+import path from 'node:path';
+import { existsSync } from 'node:fs';
+import isSameOrChildPath from './is-same-or-child-path.mjs';
+import { createCSSWithNativeDeclarations } from '@master/css-validator';
+
+const cssCaches = [];
+const workspaceDirectoriesByCwd = new Map();
+function getContextFilename(context) {
+    const filename = context.physicalFilename || context.filename;
+    if (!filename || filename.startsWith('<')) return;
+    const resolvedFilename = path.isAbsolute(filename) ? filename : path.resolve(context.cwd, filename);
+    return existsSync(resolvedFilename) ? resolvedFilename : undefined;
+}
+function getWorkspaceDirectories(cwd) {
+    let directories = workspaceDirectoriesByCwd.get(cwd);
+    if (!directories) {
+        directories = findMasterCSSWorkspaceDirectoriesSync(cwd);
+        workspaceDirectoriesByCwd.set(cwd, directories);
+    }
+    return directories;
+}
+function findNearestPackageDirectory(filename) {
+    let directory = path.dirname(filename);
+    const root = path.parse(directory).root;
+    while(directory !== root){
+        if (existsSync(path.join(directory, 'package.json'))) return directory;
+        directory = path.dirname(directory);
+    }
+    return path.dirname(filename);
+}
+function resolveSearchDirectory(context, filename) {
+    const cwd = path.resolve(context.cwd || process.cwd());
+    const root = path.parse(cwd).root;
+    if (cwd !== root && isSameOrChildPath(cwd, filename)) return cwd;
+    return findNearestPackageDirectory(filename);
+}
+function resolveWorkspaceDirectory(context, filename) {
+    const cwd = resolveSearchDirectory(context, filename);
+    let closestDirectory;
+    for (const directory of getWorkspaceDirectories(cwd)){
+        if (isSameOrChildPath(directory, filename) && (!closestDirectory || directory.length > closestDirectory.length)) {
+            closestDirectory = directory;
+        }
+    }
+    return closestDirectory || cwd;
+}
+function resolvePlan(workspaceDir, manifest) {
+    const result = loadProjectManifestSync(workspaceDir);
+    return result.entries.length ? result.manifest : manifest;
+}
+function resolveContext(context) {
+    const resolvedSettings = Object.assign({}, settings, context.settings?.['@master/css']);
+    const filename = getContextFilename(context);
+    const workspaceDir = filename ? resolveWorkspaceDirectory(context, filename) : context.cwd || process.cwd();
+    let css = cssCaches.find((cache)=>cache.manifest === resolvedSettings.manifest && cache.cwd === workspaceDir)?.css;
+    if (!css) {
+        const manifest = filename ? resolvePlan(workspaceDir, resolvedSettings.manifest) : resolvedSettings.manifest;
+        css = createCSSWithNativeDeclarations(manifest || defaultManifest);
+        cssCaches.push({
+            cwd: workspaceDir,
+            manifest: resolvedSettings.manifest,
+            css
+        });
+    }
+    return {
+        settings: resolvedSettings,
+        options: context.options[0] || {},
+        css
+    };
+}
+
+export { resolveContext as default };