boss-css 0.0.1 → 0.0.2

package/dist/eslint-plugin/utils/ast.cjs

@@ -0,0 +1,119 @@
+
+//#region src/eslint-plugin/utils/ast.js
+const isStringLiteral = (node) => node && node.type === "Literal" && typeof node.value === "string" || node && node.type === "StringLiteral" && typeof node.value === "string";
+const isTemplateLiteral = (node) => node && node.type === "TemplateLiteral";
+const getLiteralInfo = (node, sourceCode) => {
+	if (isStringLiteral(node)) return {
+		value: node.value,
+		node,
+		raw: sourceCode.getText(node),
+		canFix: true
+	};
+	if (isTemplateLiteral(node) && node.expressions.length === 0) {
+		const quasi = node.quasis[0];
+		return {
+			value: quasi?.value?.cooked ?? quasi?.value?.raw ?? "",
+			node,
+			raw: sourceCode.getText(node),
+			canFix: true
+		};
+	}
+	return null;
+};
+const getPropertyKeyInfo = (property, sourceCode) => {
+	if (!property || property.type !== "Property") return null;
+	if (property.computed) return null;
+	const key = property.key;
+	if (isStringLiteral(key)) return {
+		value: key.value,
+		node: key,
+		raw: sourceCode.getText(key),
+		canFix: false
+	};
+	if (key && key.type === "Identifier") return {
+		value: key.name,
+		node: key,
+		raw: sourceCode.getText(key),
+		canFix: false
+	};
+	return null;
+};
+const collectClassLiteralsFromExpression = (expression, sourceCode, results) => {
+	if (!expression) return;
+	if (expression.type === "JSXExpressionContainer") {
+		collectClassLiteralsFromExpression(expression.expression, sourceCode, results);
+		return;
+	}
+	const literal = getLiteralInfo(expression, sourceCode);
+	if (literal) {
+		results.push(literal);
+		return;
+	}
+	if (expression.type === "ArrayExpression") {
+		for (const element of expression.elements) if (element) collectClassLiteralsFromExpression(element, sourceCode, results);
+		return;
+	}
+	if (expression.type === "LogicalExpression") {
+		collectClassLiteralsFromExpression(expression.left, sourceCode, results);
+		collectClassLiteralsFromExpression(expression.right, sourceCode, results);
+		return;
+	}
+	if (expression.type === "ConditionalExpression") {
+		collectClassLiteralsFromExpression(expression.consequent, sourceCode, results);
+		collectClassLiteralsFromExpression(expression.alternate, sourceCode, results);
+		return;
+	}
+	if (expression.type === "BinaryExpression" && expression.operator === "+") {
+		collectClassLiteralsFromExpression(expression.left, sourceCode, results);
+		collectClassLiteralsFromExpression(expression.right, sourceCode, results);
+		return;
+	}
+	if (expression.type === "SequenceExpression") {
+		for (const item of expression.expressions) collectClassLiteralsFromExpression(item, sourceCode, results);
+		return;
+	}
+	if (expression.type === "ObjectExpression") {
+		for (const property of expression.properties) if (property && property.type === "Property") {
+			const keyInfo = getPropertyKeyInfo(property, sourceCode);
+			if (keyInfo) results.push(keyInfo);
+		}
+	}
+};
+const compilePatterns = (patterns) => {
+	if (!Array.isArray(patterns)) return [];
+	return patterns.map((pattern) => new RegExp(pattern));
+};
+const matchesPattern = (compiled, name) => compiled.some((pattern) => pattern.test(name));
+const getCalleeName = (node) => {
+	if (!node) return null;
+	if (node.type === "ChainExpression") return getCalleeName(node.expression);
+	if (node.type === "Identifier") return node.name;
+	if (node.type === "MemberExpression" && !node.computed) {
+		const objectName = getCalleeName(node.object);
+		const propertyName = getCalleeName(node.property);
+		if (!objectName || !propertyName) return null;
+		return `${objectName}.${propertyName}`;
+	}
+	return null;
+};
+const getJSXRootName = (node) => {
+	if (!node) return null;
+	if (node.type === "JSXIdentifier") return node.name;
+	if (node.type === "JSXMemberExpression") return getJSXRootName(node.object);
+	return null;
+};
+const getJSXAttributeName = (node) => {
+	if (!node || node.type !== "JSXAttribute") return null;
+	if (!node.name) return null;
+	if (node.name.type === "JSXIdentifier") return node.name.name;
+	return null;
+};
+
+//#endregion
+exports.collectClassLiteralsFromExpression = collectClassLiteralsFromExpression;
+exports.compilePatterns = compilePatterns;
+exports.getCalleeName = getCalleeName;
+exports.getJSXAttributeName = getJSXAttributeName;
+exports.getJSXRootName = getJSXRootName;
+exports.getLiteralInfo = getLiteralInfo;
+exports.matchesPattern = matchesPattern;

package/dist/eslint-plugin/utils/ast.mjs

@@ -0,0 +1,112 @@
+//#region src/eslint-plugin/utils/ast.js
+const isStringLiteral = (node) => node && node.type === "Literal" && typeof node.value === "string" || node && node.type === "StringLiteral" && typeof node.value === "string";
+const isTemplateLiteral = (node) => node && node.type === "TemplateLiteral";
+const getLiteralInfo = (node, sourceCode) => {
+	if (isStringLiteral(node)) return {
+		value: node.value,
+		node,
+		raw: sourceCode.getText(node),
+		canFix: true
+	};
+	if (isTemplateLiteral(node) && node.expressions.length === 0) {
+		const quasi = node.quasis[0];
+		return {
+			value: quasi?.value?.cooked ?? quasi?.value?.raw ?? "",
+			node,
+			raw: sourceCode.getText(node),
+			canFix: true
+		};
+	}
+	return null;
+};
+const getPropertyKeyInfo = (property, sourceCode) => {
+	if (!property || property.type !== "Property") return null;
+	if (property.computed) return null;
+	const key = property.key;
+	if (isStringLiteral(key)) return {
+		value: key.value,
+		node: key,
+		raw: sourceCode.getText(key),
+		canFix: false
+	};
+	if (key && key.type === "Identifier") return {
+		value: key.name,
+		node: key,
+		raw: sourceCode.getText(key),
+		canFix: false
+	};
+	return null;
+};
+const collectClassLiteralsFromExpression = (expression, sourceCode, results) => {
+	if (!expression) return;
+	if (expression.type === "JSXExpressionContainer") {
+		collectClassLiteralsFromExpression(expression.expression, sourceCode, results);
+		return;
+	}
+	const literal = getLiteralInfo(expression, sourceCode);
+	if (literal) {
+		results.push(literal);
+		return;
+	}
+	if (expression.type === "ArrayExpression") {
+		for (const element of expression.elements) if (element) collectClassLiteralsFromExpression(element, sourceCode, results);
+		return;
+	}
+	if (expression.type === "LogicalExpression") {
+		collectClassLiteralsFromExpression(expression.left, sourceCode, results);
+		collectClassLiteralsFromExpression(expression.right, sourceCode, results);
+		return;
+	}
+	if (expression.type === "ConditionalExpression") {
+		collectClassLiteralsFromExpression(expression.consequent, sourceCode, results);
+		collectClassLiteralsFromExpression(expression.alternate, sourceCode, results);
+		return;
+	}
+	if (expression.type === "BinaryExpression" && expression.operator === "+") {
+		collectClassLiteralsFromExpression(expression.left, sourceCode, results);
+		collectClassLiteralsFromExpression(expression.right, sourceCode, results);
+		return;
+	}
+	if (expression.type === "SequenceExpression") {
+		for (const item of expression.expressions) collectClassLiteralsFromExpression(item, sourceCode, results);
+		return;
+	}
+	if (expression.type === "ObjectExpression") {
+		for (const property of expression.properties) if (property && property.type === "Property") {
+			const keyInfo = getPropertyKeyInfo(property, sourceCode);
+			if (keyInfo) results.push(keyInfo);
+		}
+	}
+};
+const compilePatterns = (patterns) => {
+	if (!Array.isArray(patterns)) return [];
+	return patterns.map((pattern) => new RegExp(pattern));
+};
+const matchesPattern = (compiled, name) => compiled.some((pattern) => pattern.test(name));
+const getCalleeName = (node) => {
+	if (!node) return null;
+	if (node.type === "ChainExpression") return getCalleeName(node.expression);
+	if (node.type === "Identifier") return node.name;
+	if (node.type === "MemberExpression" && !node.computed) {
+		const objectName = getCalleeName(node.object);
+		const propertyName = getCalleeName(node.property);
+		if (!objectName || !propertyName) return null;
+		return `${objectName}.${propertyName}`;
+	}
+	return null;
+};
+const getJSXRootName = (node) => {
+	if (!node) return null;
+	if (node.type === "JSXIdentifier") return node.name;
+	if (node.type === "JSXMemberExpression") return getJSXRootName(node.object);
+	return null;
+};
+const getJSXAttributeName = (node) => {
+	if (!node || node.type !== "JSXAttribute") return null;
+	if (!node.name) return null;
+	if (node.name.type === "JSXIdentifier") return node.name.name;
+	return null;
+};
+
+//#endregion
+export { collectClassLiteralsFromExpression, compilePatterns, getCalleeName, getJSXAttributeName, getJSXRootName, getLiteralInfo, matchesPattern };

package/dist/eslint-plugin/utils/boss-classes.cjs

@@ -0,0 +1,185 @@
+const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
+const require_defaults = require('./defaults.cjs');
+const require_api = require('./api.cjs');
+let _boss_css_is_css_prop = require("@boss-css/is-css-prop");
+_boss_css_is_css_prop = require_rolldown_runtime.__toESM(_boss_css_is_css_prop);
+
+//#region src/eslint-plugin/utils/boss-classes.js
+const whitespaceRegexp = /\s/;
+const cssPropCache = /* @__PURE__ */ new Map();
+const dashToCamelCase = (str) => str.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());
+const getDictionary = () => {
+	const { api } = require_api.getApi();
+	return api?.dictionary ?? null;
+};
+const getDictionaryEntry = (name) => {
+	const dictionary = getDictionary();
+	if (!dictionary) return null;
+	if (typeof dictionary.resolve === "function") return dictionary.resolve(name).descriptor || dictionary.resolve(dashToCamelCase(name)).descriptor || null;
+	return dictionary.get(name) || dictionary.get(dashToCamelCase(name)) || null;
+};
+const isCssPropName = (name, extraProps) => {
+	if (!name) return false;
+	if (extraProps && extraProps.has(name)) return true;
+	const dictionaryEntry = getDictionaryEntry(name);
+	if (dictionaryEntry) return Boolean(dictionaryEntry.isCSSProp);
+	const cached = cssPropCache.get(name);
+	if (cached !== void 0) return cached;
+	const camelName = dashToCamelCase(name);
+	const result = (0, _boss_css_is_css_prop.default)("div", name) || (0, _boss_css_is_css_prop.default)("div", camelName);
+	cssPropCache.set(name, result);
+	return result;
+};
+const splitClassList = (input) => {
+	const results = [];
+	let current = "";
+	let braceDepth = 0;
+	let bracketDepth = 0;
+	for (const char of input) {
+		if (char === "{") braceDepth += 1;
+		if (char === "}") braceDepth = Math.max(0, braceDepth - 1);
+		if (char === "[") bracketDepth += 1;
+		if (char === "]") bracketDepth = Math.max(0, bracketDepth - 1);
+		if (braceDepth === 0 && bracketDepth === 0 && whitespaceRegexp.test(char)) {
+			if (current) results.push(current);
+			current = "";
+			continue;
+		}
+		current += char;
+	}
+	if (current) results.push(current);
+	return results;
+};
+const splitFragments = (selector) => splitOutside(selector, ":");
+const parseGroupedSelector = (selector) => {
+	if (!selector.endsWith("}")) return null;
+	const groupStart = findGroupStart(selector);
+	if (groupStart === -1) return null;
+	const prefix = selector.slice(0, groupStart);
+	const entries = splitOutside(selector.slice(groupStart + 2, -1), ";").map((entry) => entry.trim()).filter(Boolean).map((entry) => {
+		const parts = splitOnceOutside(entry, ":");
+		if (!parts) return null;
+		const [name, rawValue] = parts;
+		return {
+			name: name.trim(),
+			rawValue: rawValue.trim()
+		};
+	}).filter(Boolean);
+	if (!entries.length) return null;
+	return {
+		prefix,
+		entries
+	};
+};
+const splitOutside = (input, delimiter) => {
+	const results = [];
+	let current = "";
+	let braceDepth = 0;
+	let bracketDepth = 0;
+	for (const char of input) {
+		if (char === "{") braceDepth += 1;
+		if (char === "}") braceDepth = Math.max(0, braceDepth - 1);
+		if (char === "[") bracketDepth += 1;
+		if (char === "]") bracketDepth = Math.max(0, bracketDepth - 1);
+		if (char === delimiter && braceDepth === 0 && bracketDepth === 0) {
+			if (current) results.push(current);
+			current = "";
+			continue;
+		}
+		current += char;
+	}
+	if (current) results.push(current);
+	return results;
+};
+const splitOnceOutside = (input, delimiter) => {
+	let braceDepth = 0;
+	let bracketDepth = 0;
+	for (let i = 0; i < input.length; i += 1) {
+		const char = input[i];
+		if (char === "{") braceDepth += 1;
+		if (char === "}") braceDepth = Math.max(0, braceDepth - 1);
+		if (char === "[") bracketDepth += 1;
+		if (char === "]") bracketDepth = Math.max(0, bracketDepth - 1);
+		if (char === delimiter && braceDepth === 0 && bracketDepth === 0) return [input.slice(0, i), input.slice(i + 1)];
+	}
+	return null;
+};
+const findGroupStart = (selector) => {
+	let bracketDepth = 0;
+	for (let i = 0; i < selector.length - 1; i += 1) {
+		const char = selector[i];
+		if (char === "[") bracketDepth += 1;
+		if (char === "]") bracketDepth = Math.max(0, bracketDepth - 1);
+		if (bracketDepth === 0 && selector[i] === ":" && selector[i + 1] === "{") return i;
+	}
+	return -1;
+};
+const isArbitrarySelectorContext = (context) => context.startsWith("[") && context.endsWith("]");
+const isContainerContext = (context) => context === "container" || context.startsWith("container ") || context.startsWith("container_");
+const getContextSet = (options) => {
+	const contexts = require_defaults.getDefaultContexts();
+	const dictionary = getDictionary();
+	if (dictionary) for (const [name, entry] of dictionary.entries()) {
+		if (entry?.isCSSProp) continue;
+		contexts.add(name);
+	}
+	if (options?.additionalContexts) for (const context of options.additionalContexts) contexts.add(context);
+	return contexts;
+};
+const hasValidContexts = (contexts, options, contextSet) => {
+	if (options?.allowCustomContexts) return true;
+	return contexts.every((context) => isArbitrarySelectorContext(context) || contextSet.has(context) || contextSet.has("container") && isContainerContext(context));
+};
+const isValidBossToken = (token, options = {}) => {
+	if (!token) return false;
+	const contextSet = getContextSet(options);
+	const extraProps = options.additionalProps ? new Set(options.additionalProps) : null;
+	const singleProps = options.singleProps ? new Set(options.singleProps) : null;
+	const grouped = parseGroupedSelector(token);
+	if (grouped) {
+		if (!hasValidContexts(splitFragments(grouped.prefix), options, contextSet)) return false;
+		for (const entry of grouped.entries) {
+			if (!entry.name) return false;
+			if (!isCssPropName(entry.name, extraProps)) return false;
+		}
+		return true;
+	}
+	const fragments = splitFragments(token);
+	if (!fragments.length) return false;
+	let propIndex = -1;
+	for (let i = 0; i < fragments.length; i += 1) if (isCssPropName(fragments[i], extraProps)) {
+		propIndex = i;
+		break;
+	}
+	if (propIndex === -1) return false;
+	if (!hasValidContexts(fragments.slice(0, propIndex), options, contextSet)) return false;
+	if (!(propIndex < fragments.length - 1)) {
+		if (getDictionaryEntry(fragments[propIndex])?.single) return true;
+		if (!singleProps) return false;
+		if (!singleProps.has(fragments[propIndex])) return false;
+	}
+	return true;
+};
+const findInvalidTokens = (classList, options) => {
+	const tokens = splitClassList(classList);
+	const invalid = [];
+	for (const token of tokens) {
+		if (!token) continue;
+		if (!isValidBossToken(token, options)) invalid.push(token);
+	}
+	return invalid;
+};
+const containsBossToken = (classList, options) => {
+	return splitClassList(classList).some((token) => isValidBossToken(token, options));
+};
+
+//#endregion
+exports.containsBossToken = containsBossToken;
+exports.findInvalidTokens = findInvalidTokens;
+exports.getContextSet = getContextSet;
+exports.getDictionary = getDictionary;
+exports.getDictionaryEntry = getDictionaryEntry;
+exports.isCssPropName = isCssPropName;
+exports.parseGroupedSelector = parseGroupedSelector;
+exports.splitClassList = splitClassList;
+exports.splitFragments = splitFragments;

package/dist/eslint-plugin/utils/boss-classes.mjs

@@ -0,0 +1,175 @@
+import { getDefaultContexts } from "./defaults.mjs";
+import { getApi } from "./api.mjs";
+import isCSSProp from "@boss-css/is-css-prop";
+
+//#region src/eslint-plugin/utils/boss-classes.js
+const whitespaceRegexp = /\s/;
+const cssPropCache = /* @__PURE__ */ new Map();
+const dashToCamelCase = (str) => str.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());
+const getDictionary = () => {
+	const { api } = getApi();
+	return api?.dictionary ?? null;
+};
+const getDictionaryEntry = (name) => {
+	const dictionary = getDictionary();
+	if (!dictionary) return null;
+	if (typeof dictionary.resolve === "function") return dictionary.resolve(name).descriptor || dictionary.resolve(dashToCamelCase(name)).descriptor || null;
+	return dictionary.get(name) || dictionary.get(dashToCamelCase(name)) || null;
+};
+const isCssPropName = (name, extraProps) => {
+	if (!name) return false;
+	if (extraProps && extraProps.has(name)) return true;
+	const dictionaryEntry = getDictionaryEntry(name);
+	if (dictionaryEntry) return Boolean(dictionaryEntry.isCSSProp);
+	const cached = cssPropCache.get(name);
+	if (cached !== void 0) return cached;
+	const camelName = dashToCamelCase(name);
+	const result = isCSSProp("div", name) || isCSSProp("div", camelName);
+	cssPropCache.set(name, result);
+	return result;
+};
+const splitClassList = (input) => {
+	const results = [];
+	let current = "";
+	let braceDepth = 0;
+	let bracketDepth = 0;
+	for (const char of input) {
+		if (char === "{") braceDepth += 1;
+		if (char === "}") braceDepth = Math.max(0, braceDepth - 1);
+		if (char === "[") bracketDepth += 1;
+		if (char === "]") bracketDepth = Math.max(0, bracketDepth - 1);
+		if (braceDepth === 0 && bracketDepth === 0 && whitespaceRegexp.test(char)) {
+			if (current) results.push(current);
+			current = "";
+			continue;
+		}
+		current += char;
+	}
+	if (current) results.push(current);
+	return results;
+};
+const splitFragments = (selector) => splitOutside(selector, ":");
+const parseGroupedSelector = (selector) => {
+	if (!selector.endsWith("}")) return null;
+	const groupStart = findGroupStart(selector);
+	if (groupStart === -1) return null;
+	const prefix = selector.slice(0, groupStart);
+	const entries = splitOutside(selector.slice(groupStart + 2, -1), ";").map((entry) => entry.trim()).filter(Boolean).map((entry) => {
+		const parts = splitOnceOutside(entry, ":");
+		if (!parts) return null;
+		const [name, rawValue] = parts;
+		return {
+			name: name.trim(),
+			rawValue: rawValue.trim()
+		};
+	}).filter(Boolean);
+	if (!entries.length) return null;
+	return {
+		prefix,
+		entries
+	};
+};
+const splitOutside = (input, delimiter) => {
+	const results = [];
+	let current = "";
+	let braceDepth = 0;
+	let bracketDepth = 0;
+	for (const char of input) {
+		if (char === "{") braceDepth += 1;
+		if (char === "}") braceDepth = Math.max(0, braceDepth - 1);
+		if (char === "[") bracketDepth += 1;
+		if (char === "]") bracketDepth = Math.max(0, bracketDepth - 1);
+		if (char === delimiter && braceDepth === 0 && bracketDepth === 0) {
+			if (current) results.push(current);
+			current = "";
+			continue;
+		}
+		current += char;
+	}
+	if (current) results.push(current);
+	return results;
+};
+const splitOnceOutside = (input, delimiter) => {
+	let braceDepth = 0;
+	let bracketDepth = 0;
+	for (let i = 0; i < input.length; i += 1) {
+		const char = input[i];
+		if (char === "{") braceDepth += 1;
+		if (char === "}") braceDepth = Math.max(0, braceDepth - 1);
+		if (char === "[") bracketDepth += 1;
+		if (char === "]") bracketDepth = Math.max(0, bracketDepth - 1);
+		if (char === delimiter && braceDepth === 0 && bracketDepth === 0) return [input.slice(0, i), input.slice(i + 1)];
+	}
+	return null;
+};
+const findGroupStart = (selector) => {
+	let bracketDepth = 0;
+	for (let i = 0; i < selector.length - 1; i += 1) {
+		const char = selector[i];
+		if (char === "[") bracketDepth += 1;
+		if (char === "]") bracketDepth = Math.max(0, bracketDepth - 1);
+		if (bracketDepth === 0 && selector[i] === ":" && selector[i + 1] === "{") return i;
+	}
+	return -1;
+};
+const isArbitrarySelectorContext = (context) => context.startsWith("[") && context.endsWith("]");
+const isContainerContext = (context) => context === "container" || context.startsWith("container ") || context.startsWith("container_");
+const getContextSet = (options) => {
+	const contexts = getDefaultContexts();
+	const dictionary = getDictionary();
+	if (dictionary) for (const [name, entry] of dictionary.entries()) {
+		if (entry?.isCSSProp) continue;
+		contexts.add(name);
+	}
+	if (options?.additionalContexts) for (const context of options.additionalContexts) contexts.add(context);
+	return contexts;
+};
+const hasValidContexts = (contexts, options, contextSet) => {
+	if (options?.allowCustomContexts) return true;
+	return contexts.every((context) => isArbitrarySelectorContext(context) || contextSet.has(context) || contextSet.has("container") && isContainerContext(context));
+};
+const isValidBossToken = (token, options = {}) => {
+	if (!token) return false;
+	const contextSet = getContextSet(options);
+	const extraProps = options.additionalProps ? new Set(options.additionalProps) : null;
+	const singleProps = options.singleProps ? new Set(options.singleProps) : null;
+	const grouped = parseGroupedSelector(token);
+	if (grouped) {
+		if (!hasValidContexts(splitFragments(grouped.prefix), options, contextSet)) return false;
+		for (const entry of grouped.entries) {
+			if (!entry.name) return false;
+			if (!isCssPropName(entry.name, extraProps)) return false;
+		}
+		return true;
+	}
+	const fragments = splitFragments(token);
+	if (!fragments.length) return false;
+	let propIndex = -1;
+	for (let i = 0; i < fragments.length; i += 1) if (isCssPropName(fragments[i], extraProps)) {
+		propIndex = i;
+		break;
+	}
+	if (propIndex === -1) return false;
+	if (!hasValidContexts(fragments.slice(0, propIndex), options, contextSet)) return false;
+	if (!(propIndex < fragments.length - 1)) {
+		if (getDictionaryEntry(fragments[propIndex])?.single) return true;
+		if (!singleProps) return false;
+		if (!singleProps.has(fragments[propIndex])) return false;
+	}
+	return true;
+};
+const findInvalidTokens = (classList, options) => {
+	const tokens = splitClassList(classList);
+	const invalid = [];
+	for (const token of tokens) {
+		if (!token) continue;
+		if (!isValidBossToken(token, options)) invalid.push(token);
+	}
+	return invalid;
+};
+const containsBossToken = (classList, options) => {
+	return splitClassList(classList).some((token) => isValidBossToken(token, options));
+};
+
+//#endregion
+export { containsBossToken, findInvalidTokens, getContextSet, getDictionary, getDictionaryEntry, isCssPropName, parseGroupedSelector, splitClassList, splitFragments };

package/dist/eslint-plugin/utils/defaults.cjs

@@ -0,0 +1,99 @@
+
+//#region src/eslint-plugin/utils/defaults.js
+const DEFAULT_ATTRIBUTE_PATTERNS = ["^class(?:Name)?$"];
+const DEFAULT_CALLEE_PATTERNS = [
+	"^cx$",
+	"^merge$",
+	"^\\$\\$\\.cx$",
+	"^\\$\\$\\.merge$"
+];
+const DEFAULT_VARIABLE_PATTERNS = ["^classNames?$", "^classes$"];
+const DEFAULT_TAG_PATTERNS = [];
+const DEFAULT_COMPONENTS = ["$$"];
+const DEFAULT_BREAKPOINTS = {
+	micro: [null, 375],
+	mobile: [376, 639],
+	tablet: [640, 1023],
+	small: [1024, 1439],
+	medium: [1440, 1919],
+	large: [1920, null],
+	device: [null, 1023]
+};
+const DEFAULT_PSEUDO_CONTEXTS = [
+	"defined",
+	"any-link",
+	"link",
+	"visited",
+	"local-link",
+	"target",
+	"target-within",
+	"scope",
+	"hover",
+	"active",
+	"focus",
+	"focus-visible",
+	"focus-within",
+	"current",
+	"past",
+	"future",
+	"playing",
+	"paused",
+	"seeking",
+	"buffering",
+	"stalled",
+	"muted",
+	"volume-locked",
+	"open",
+	"closed",
+	"modal",
+	"fullscreen",
+	"picture-in-picture",
+	"enabled",
+	"disabled",
+	"read-write",
+	"read-only",
+	"placeholder-shown",
+	"autofill",
+	"default",
+	"checked",
+	"indeterminate",
+	"blank",
+	"valid",
+	"invalid",
+	"in-range",
+	"out-of-range",
+	"user-valid",
+	"root",
+	"empty",
+	"first-child",
+	"last-child",
+	"only-child",
+	"first-of-type",
+	"last-of-type",
+	"only-of-type",
+	"after",
+	"before"
+];
+const getDefaultContexts = () => {
+	const contexts = new Set(DEFAULT_PSEUDO_CONTEXTS);
+	const breakpointNames = Object.keys(DEFAULT_BREAKPOINTS);
+	for (const name of breakpointNames) {
+		contexts.add(name);
+		contexts.add(`${name}+`);
+		contexts.add(`${name}-`);
+	}
+	contexts.add("at");
+	contexts.add("container");
+	contexts.add("dark");
+	contexts.add("light");
+	contexts.add("hdpi");
+	return contexts;
+};
+
+//#endregion
+exports.DEFAULT_ATTRIBUTE_PATTERNS = DEFAULT_ATTRIBUTE_PATTERNS;
+exports.DEFAULT_CALLEE_PATTERNS = DEFAULT_CALLEE_PATTERNS;
+exports.DEFAULT_COMPONENTS = DEFAULT_COMPONENTS;
+exports.DEFAULT_TAG_PATTERNS = DEFAULT_TAG_PATTERNS;
+exports.DEFAULT_VARIABLE_PATTERNS = DEFAULT_VARIABLE_PATTERNS;
+exports.getDefaultContexts = getDefaultContexts;