@bamboocss/eslint-plugin 1.12.0

package/dist/index.cjs

@@ -0,0 +1,2287 @@
+const require_utils = require('./utils-BQiAeXE_.cjs');
+let _bamboocss_shared = require("@bamboocss/shared");
+let _typescript_eslint_utils = require("@typescript-eslint/utils");
+let _typescript_eslint_utils_ast_utils = require("@typescript-eslint/utils/ast-utils");
+let _typescript_eslint_scope_manager = require("@typescript-eslint/scope-manager");
+require("@typescript-eslint/utils/ts-eslint");
+
+//#region package.json
+var name = "@bamboocss/eslint-plugin";
+var version = "1.12.0";
+
+//#endregion
+//#region src/utils/nodes.ts
+const isIdentifier = (0, _typescript_eslint_utils_ast_utils.isNodeOfType)(_typescript_eslint_utils.AST_NODE_TYPES.Identifier);
+const isLiteral = (0, _typescript_eslint_utils_ast_utils.isNodeOfType)(_typescript_eslint_utils.AST_NODE_TYPES.Literal);
+const isTemplateLiteral = (0, _typescript_eslint_utils_ast_utils.isNodeOfType)(_typescript_eslint_utils.AST_NODE_TYPES.TemplateLiteral);
+const isArrayExpression = (0, _typescript_eslint_utils_ast_utils.isNodeOfType)(_typescript_eslint_utils.AST_NODE_TYPES.ArrayExpression);
+const isObjectExpression = (0, _typescript_eslint_utils_ast_utils.isNodeOfType)(_typescript_eslint_utils.AST_NODE_TYPES.ObjectExpression);
+const isMemberExpression = (0, _typescript_eslint_utils_ast_utils.isNodeOfType)(_typescript_eslint_utils.AST_NODE_TYPES.MemberExpression);
+const isVariableDeclarator = (0, _typescript_eslint_utils_ast_utils.isNodeOfType)(_typescript_eslint_utils.AST_NODE_TYPES.VariableDeclarator);
+const isVariableDeclaration = (0, _typescript_eslint_utils_ast_utils.isNodeOfType)(_typescript_eslint_utils.AST_NODE_TYPES.VariableDeclaration);
+const isJSXMemberExpression = (0, _typescript_eslint_utils_ast_utils.isNodeOfType)(_typescript_eslint_utils.AST_NODE_TYPES.JSXMemberExpression);
+const isJSXOpeningElement = (0, _typescript_eslint_utils_ast_utils.isNodeOfType)(_typescript_eslint_utils.AST_NODE_TYPES.JSXOpeningElement);
+const isJSXExpressionContainer = (0, _typescript_eslint_utils_ast_utils.isNodeOfType)(_typescript_eslint_utils.AST_NODE_TYPES.JSXExpressionContainer);
+const isJSXAttribute = (0, _typescript_eslint_utils_ast_utils.isNodeOfType)(_typescript_eslint_utils.AST_NODE_TYPES.JSXAttribute);
+const isJSXIdentifier = (0, _typescript_eslint_utils_ast_utils.isNodeOfType)(_typescript_eslint_utils.AST_NODE_TYPES.JSXIdentifier);
+const isCallExpression = (0, _typescript_eslint_utils_ast_utils.isNodeOfType)(_typescript_eslint_utils.AST_NODE_TYPES.CallExpression);
+const isImportDeclaration = (0, _typescript_eslint_utils_ast_utils.isNodeOfType)(_typescript_eslint_utils.AST_NODE_TYPES.ImportDeclaration);
+const isImportSpecifier = (0, _typescript_eslint_utils_ast_utils.isNodeOfType)(_typescript_eslint_utils.AST_NODE_TYPES.ImportSpecifier);
+
+//#endregion
+//#region src/utils/helpers.ts
+const getAncestor = (ofType, for_) => {
+	let current = for_.parent;
+	while (current) {
+		if (ofType(current)) return current;
+		current = current.parent;
+	}
+};
+const getSyncOptions = (context) => {
+	return {
+		configPath: context.settings["@bamboocss/configPath"],
+		currentFile: context.filename
+	};
+};
+const getImportSpecifiers = (context) => {
+	const specifiers = [];
+	for (const node of context.sourceCode?.ast.body) {
+		if (!isImportDeclaration(node)) continue;
+		const module_ = node.source.value;
+		if (!module_) continue;
+		for (const specifier of node.specifiers) {
+			if (!isImportSpecifier(specifier)) continue;
+			specifiers.push({
+				mod: module_,
+				specifier
+			});
+		}
+	}
+	return specifiers;
+};
+const hasPkgImport = (context) => {
+	return _getImports(context).some(({ mod }) => mod === "@bamboocss/dev");
+};
+const isBambooConfigFunction = (context, name) => {
+	return _getImports(context).some(({ alias, mod }) => alias === name && mod === "@bamboocss/dev");
+};
+const rawImportsCache = /* @__PURE__ */ new WeakMap();
+const _getImports = (context) => {
+	if (rawImportsCache.has(context)) return rawImportsCache.get(context);
+	const imports = getImportSpecifiers(context).map(({ mod, specifier }) => ({
+		alias: specifier.local.name,
+		mod,
+		name: specifier.imported.name
+	}));
+	rawImportsCache.set(context, imports);
+	return imports;
+};
+const importsCache = /* @__PURE__ */ new WeakMap();
+const getImports = (context) => {
+	if (importsCache.has(context)) return importsCache.get(context);
+	const imports = _getImports(context);
+	const result = require_utils.syncAction("filterImports", getSyncOptions(context), imports) ?? [];
+	importsCache.set(context, result);
+	return result;
+};
+const isValidStyledProperty = (node, context) => {
+	return isJSXIdentifier(node) && isValidProperty(node.name, context);
+};
+const matchFile = (name, imports, context) => {
+	return require_utils.syncAction("matchFile", getSyncOptions(context), name, imports);
+};
+const isBambooIsh = (name, context) => {
+	const imports = getImports(context);
+	if (imports.length === 0) return false;
+	const jsxFactory = require_utils.syncAction("getJsxFactory", getSyncOptions(context));
+	if (jsxFactory && name === jsxFactory) return imports.some((imp) => imp.name === name || imp.alias === name);
+	return matchFile(name, imports, context);
+};
+const scopeCache = /* @__PURE__ */ new WeakMap();
+const findDeclaration = (name, context) => {
+	try {
+		const source = context.sourceCode;
+		if (!source) {
+			console.warn("⚠️ ESLint's sourceCode is not available. Ensure that the rule is invoked with valid code.");
+			return;
+		}
+		let scope = scopeCache.get(source.ast);
+		if (!scope) {
+			scope = (0, _typescript_eslint_scope_manager.analyze)(source.ast, { sourceType: "module" });
+			scopeCache.set(source.ast, scope);
+		}
+		const decl = scope.variables.find((v) => v.name === name)?.defs.find((d) => isIdentifier(d.name) && d.name.name === name)?.node;
+		if (isVariableDeclarator(decl)) return decl;
+	} catch (error) {
+		console.error("Error in findDeclaration:", error);
+		return;
+	}
+};
+const isLocalStyledFactory = (node, context) => {
+	if (!isJSXIdentifier(node.name)) return;
+	const decl = findDeclaration(node.name.name, context);
+	if (!decl) return;
+	if (!isCallExpression(decl.init)) return;
+	if (!isIdentifier(decl.init.callee)) return;
+	const calleeName = decl.init.callee.name;
+	if (!_getImports(context).some((imp) => imp.alias === calleeName && imp.mod.includes("bamboo")) && !isBambooIsh(calleeName, context)) return;
+	return true;
+};
+const isValidFile = (context) => {
+	return require_utils.syncAction("isValidFile", getSyncOptions(context));
+};
+const isValidProperty = (name, context, calleName) => {
+	return require_utils.syncAction("isValidProperty", getSyncOptions(context), name, calleName);
+};
+const isBambooImport = (node, context) => {
+	return getImports(context).some((imp) => imp.mod === node.source.value);
+};
+const isBambooProp = (node, context) => {
+	const jsxAncestor = getAncestor(isJSXOpeningElement, node);
+	if (!jsxAncestor) return;
+	if (!isJSXMemberExpression(jsxAncestor.name) && !isJSXIdentifier(jsxAncestor.name)) return;
+	let isBambooComponent = false;
+	let componentName;
+	if (isJSXMemberExpression(jsxAncestor.name)) {
+		const objectName = jsxAncestor.name.object.name;
+		componentName = objectName;
+		const imports = getImports(context);
+		const rawImports = _getImports(context);
+		isBambooComponent = imports.some((imp) => imp.alias === objectName) || rawImports.some((imp) => imp.alias === objectName && imp.mod.includes("bamboo")) || isBambooIsh(objectName, context);
+		if (isBambooComponent) return true;
+	} else if (isJSXIdentifier(jsxAncestor.name)) {
+		componentName = jsxAncestor.name.name;
+		if (isLocalStyledFactory(jsxAncestor, context)) {
+			const property = node.name.name;
+			if (property === "css" || typeof property === "string" && property.startsWith("_")) return true;
+			if (typeof property !== "string" || !isValidProperty(property, context)) return false;
+			return true;
+		}
+		isBambooComponent = isBambooIsh(componentName, context);
+	}
+	if (!isBambooComponent) return;
+	const property = node.name.name;
+	if (typeof property !== "string" || !isValidProperty(property, context, componentName)) return;
+	return true;
+};
+const isStyledProperty = (node, context, calleeName) => {
+	if (!isIdentifier(node.key) && !isLiteral(node.key) && !isTemplateLiteral(node.key)) return;
+	if (isIdentifier(node.key) && !isValidProperty(node.key.name, context, calleeName)) return;
+	if (isLiteral(node.key) && typeof node.key.value === "string" && !isValidProperty(node.key.value, context, calleeName)) return;
+	if (isTemplateLiteral(node.key) && !isValidProperty(node.key.quasis[0].value.raw, context, calleeName)) return;
+	return true;
+};
+const isInBambooFunction = (node, context) => {
+	const callAncestor = getAncestor(isCallExpression, node);
+	if (!callAncestor) return;
+	let calleeName;
+	if (isIdentifier(callAncestor.callee)) calleeName = callAncestor.callee.name;
+	if (isMemberExpression(callAncestor.callee) && isIdentifier(callAncestor.callee.object)) calleeName = callAncestor.callee.object.name;
+	if (!calleeName) return;
+	if (!isBambooIsh(calleeName, context)) return;
+	return calleeName;
+};
+const isInJSXProp = (node, context) => {
+	const jsxExprAncestor = getAncestor(isJSXExpressionContainer, node);
+	const jsxAttributeAncestor = getAncestor(isJSXAttribute, node);
+	if (!jsxExprAncestor || !jsxAttributeAncestor) return;
+	const jsxElement = getAncestor(isJSXOpeningElement, jsxAttributeAncestor);
+	if (!jsxElement) return;
+	let isBambooComponent = false;
+	if (isJSXMemberExpression(jsxElement.name)) {
+		const objectName = jsxElement.name.object.name;
+		isBambooComponent = isBambooIsh(objectName, context);
+	} else if (isJSXIdentifier(jsxElement.name)) {
+		const componentName = jsxElement.name.name;
+		isBambooComponent = isBambooIsh(componentName, context) || Boolean(isLocalStyledFactory(jsxElement, context));
+	}
+	if (!isBambooComponent) return;
+	if (!isJSXIdentifier(jsxAttributeAncestor.name)) return;
+	if (!isValidStyledProperty(jsxAttributeAncestor.name, context)) return;
+	return true;
+};
+const isBambooAttribute = (node, context) => {
+	if (getAncestor(isCallExpression, node)) {
+		const callee = isInBambooFunction(node, context);
+		if (!callee) return;
+		return isStyledProperty(node, context, callee);
+	}
+	return isInJSXProp(node, context) && isStyledProperty(node, context);
+};
+const resolveLonghand = (name, context) => {
+	return require_utils.syncAction("resolveLongHand", getSyncOptions(context), name);
+};
+const resolveShorthands = (name, context) => {
+	return require_utils.syncAction("resolveShorthands", getSyncOptions(context), name);
+};
+const isColorAttribute = (attribute, context) => {
+	return require_utils.syncAction("isColorAttribute", getSyncOptions(context), attribute);
+};
+const isColorToken = (value, context) => {
+	if (!value) return;
+	return require_utils.syncAction("isColorToken", getSyncOptions(context), value);
+};
+const extractTokens = (value) => {
+	const regex = /token\(([^"'(),]+)(?:,\s*([^"'(),]+))?\)|\{([^\n\r{}]+)\}/g;
+	const matches = [];
+	let match;
+	while ((match = regex.exec(value)) !== null) {
+		const tokenFromFirstSyntax = match[1] || match[2] || match[3];
+		const tokensFromSecondSyntax = match[4] && match[4].match(/(\w+\.\w+(\.\w+)?)/g);
+		if (tokenFromFirstSyntax) matches.push(tokenFromFirstSyntax);
+		if (tokensFromSecondSyntax) matches.push(...tokensFromSecondSyntax);
+	}
+	return matches.filter(Boolean);
+};
+const invalidTokensCache = /* @__PURE__ */ new Map();
+const getInvalidTokens = (value, context) => {
+	if (invalidTokensCache.has(value)) return invalidTokensCache.get(value);
+	const tokens = extractTokens(value);
+	if (!tokens.length) return [];
+	const invalidTokens = require_utils.syncAction("filterInvalidTokens", getSyncOptions(context), tokens);
+	invalidTokensCache.set(value, invalidTokens);
+	return invalidTokens;
+};
+const deprecatedTokensCache = /* @__PURE__ */ new Map();
+const getDeprecatedTokens = (property, value, context) => {
+	const propertyCategory = require_utils.syncAction("getPropCategory", getSyncOptions(context), property);
+	const tokens = extractTokens(value);
+	if (!propertyCategory && !tokens.length) return [];
+	const values = tokens.length ? tokens : [{
+		category: propertyCategory,
+		value: value.split("/")[0]
+	}];
+	if (deprecatedTokensCache.has(value)) return deprecatedTokensCache.get(value);
+	const deprecatedTokens = require_utils.syncAction("filterDeprecatedTokens", getSyncOptions(context), values);
+	deprecatedTokensCache.set(value, deprecatedTokens);
+	return deprecatedTokens;
+};
+const getTokenImport = (context) => {
+	return _getImports(context).find((imp) => imp.name === "token");
+};
+const getTaggedTemplateCaller = (node) => {
+	if (isIdentifier(node.tag)) return node.tag.name;
+	if (isMemberExpression(node.tag)) {
+		if (!isIdentifier(node.tag.object)) return;
+		return node.tag.object.name;
+	}
+	if (isCallExpression(node.tag)) {
+		if (!isIdentifier(node.tag.callee)) return;
+		return node.tag.callee.name;
+	}
+};
+const isStyledTaggedTemplate = (node, context) => {
+	const caller = getTaggedTemplateCaller(node);
+	if (!caller) return false;
+	return _getImports(context).some((imp) => imp.alias === caller && imp.mod.includes("bamboo")) || isBambooIsh(caller, context);
+};
+function isRecipeVariant(node, context) {
+	const caller = isInBambooFunction(node, context);
+	if (!caller) return;
+	if (!getImports(context).find((imp) => ["cva", "sva"].includes(imp.name) && imp.alias === caller)) return;
+	let currentNode = node;
+	let length = 0;
+	let styleObjectParent = null;
+	while (currentNode) {
+		const keyName = currentNode?.key?.name;
+		if (keyName && ["base", "variants"].includes(keyName)) styleObjectParent = keyName;
+		currentNode = currentNode.parent;
+		if (!styleObjectParent) length++;
+	}
+	if (length < (caller === "cva" ? 2 : 4) + (styleObjectParent === "base" ? 0 : 4)) return true;
+}
+
+//#endregion
+//#region src/rules/file-not-included.ts
+const RULE_NAME$18 = "file-not-included";
+const rule$18 = require_utils.createRule({
+	create(context) {
+		if (isValidFile(context)) return {};
+		let hasReported = false;
+		return { ImportDeclaration(node) {
+			if (hasReported) return;
+			if (!isBambooImport(node, context)) return;
+			context.report({
+				messageId: "include",
+				node
+			});
+			hasReported = true;
+		} };
+	},
+	defaultOptions: [],
+	meta: {
+		docs: { description: "Disallow the use of Bamboo CSS in files that are not included in the specified Bamboo CSS `include` config." },
+		messages: { include: "The use of Bamboo CSS is not allowed in this file. Please ensure the file is included in the Bamboo CSS `include` configuration." },
+		schema: [],
+		type: "problem"
+	},
+	name: RULE_NAME$18
+});
+
+//#endregion
+//#region src/rules/no-config-function-in-source.ts
+const RULE_NAME$17 = "no-config-function-in-source";
+const CONFIG_FUNCTIONS = new Set([
+	"defineConfig",
+	"defineGlobalStyles",
+	"defineKeyframes",
+	"defineLayerStyles",
+	"defineParts",
+	"definePattern",
+	"definePreset",
+	"defineRecipe",
+	"defineSemanticTokens",
+	"defineSlotRecipe",
+	"defineStyles",
+	"defineTextStyles",
+	"defineTokens",
+	"defineUtility"
+]);
+const rule$17 = require_utils.createRule({
+	create(context) {
+		if (!hasPkgImport(context)) return {};
+		if (!isValidFile(context)) return {};
+		return { CallExpression(node) {
+			if (!isIdentifier(node.callee)) return;
+			const functionName = node.callee.name;
+			if (!CONFIG_FUNCTIONS.has(functionName)) return;
+			if (!isBambooConfigFunction(context, functionName)) return;
+			context.report({
+				data: { name: functionName },
+				messageId: "configFunction",
+				node,
+				suggest: [{
+					data: { name: functionName },
+					fix(fixer) {
+						const declaration = getAncestor(isVariableDeclaration, node);
+						const importSpec = getImportSpecifiers(context).find((s) => s.specifier.local.name === functionName);
+						const fixes = [];
+						if (declaration) fixes.push(fixer.remove(declaration));
+						else fixes.push(fixer.remove(node));
+						if (importSpec?.specifier) fixes.push(fixer.remove(importSpec.specifier));
+						return fixes;
+					},
+					messageId: "delete"
+				}]
+			});
+		} };
+	},
+	defaultOptions: [],
+	meta: {
+		docs: { description: "Prohibit the use of config functions outside the Bamboo config file." },
+		hasSuggestions: true,
+		messages: {
+			configFunction: "Unnecessary `{{name}}` call. Config functions should only be used in the Bamboo config file.",
+			delete: "Delete `{{name}}` call."
+		},
+		schema: [],
+		type: "problem"
+	},
+	name: RULE_NAME$17
+});
+
+//#endregion
+//#region src/rules/no-debug.ts
+const RULE_NAME$16 = "no-debug";
+const rule$16 = require_utils.createRule({
+	create(context) {
+		const processedNodes = /* @__PURE__ */ new WeakSet();
+		const checkObjectForDebug = (object) => {
+			for (const property of object.properties) {
+				if (property.type !== "Property") continue;
+				if (!property.key || property.key.type !== "Identifier") continue;
+				if (property.key.name === "debug") {
+					if (processedNodes.has(property)) continue;
+					processedNodes.add(property);
+					context.report({
+						messageId: "debug",
+						node: property.key,
+						suggest: [{
+							fix: (fixer) => fixer.removeRange([property.range[0], property.range[1] + 1]),
+							messageId: "property"
+						}]
+					});
+				}
+				if (property.value && property.value.type === "ObjectExpression") checkObjectForDebug(property.value);
+			}
+		};
+		return {
+			JSXAttribute(node) {
+				if (!isBambooProp(node, context)) return;
+				if (!node.value || !isJSXExpressionContainer(node.value)) return;
+				const expr = node.value.expression;
+				if (!isObjectExpression(expr)) return;
+				checkObjectForDebug(expr);
+			},
+			"JSXAttribute[name.name=\"debug\"]"(node) {
+				if (!isBambooProp(node, context)) return;
+				context.report({
+					messageId: "debug",
+					node,
+					suggest: [{
+						fix: (fixer) => fixer.remove(node),
+						messageId: "prop"
+					}]
+				});
+			},
+			"Property[key.name=\"debug\"]"(node) {
+				if (processedNodes.has(node)) return;
+				if (!isBambooAttribute(node, context)) return;
+				if (isRecipeVariant(node, context)) return;
+				processedNodes.add(node);
+				context.report({
+					messageId: "debug",
+					node: node.key,
+					suggest: [{
+						fix: (fixer) => fixer.removeRange([node.range[0], node.range[1] + 1]),
+						messageId: "property"
+					}]
+				});
+			}
+		};
+	},
+	defaultOptions: [],
+	meta: {
+		docs: { description: "Disallow the inclusion of the debug attribute when shipping code to the production environment." },
+		hasSuggestions: true,
+		messages: {
+			debug: "Unnecessary debug utility.",
+			prop: "Remove the debug prop.",
+			property: "Remove the debug property."
+		},
+		schema: [],
+		type: "problem"
+	},
+	name: RULE_NAME$16
+});
+
+//#endregion
+//#region src/rules/no-deprecated-tokens.ts
+const RULE_NAME$15 = "no-deprecated-tokens";
+const rule$15 = require_utils.createRule({
+	create(context) {
+		const deprecatedTokensCache = /* @__PURE__ */ new Map();
+		const sendReport = (property, node, value) => {
+			if (!value) return;
+			let tokens = deprecatedTokensCache.get(value);
+			if (!tokens) {
+				tokens = getDeprecatedTokens(property, value, context);
+				deprecatedTokensCache.set(value, tokens);
+			}
+			if (!tokens || tokens.length === 0) return;
+			for (const token of tokens) context.report({
+				data: {
+					category: typeof token === "string" ? void 0 : token.category,
+					token: typeof token === "string" ? token : token.value
+				},
+				messageId: typeof token === "string" ? "noDeprecatedTokenPaths" : "noDeprecatedTokens",
+				node
+			});
+		};
+		const handleLiteralOrTemplate = (property, node) => {
+			if (!node) return;
+			if (isLiteral(node)) {
+				const value = node.value?.toString();
+				sendReport(property, node, value);
+			} else if (isTemplateLiteral(node) && node.expressions.length === 0) {
+				const value = node.quasis[0].value.raw;
+				sendReport(property, node.quasis[0], value);
+			}
+		};
+		return {
+			JSXAttribute(node) {
+				if (!node.value || !isBambooProp(node, context)) return;
+				const property = node.name.name;
+				if (isLiteral(node.value)) handleLiteralOrTemplate(property, node.value);
+				else if (isJSXExpressionContainer(node.value)) handleLiteralOrTemplate(property, node.value.expression);
+			},
+			Property(node) {
+				if (!isIdentifier(node.key) || !(0, _typescript_eslint_utils_ast_utils.isNodeOfTypes)([_typescript_eslint_utils.AST_NODE_TYPES.Literal, _typescript_eslint_utils.AST_NODE_TYPES.TemplateLiteral])(node.value) || !isBambooAttribute(node, context) || isRecipeVariant(node, context)) return;
+				const property = node.key.name;
+				handleLiteralOrTemplate(property, node.value);
+			}
+		};
+	},
+	defaultOptions: [],
+	meta: {
+		docs: { description: "Disallow the use of deprecated tokens within token function syntax." },
+		messages: {
+			noDeprecatedTokenPaths: "`{{token}}` is a deprecated token.",
+			noDeprecatedTokens: "`{{token}}` is a deprecated {{category}} token."
+		},
+		schema: [],
+		type: "problem"
+	},
+	name: RULE_NAME$15
+});
+
+//#endregion
+//#region src/rules/no-dynamic-styling.ts
+const RULE_NAME$14 = "no-dynamic-styling";
+const rule$14 = require_utils.createRule({
+	create(context) {
+		function isStaticValue(node) {
+			if (!node) return false;
+			if (isLiteral(node)) return true;
+			if (isTemplateLiteral(node) && node.expressions.length === 0) return true;
+			if (isObjectExpression(node)) return true;
+			return false;
+		}
+		function checkArrayElements(array) {
+			for (const element of array.elements) {
+				if (!element) continue;
+				if (isStaticValue(element)) continue;
+				context.report({
+					messageId: "dynamic",
+					node: element
+				});
+			}
+		}
+		return {
+			JSXAttribute(node) {
+				if (!node.value) return;
+				if (!isBambooProp(node, context)) return;
+				if (isLiteral(node.value)) return;
+				if (isJSXExpressionContainer(node.value)) {
+					const expr = node.value.expression;
+					if (isStaticValue(expr)) return;
+					if (isArrayExpression(expr)) {
+						checkArrayElements(expr);
+						return;
+					}
+					context.report({
+						messageId: "dynamic",
+						node: node.value
+					});
+				}
+			},
+			Property(node) {
+				if (!isIdentifier(node.key)) return;
+				if (!isBambooAttribute(node, context)) return;
+				if (isRecipeVariant(node, context)) return;
+				if (isStaticValue(node.value)) return;
+				if (isArrayExpression(node.value)) {
+					checkArrayElements(node.value);
+					return;
+				}
+				context.report({
+					messageId: "dynamic",
+					node: node.value
+				});
+			},
+			"Property[computed=true]": (node) => {
+				if (!isInBambooFunction(node, context)) return;
+				context.report({
+					messageId: isRecipeVariant(node, context) ? "dynamicRecipeVariant" : "dynamicProperty",
+					node: node.key
+				});
+			}
+		};
+	},
+	defaultOptions: [],
+	meta: {
+		docs: { description: "Ensure users don't use dynamic styling. Prefer static styles, leverage CSS variables, or recipes for known dynamic styles." },
+		messages: {
+			dynamic: "Remove dynamic value. Prefer static styles.",
+			dynamicProperty: "Remove dynamic property. Prefer static style property.",
+			dynamicRecipeVariant: "Remove dynamic variant. Prefer static variant definition."
+		},
+		schema: [],
+		type: "problem"
+	},
+	name: RULE_NAME$14
+});
+
+//#endregion
+//#region src/rules/no-escape-hatch.ts
+const RULE_NAME$13 = "no-escape-hatch";
+const rule$13 = require_utils.createRule({
+	create(context) {
+		const removeBrackets = (range) => {
+			const [start, end] = range;
+			return [start + 1, end - 1];
+		};
+		const hasEscapeHatch = (value) => {
+			if (!value) return false;
+			if (!value.includes("[")) return false;
+			return (0, _bamboocss_shared.getArbitraryValue)(value) !== value.trim();
+		};
+		const handleNodeValue = (node, value) => {
+			if (!hasEscapeHatch(value)) return;
+			context.report({
+				messageId: "escapeHatch",
+				node,
+				suggest: [{
+					fix: (fixer) => {
+						return fixer.replaceTextRange(removeBrackets(node.range), (0, _bamboocss_shared.getArbitraryValue)(value));
+					},
+					messageId: "remove"
+				}]
+			});
+		};
+		return {
+			JSXAttribute(node) {
+				if (!node.value) return;
+				if (!isBambooProp(node, context)) return;
+				const { value } = node;
+				if (isLiteral(value)) handleNodeValue(value, value.value?.toString() ?? "");
+				else if (isJSXExpressionContainer(value)) {
+					const expr = value.expression;
+					if (isLiteral(expr)) handleNodeValue(expr, expr.value?.toString() ?? "");
+					else if (isTemplateLiteral(expr) && expr.expressions.length === 0) {
+						const value_ = expr.quasis[0].value.raw;
+						handleNodeValue(expr.quasis[0], value_);
+					}
+				}
+			},
+			Property(node) {
+				if (!isIdentifier(node.key)) return;
+				if (!isBambooAttribute(node, context)) return;
+				if (isRecipeVariant(node, context)) return;
+				const value = node.value;
+				if (isLiteral(value)) handleNodeValue(value, value.value?.toString() ?? "");
+				else if (isTemplateLiteral(value) && value.expressions.length === 0) {
+					const value_ = value.quasis[0].value.raw;
+					handleNodeValue(value.quasis[0], value_);
+				}
+			}
+		};
+	},
+	defaultOptions: [],
+	meta: {
+		docs: { description: "Prohibit the use of escape hatch syntax in the code." },
+		hasSuggestions: true,
+		messages: {
+			escapeHatch: "Avoid using the escape hatch [value] for undefined tokens. Define a corresponding token in your design system for better consistency and maintainability.",
+			remove: "Remove the square brackets (`[]`)."
+		},
+		schema: [],
+		type: "problem"
+	},
+	name: RULE_NAME$13
+});
+
+//#endregion
+//#region src/rules/no-hardcoded-color.ts
+const RULE_NAME$12 = "no-hardcoded-color";
+const rule$12 = require_utils.createRule({
+	create(context) {
+		const noOpacity = context.options[0]?.noOpacity;
+		const whitelist = context.options[0]?.whitelist ?? [];
+		const colorTokenCache = new Map(whitelist?.map((item) => [item, true]));
+		const colorAttributeCache = /* @__PURE__ */ new Map();
+		const isColorToken$1 = (token) => {
+			if (colorTokenCache.has(token)) return colorTokenCache.get(token);
+			const result = isColorToken(token, context);
+			colorTokenCache.set(token, result);
+			return Boolean(result);
+		};
+		const isColorAttribute$1 = (attribute) => {
+			if (colorAttributeCache.has(attribute)) return colorAttributeCache.get(attribute);
+			const result = isColorAttribute(attribute, context);
+			colorAttributeCache.set(attribute, result);
+			return result;
+		};
+		const isTokenFunctionUsed = (value) => {
+			if (!value) return false;
+			return extractTokens(value).length > 0;
+		};
+		const isValidColorToken = (value) => {
+			if (!value) return false;
+			const [colorToken, opacity] = value.split("/");
+			const hasOpacity = opacity !== void 0 && opacity.length > 0;
+			const isValidToken = isColorToken$1(colorToken);
+			return noOpacity ? isValidToken && !hasOpacity : isValidToken;
+		};
+		const reportInvalidColor = (node, color) => {
+			context.report({
+				data: { color },
+				messageId: "invalidColor",
+				node
+			});
+		};
+		const checkColorValue = (node, value, attributeName) => {
+			if (!isColorAttribute$1(attributeName)) return;
+			if (isTokenFunctionUsed(value)) return;
+			if (isValidColorToken(value)) return;
+			reportInvalidColor(node, value);
+		};
+		return {
+			JSXAttribute(node) {
+				if (!isJSXIdentifier(node.name)) return;
+				if (!isBambooProp(node, context) || !node.value) return;
+				const attributeName = node.name.name;
+				const valueNode = node.value;
+				if (isLiteral(valueNode)) checkColorValue(valueNode, valueNode.value?.toString() || "", attributeName);
+				else if (isJSXExpressionContainer(valueNode)) {
+					const expression = valueNode.expression;
+					if (isLiteral(expression)) checkColorValue(expression, expression.value?.toString() || "", attributeName);
+					else if (isTemplateLiteral(expression) && expression.expressions.length === 0) {
+						const value = expression.quasis[0].value.raw;
+						checkColorValue(expression.quasis[0], value, attributeName);
+					}
+				}
+			},
+			Property(node) {
+				if (!isIdentifier(node.key)) return;
+				if (!isBambooAttribute(node, context)) return;
+				if (isRecipeVariant(node, context)) return;
+				const attributeName = node.key.name;
+				const valueNode = node.value;
+				if (isLiteral(valueNode)) checkColorValue(valueNode, valueNode.value?.toString() || "", attributeName);
+				else if (isTemplateLiteral(valueNode) && valueNode.expressions.length === 0) {
+					const value = valueNode.quasis[0].value.raw;
+					checkColorValue(valueNode.quasis[0], value, attributeName);
+				}
+			}
+		};
+	},
+	defaultOptions: [{
+		noOpacity: false,
+		whitelist: []
+	}],
+	meta: {
+		docs: { description: "Enforce the exclusive use of design tokens as values for colors within the codebase." },
+		messages: { invalidColor: "`{{color}}` is not a valid color token." },
+		schema: [{
+			additionalProperties: false,
+			properties: {
+				noOpacity: { type: "boolean" },
+				whitelist: {
+					items: {
+						minLength: 0,
+						type: "string"
+					},
+					type: "array",
+					uniqueItems: true
+				}
+			},
+			type: "object"
+		}],
+		type: "problem"
+	},
+	name: RULE_NAME$12
+});
+
+//#endregion
+//#region src/rules/no-important.ts
+const exclamationRegex = /\s*!$/;
+const importantRegex = /\s*!important\s*$/;
+const RULE_NAME$11 = "no-important";
+const rule$11 = require_utils.createRule({
+	create(context) {
+		const removeQuotes = (range) => {
+			const [start, end] = range;
+			return [start + 1, end - 1];
+		};
+		const bambooPropertyCache = /* @__PURE__ */ new WeakMap();
+		const bambooAttributeCache = /* @__PURE__ */ new WeakMap();
+		const recipeVariantCache = /* @__PURE__ */ new WeakMap();
+		const isCachedBambooProperty = (node) => {
+			if (bambooPropertyCache.has(node)) return bambooPropertyCache.get(node);
+			const result = isBambooProp(node, context);
+			bambooPropertyCache.set(node, result);
+			return Boolean(result);
+		};
+		const isCachedBambooAttribute = (node) => {
+			if (bambooAttributeCache.has(node)) return bambooAttributeCache.get(node);
+			const result = isBambooAttribute(node, context);
+			bambooAttributeCache.set(node, result);
+			return Boolean(result);
+		};
+		const isCachedRecipeVariant = (node) => {
+			if (recipeVariantCache.has(node)) return recipeVariantCache.get(node);
+			const result = isRecipeVariant(node, context);
+			recipeVariantCache.set(node, result);
+			return Boolean(result);
+		};
+		const hasImportantKeyword = (value) => {
+			if (!value) return false;
+			const arbitraryValue = (0, _bamboocss_shared.getArbitraryValue)(value);
+			return exclamationRegex.test(arbitraryValue) || importantRegex.test(arbitraryValue);
+		};
+		const removeImportantKeyword = (input) => {
+			if (importantRegex.test(input)) return {
+				fixed: input.replace(importantRegex, "").trimEnd(),
+				keyword: "!important"
+			};
+			else if (exclamationRegex.test(input)) return {
+				fixed: input.replace(exclamationRegex, "").trimEnd(),
+				keyword: "!"
+			};
+			else return {
+				fixed: input,
+				keyword: null
+			};
+		};
+		const handleNodeValue = (node, value) => {
+			if (!hasImportantKeyword(value)) return;
+			const { fixed: fixedArbitrary, keyword } = removeImportantKeyword((0, _bamboocss_shared.getArbitraryValue)(value));
+			let fixed = value;
+			if (value.startsWith("[") && value.endsWith("]")) fixed = `[${fixedArbitrary}]`;
+			else fixed = fixedArbitrary;
+			context.report({
+				data: { keyword },
+				messageId: "important",
+				node,
+				suggest: [{
+					data: { keyword },
+					fix: (fixer) => {
+						return fixer.replaceTextRange(removeQuotes(node.range), fixed);
+					},
+					messageId: "remove"
+				}]
+			});
+		};
+		return {
+			JSXAttribute(node) {
+				if (!node.value) return;
+				if (!isCachedBambooProperty(node)) return;
+				const valueNode = node.value;
+				if (isLiteral(valueNode)) handleNodeValue(valueNode, valueNode.value?.toString() ?? "");
+				else if (isJSXExpressionContainer(valueNode)) {
+					const expr = valueNode.expression;
+					if (isLiteral(expr)) handleNodeValue(expr, expr.value?.toString() ?? "");
+					else if (isTemplateLiteral(expr) && expr.expressions.length === 0) {
+						const value = expr.quasis[0].value.raw;
+						handleNodeValue(expr.quasis[0], value);
+					}
+				}
+			},
+			Property(node) {
+				if (!isIdentifier(node.key)) return;
+				if (!isCachedBambooAttribute(node)) return;
+				if (isCachedRecipeVariant(node)) return;
+				const valueNode = node.value;
+				if (isLiteral(valueNode)) handleNodeValue(valueNode, valueNode.value?.toString() ?? "");
+				else if (isTemplateLiteral(valueNode) && valueNode.expressions.length === 0) {
+					const value = valueNode.quasis[0].value.raw;
+					handleNodeValue(valueNode.quasis[0], value);
+				}
+			}
+		};
+	},
+	defaultOptions: [],
+	meta: {
+		docs: { description: "Disallow usage of !important keyword. Prioritize specificity for a maintainable and predictable styling structure." },
+		hasSuggestions: true,
+		messages: {
+			important: "Avoid using the {{keyword}} keyword. Refactor your code to prioritize specificity for predictable styling.",
+			remove: "Remove the `{{keyword}}` keyword."
+		},
+		schema: [],
+		type: "problem"
+	},
+	name: RULE_NAME$11
+});
+
+//#endregion
+//#region src/rules/no-invalid-nesting.ts
+const RULE_NAME$10 = "no-invalid-nesting";
+const rule$10 = require_utils.createRule({
+	create(context) {
+		const bambooFunctionCache = /* @__PURE__ */ new WeakMap();
+		const jsxPropertyCache = /* @__PURE__ */ new WeakMap();
+		const recipeVariantCache = /* @__PURE__ */ new WeakMap();
+		const styledPropertyCache = /* @__PURE__ */ new WeakMap();
+		const isCachedInBambooFunction = (node) => {
+			if (bambooFunctionCache.has(node)) return bambooFunctionCache.get(node);
+			const result = Boolean(isInBambooFunction(node, context));
+			bambooFunctionCache.set(node, result);
+			return Boolean(result);
+		};
+		const isCachedInJSXProperty = (node) => {
+			if (jsxPropertyCache.has(node)) return jsxPropertyCache.get(node);
+			const result = isInJSXProp(node, context);
+			jsxPropertyCache.set(node, result);
+			return Boolean(result);
+		};
+		const isCachedRecipeVariant = (node) => {
+			if (recipeVariantCache.has(node)) return recipeVariantCache.get(node);
+			const result = isRecipeVariant(node, context);
+			recipeVariantCache.set(node, result);
+			return Boolean(result);
+		};
+		const isCachedStyledProperty = (node) => {
+			if (styledPropertyCache.has(node)) return styledPropertyCache.get(node);
+			const result = isStyledProperty(node, context);
+			styledPropertyCache.set(node, result);
+			return Boolean(result);
+		};
+		const isInvalidNestingSelector = (node) => {
+			if (isLiteral(node) && typeof node.value === "string") return !node.value.includes("&");
+			else if (isTemplateLiteral(node) && node.expressions.length === 0) return !node.quasis[0].value.raw.includes("&");
+			return false;
+		};
+		return { "Property[key.type!=/Identifier/][value.type=\"ObjectExpression\"]"(node) {
+			const inBambooFunction = isCachedInBambooFunction(node);
+			const inJSXProperty = isCachedInJSXProperty(node);
+			if (!inBambooFunction && !inJSXProperty) return;
+			if (isCachedRecipeVariant(node)) return;
+			if (isCachedStyledProperty(node)) return;
+			const keyNode = node.key;
+			if (isInvalidNestingSelector(keyNode)) context.report({
+				messageId: "nesting",
+				node: keyNode
+			});
+		} };
+	},
+	defaultOptions: [],
+	meta: {
+		docs: { description: "Warn against invalid nesting. Nested styles must contain the `&` character." },
+		messages: { nesting: "Invalid style nesting. Nested styles must contain the `&` character." },
+		schema: [],
+		type: "problem"
+	},
+	name: RULE_NAME$10
+});
+
+//#endregion
+//#region src/rules/no-invalid-token-paths.ts
+const RULE_NAME$9 = "no-invalid-token-paths";
+const rule$9 = require_utils.createRule({
+	create(context) {
+		const invalidTokensCache = /* @__PURE__ */ new Map();
+		const sendReport = (node, value) => {
+			if (!value) return;
+			let tokens = invalidTokensCache.get(value);
+			if (!tokens) {
+				tokens = getInvalidTokens(value, context);
+				invalidTokensCache.set(value, tokens);
+			}
+			if (!tokens || tokens.length === 0) return;
+			for (const token of tokens) context.report({
+				data: { token },
+				messageId: "noInvalidTokenPaths",
+				node
+			});
+		};
+		const handleLiteralOrTemplate = (node) => {
+			if (!node) return;
+			if (isLiteral(node)) {
+				const value = node.value?.toString();
+				sendReport(node, value);
+			} else if (isTemplateLiteral(node) && node.expressions.length === 0) {
+				const value = node.quasis[0].value.raw;
+				sendReport(node.quasis[0], value);
+			}
+		};
+		return {
+			JSXAttribute(node) {
+				if (!node.value || !isBambooProp(node, context)) return;
+				if (isLiteral(node.value)) handleLiteralOrTemplate(node.value);
+				else if (isJSXExpressionContainer(node.value)) handleLiteralOrTemplate(node.value.expression);
+			},
+			Property(node) {
+				if (!isIdentifier(node.key) || !(0, _typescript_eslint_utils_ast_utils.isNodeOfTypes)([_typescript_eslint_utils.AST_NODE_TYPES.Literal, _typescript_eslint_utils.AST_NODE_TYPES.TemplateLiteral])(node.value) || !isBambooAttribute(node, context) || isRecipeVariant(node, context)) return;
+				handleLiteralOrTemplate(node.value);
+			},
+			TaggedTemplateExpression(node) {
+				if (!getTaggedTemplateCaller(node)) return;
+				if (!isStyledTaggedTemplate(node, context)) return;
+				const quasis = node.quasi.quasis;
+				for (const quasi of quasis) {
+					const styles = quasi.value.raw;
+					if (!styles) continue;
+					let tokens = invalidTokensCache.get(styles);
+					if (!tokens) {
+						tokens = getInvalidTokens(styles, context);
+						invalidTokensCache.set(styles, tokens);
+					}
+					if (!tokens || tokens.length === 0) continue;
+					for (const token of tokens) {
+						let index = styles.indexOf(token);
+						while (index !== -1) {
+							const start = quasi.range[0] + index + 1;
+							const end = start + token.length;
+							context.report({
+								data: { token },
+								loc: {
+									end: context.sourceCode.getLocFromIndex(end),
+									start: context.sourceCode.getLocFromIndex(start)
+								},
+								messageId: "noInvalidTokenPaths"
+							});
+							index = styles.indexOf(token, index + token.length);
+						}
+					}
+				}
+			}
+		};
+	},
+	defaultOptions: [],
+	meta: {
+		docs: { description: "Disallow the use of invalid token paths within token function syntax." },
+		messages: { noInvalidTokenPaths: "`{{token}}` is an invalid token path." },
+		schema: [],
+		type: "problem"
+	},
+	name: RULE_NAME$9
+});
+
+//#endregion
+//#region src/rules/no-margin-properties.ts
+const RULE_NAME$8 = "no-margin-properties";
+const rule$8 = require_utils.createRule({
+	create(context) {
+		const whitelist = context.options[0]?.whitelist ?? [];
+		const longhandCache = /* @__PURE__ */ new Map();
+		const getLonghand = (name) => {
+			if (longhandCache.has(name)) return longhandCache.get(name);
+			const longhand = resolveLonghand(name, context) ?? name;
+			longhandCache.set(name, longhand);
+			return longhand;
+		};
+		const marginRegex = /margin/i;
+		const isMarginProperty = (name) => {
+			const longhand = getLonghand(name).toLowerCase();
+			return marginRegex.test(longhand);
+		};
+		const sendReport = (node) => {
+			if (whitelist.includes(node.name)) return;
+			if (!isMarginProperty(node.name)) return;
+			context.report({
+				messageId: "noMargin",
+				node
+			});
+		};
+		const bambooPropertyCache = /* @__PURE__ */ new WeakMap();
+		const isCachedBambooProperty = (node) => {
+			if (bambooPropertyCache.has(node)) return bambooPropertyCache.get(node);
+			const result = isBambooProp(node, context);
+			bambooPropertyCache.set(node, result);
+			return Boolean(result);
+		};
+		const bambooAttributeCache = /* @__PURE__ */ new WeakMap();
+		const isCachedBambooAttribute = (node) => {
+			if (bambooAttributeCache.has(node)) return bambooAttributeCache.get(node);
+			const result = isBambooAttribute(node, context);
+			bambooAttributeCache.set(node, result);
+			return Boolean(result);
+		};
+		const recipeVariantCache = /* @__PURE__ */ new WeakMap();
+		const isCachedRecipeVariant = (node) => {
+			if (recipeVariantCache.has(node)) return recipeVariantCache.get(node);
+			const result = isRecipeVariant(node, context);
+			recipeVariantCache.set(node, result);
+			return Boolean(result);
+		};
+		return {
+			JSXAttribute(node) {
+				if (!isJSXIdentifier(node.name)) return;
+				if (!isCachedBambooProperty(node)) return;
+				sendReport(node.name);
+			},
+			Property(node) {
+				if (!isIdentifier(node.key)) return;
+				if (!isCachedBambooAttribute(node)) return;
+				if (isCachedRecipeVariant(node)) return;
+				sendReport(node.key);
+			}
+		};
+	},
+	defaultOptions: [{ whitelist: [] }],
+	meta: {
+		docs: { description: "Discourage using margin properties for spacing; prefer defining spacing in parent elements with `flex` or `grid` using the `gap` property for a more resilient layout. Margins make components less reusable in other contexts." },
+		messages: { noMargin: "Use flex or grid with the `gap` property to define spacing in parent elements for a more resilient layout." },
+		schema: [{
+			additionalProperties: false,
+			properties: { whitelist: {
+				items: {
+					minLength: 0,
+					type: "string"
+				},
+				type: "array",
+				uniqueItems: true
+			} },
+			type: "object"
+		}],
+		type: "suggestion"
+	},
+	name: RULE_NAME$8
+});
+
+//#endregion
+//#region src/utils/physical-properties.ts
+const physicalProperties = {
+	borderBottom: "borderBlockEnd",
+	borderBottomColor: "borderBlockEndColor",
+	borderBottomLeftRadius: "borderEndStartRadius",
+	borderBottomRightRadius: "borderEndEndRadius",
+	borderBottomStyle: "borderBlockEndStyle",
+	borderBottomWidth: "borderBlockEndWidth",
+	borderLeft: "borderInlineStart",
+	borderLeftColor: "borderInlineStartColor",
+	borderLeftStyle: "borderInlineStartStyle",
+	borderLeftWidth: "borderInlineStartWidth",
+	borderRight: "borderInlineEnd",
+	borderRightColor: "borderInlineEndColor",
+	borderRightStyle: "borderInlineEndStyle",
+	borderRightWidth: "borderInlineEndWidth",
+	borderTop: "borderBlockStart",
+	borderTopColor: "borderBlockStartColor",
+	borderTopLeftRadius: "borderStartStartRadius",
+	borderTopRightRadius: "borderStartEndRadius",
+	borderTopStyle: "borderBlockStartStyle",
+	borderTopWidth: "borderBlockStartWidth",
+	bottom: "insetBlockEnd",
+	left: "insetInlineStart",
+	marginBottom: "marginBlockEnd",
+	marginLeft: "marginInlineStart",
+	marginRight: "marginInlineEnd",
+	marginTop: "marginBlockStart",
+	paddingBottom: "paddingBlockEnd",
+	paddingLeft: "paddingInlineStart",
+	paddingRight: "paddingInlineEnd",
+	paddingTop: "paddingBlockStart",
+	right: "insetInlineEnd",
+	top: "insetBlockStart"
+};
+const physicalPropertyValues = { textAlign: {
+	left: "start",
+	right: "end"
+} };
+
+//#endregion
+//#region src/rules/no-physical-properties.ts
+const RULE_NAME$7 = "no-physical-properties";
+const MESSAGES = {
+	physical: "Use logical property instead of {{physical}}. Prefer `{{logical}}`.",
+	physicalValue: "Use logical value instead of {{physical}}. Prefer `{{logical}}`.",
+	replace: "Replace `{{physical}}` with `{{logical}}`."
+};
+var PropertyCache = class {
+	longhandCache = /* @__PURE__ */ new Map();
+	bambooAttributeCache = /* @__PURE__ */ new WeakMap();
+	bambooPropCache = /* @__PURE__ */ new WeakMap();
+	recipeVariantCache = /* @__PURE__ */ new WeakMap();
+	getLonghand(name, context) {
+		if (this.longhandCache.has(name)) return this.longhandCache.get(name);
+		const longhand = resolveLonghand(name, context) ?? name;
+		this.longhandCache.set(name, longhand);
+		return longhand;
+	}
+	isBambooAttribute(node, context) {
+		if (this.bambooAttributeCache.has(node)) return this.bambooAttributeCache.get(node);
+		const result = isBambooAttribute(node, context);
+		this.bambooAttributeCache.set(node, result);
+		return Boolean(result);
+	}
+	isBambooProp(node, context) {
+		if (this.bambooPropCache.has(node)) return this.bambooPropCache.get(node);
+		const result = isBambooProp(node, context);
+		this.bambooPropCache.set(node, result);
+		return Boolean(result);
+	}
+	isRecipeVariant(node, context) {
+		if (this.recipeVariantCache.has(node)) return this.recipeVariantCache.get(node);
+		const result = isRecipeVariant(node, context);
+		this.recipeVariantCache.set(node, result);
+		return Boolean(result);
+	}
+};
+const extractStringLiteralValue = (valueNode) => {
+	if (isLiteral(valueNode) && typeof valueNode.value === "string") return valueNode.value;
+	if (isJSXExpressionContainer(valueNode) && isLiteral(valueNode.expression) && typeof valueNode.expression.value === "string") return valueNode.expression.value;
+	return null;
+};
+const createPropertyReport = (node, longhandName, logical, context) => {
+	const physicalName = `\`${node.name}\`${longhandName !== node.name ? ` (resolved to \`${longhandName}\`)` : ""}`;
+	context.report({
+		data: {
+			logical,
+			physical: physicalName
+		},
+		messageId: "physical",
+		node,
+		suggest: [{
+			data: {
+				logical,
+				physical: node.name
+			},
+			fix: (fixer) => fixer.replaceText(node, logical),
+			messageId: "replace"
+		}]
+	});
+};
+const createValueReport = (valueNode, valueText, logical, context) => {
+	context.report({
+		data: {
+			logical: `"${logical}"`,
+			physical: `"${valueText}"`
+		},
+		messageId: "physicalValue",
+		node: valueNode,
+		suggest: [{
+			data: {
+				logical: `"${logical}"`,
+				physical: `"${valueText}"`
+			},
+			fix: (fixer) => {
+				if (isLiteral(valueNode)) return fixer.replaceText(valueNode, `"${logical}"`);
+				if (isJSXExpressionContainer(valueNode) && isLiteral(valueNode.expression)) return fixer.replaceText(valueNode.expression, `"${logical}"`);
+				return null;
+			},
+			messageId: "replace"
+		}]
+	});
+};
+const rule$7 = require_utils.createRule({
+	create(context) {
+		const whitelist = context.options[0]?.whitelist ?? [];
+		const cache = new PropertyCache();
+		const checkPropertyName = (node) => {
+			if (whitelist.includes(node.name)) return;
+			const longhandName = cache.getLonghand(node.name, context);
+			if (!(longhandName in physicalProperties)) return;
+			const logical = physicalProperties[longhandName];
+			createPropertyReport(node, longhandName, logical, context);
+		};
+		const checkPropertyValue = (keyNode, valueNode) => {
+			const propertyName = keyNode.name;
+			if (!(propertyName in physicalPropertyValues)) return false;
+			const valueText = extractStringLiteralValue(valueNode);
+			if (valueText === null) return false;
+			const valueMap = physicalPropertyValues[propertyName];
+			if (!valueMap[valueText]) return false;
+			createValueReport(valueNode, valueText, valueMap[valueText], context);
+			return true;
+		};
+		return {
+			JSXAttribute(node) {
+				if (!isJSXIdentifier(node.name)) return;
+				if (!cache.isBambooProp(node, context)) return;
+				checkPropertyName(node.name);
+				if (node.value) checkPropertyValue(node.name, node.value);
+			},
+			Property(node) {
+				if (!isIdentifier(node.key)) return;
+				if (!cache.isBambooAttribute(node, context)) return;
+				if (cache.isRecipeVariant(node, context)) return;
+				checkPropertyName(node.key);
+				if (node.value) checkPropertyValue(node.key, node.value);
+			}
+		};
+	},
+	defaultOptions: [{ whitelist: [] }],
+	meta: {
+		docs: { description: "Encourage the use of logical properties over physical properties to foster a responsive and adaptable user interface." },
+		hasSuggestions: true,
+		messages: MESSAGES,
+		schema: [{
+			additionalProperties: false,
+			properties: { whitelist: {
+				items: {
+					minLength: 0,
+					type: "string"
+				},
+				type: "array",
+				uniqueItems: true
+			} },
+			type: "object"
+		}],
+		type: "suggestion"
+	},
+	name: RULE_NAME$7
+});
+
+//#endregion
+//#region src/rules/no-property-renaming.ts
+const RULE_NAME$6 = "no-property-renaming";
+const rule$6 = require_utils.createRule({
+	create(context) {
+		const bambooPropertyCache = /* @__PURE__ */ new WeakMap();
+		const bambooAttributeCache = /* @__PURE__ */ new WeakMap();
+		const recipeVariantCache = /* @__PURE__ */ new WeakMap();
+		const isCachedBambooProperty = (node) => {
+			if (bambooPropertyCache.has(node)) return bambooPropertyCache.get(node);
+			const result = isBambooProp(node, context);
+			bambooPropertyCache.set(node, result);
+			return Boolean(result);
+		};
+		const isCachedBambooAttribute = (node) => {
+			if (bambooAttributeCache.has(node)) return bambooAttributeCache.get(node);
+			const result = isBambooAttribute(node, context);
+			bambooAttributeCache.set(node, result);
+			return Boolean(result);
+		};
+		const isCachedRecipeVariant = (node) => {
+			if (recipeVariantCache.has(node)) return recipeVariantCache.get(node);
+			const result = isRecipeVariant(node, context);
+			recipeVariantCache.set(node, result);
+			return Boolean(result);
+		};
+		const sendReport = (node, expected, property) => {
+			context.report({
+				data: {
+					expected,
+					prop: property
+				},
+				messageId: "noRenaming",
+				node
+			});
+		};
+		const handleReport = (node, value, attribute) => {
+			if (isIdentifier(value) && attribute !== value.name) sendReport(node, attribute, value.name);
+			else if (isMemberExpression(value) && isIdentifier(value.property) && attribute !== value.property.name) sendReport(node, attribute, value.property.name);
+		};
+		return {
+			JSXAttribute(node) {
+				if (!node.value) return;
+				if (!isJSXExpressionContainer(node.value)) return;
+				if (!isCachedBambooProperty(node)) return;
+				const attribute = node.name.name.toString();
+				const expression = node.value.expression;
+				handleReport(node.value, expression, attribute);
+			},
+			Property(node) {
+				if (!isIdentifier(node.key)) return;
+				if (!isIdentifier(node.value) && !isMemberExpression(node.value)) return;
+				if (!isCachedBambooAttribute(node)) return;
+				if (isCachedRecipeVariant(node)) return;
+				const attribute = node.key.name;
+				const value = node.value;
+				handleReport(node.value, value, attribute);
+			}
+		};
+	},
+	defaultOptions: [],
+	meta: {
+		docs: { description: "Ensure that properties for patterns or style props are not renamed, as it prevents proper tracking." },
+		messages: { noRenaming: "Incoming `{{prop}}` prop is different from the expected `{{expected}}` attribute. Bamboo will not track this prop." },
+		schema: [],
+		type: "problem"
+	},
+	name: RULE_NAME$6
+});
+
+//#endregion
+//#region src/rules/no-unsafe-token-fn-usage.ts
+const RULE_NAME$5 = "no-unsafe-token-fn-usage";
+const rule$5 = require_utils.createRule({
+	create(context) {
+		let tokenImportCache;
+		const getCachedTokenImport = () => {
+			if (tokenImportCache !== void 0) return tokenImportCache;
+			tokenImportCache = getTokenImport(context);
+			return tokenImportCache;
+		};
+		const isUnsafeCallExpression = (node) => {
+			const tkImport = getCachedTokenImport();
+			return isIdentifier(node.callee) && node.callee.name === tkImport?.alias;
+		};
+		const tokenWrap = (value) => value ? `token(${value})` : "";
+		const isCompositeValue = (input) => {
+			if (!input) return false;
+			return !/^(?:token\([^)]*\)|\{[^}]*\})$/.test(input);
+		};
+		const sendReport = (node, value) => {
+			const tkImports = extractTokens(value);
+			if (!tkImports.length) return;
+			const token = tkImports[0].replace(/^[^.]*\./, "");
+			context.report({
+				messageId: "noUnsafeTokenFnUsage",
+				node,
+				suggest: [{
+					data: { safe: token },
+					fix: (fixer) => fixer.replaceText(node, `'${token}'`),
+					messageId: "replace"
+				}]
+			});
+		};
+		const handleRuntimeFunction = (node) => {
+			if (!isCallExpression(node)) return;
+			if (!isUnsafeCallExpression(node)) return;
+			const value = node.arguments[0];
+			if (isLiteral(value)) sendReport(node, tokenWrap((0, _bamboocss_shared.getArbitraryValue)(value.value?.toString() ?? "")));
+			else if (isTemplateLiteral(value) && value.expressions.length === 0) sendReport(node, tokenWrap((0, _bamboocss_shared.getArbitraryValue)(value.quasis[0].value.raw)));
+		};
+		const handleLiteral = (node) => {
+			if (!isLiteral(node)) return;
+			const value = (0, _bamboocss_shared.getArbitraryValue)(node.value?.toString() ?? "");
+			if (isCompositeValue(value)) return;
+			sendReport(node, value);
+		};
+		const handleTemplateLiteral = (node) => {
+			if (!isTemplateLiteral(node) || node.expressions.length > 0) return;
+			const value = (0, _bamboocss_shared.getArbitraryValue)(node.quasis[0].value.raw);
+			if (isCompositeValue(value)) return;
+			sendReport(node, value);
+		};
+		const bambooPropertyCache = /* @__PURE__ */ new WeakMap();
+		const isCachedBambooProperty = (node) => {
+			if (bambooPropertyCache.has(node)) return bambooPropertyCache.get(node);
+			const result = isBambooProp(node, context);
+			bambooPropertyCache.set(node, result);
+			return Boolean(result);
+		};
+		const bambooAttributeCache = /* @__PURE__ */ new WeakMap();
+		const isCachedBambooAttribute = (node) => {
+			if (bambooAttributeCache.has(node)) return bambooAttributeCache.get(node);
+			const result = isBambooAttribute(node, context);
+			bambooAttributeCache.set(node, result);
+			return Boolean(result);
+		};
+		const recipeVariantCache = /* @__PURE__ */ new WeakMap();
+		const isCachedRecipeVariant = (node) => {
+			if (recipeVariantCache.has(node)) return recipeVariantCache.get(node);
+			const result = isRecipeVariant(node, context);
+			recipeVariantCache.set(node, result);
+			return Boolean(result);
+		};
+		return {
+			JSXAttribute(node) {
+				if (!node.value) return;
+				if (!isCachedBambooProperty(node)) return;
+				handleLiteral(node.value);
+				if (isJSXExpressionContainer(node.value)) {
+					const expression = node.value.expression;
+					handleLiteral(expression);
+					handleTemplateLiteral(expression);
+					handleRuntimeFunction(expression);
+				}
+			},
+			Property(node) {
+				if (!isCachedBambooAttribute(node)) return;
+				if (isCachedRecipeVariant(node)) return;
+				const valueNode = node.value;
+				if (isCallExpression(valueNode) || isLiteral(valueNode) || isTemplateLiteral(valueNode)) {
+					handleRuntimeFunction(valueNode);
+					handleLiteral(valueNode);
+					handleTemplateLiteral(valueNode);
+				}
+			}
+		};
+	},
+	defaultOptions: [],
+	meta: {
+		docs: { description: "Prevent users from using the token function in situations where they could simply use the raw design token." },
+		hasSuggestions: true,
+		messages: {
+			noUnsafeTokenFnUsage: "Unnecessary token function usage. Prefer design token.",
+			replace: "Replace token function with `{{safe}}`."
+		},
+		schema: [],
+		type: "suggestion"
+	},
+	name: RULE_NAME$5
+});
+
+//#endregion
+//#region src/utils/composite-properties.ts
+const compositeProperties = {
+	animation: [
+		"animationName",
+		"animationDuration",
+		"animationTimingFunction",
+		"animationDelay",
+		"animationIterationCount",
+		"animationDirection",
+		"animationFillMode",
+		"animationPlayState"
+	],
+	background: [
+		"backgroundImage",
+		"backgroundPosition",
+		"backgroundSize",
+		"backgroundRepeat",
+		"backgroundAttachment",
+		"backgroundOrigin",
+		"backgroundClip",
+		"backgroundColor"
+	],
+	backgroundPosition: ["backgroundPositionX", "backgroundPositionY"],
+	border: [
+		"borderWidth",
+		"borderStyle",
+		"borderColor"
+	],
+	borderBlockEnd: [
+		"borderBlockEndWidth",
+		"borderBlockEndStyle",
+		"borderBlockEndColor"
+	],
+	borderBlockStart: [
+		"borderBlockStartWidth",
+		"borderBlockStartStyle",
+		"borderBlockStartColor"
+	],
+	borderBottom: [
+		"borderBottomWidth",
+		"borderBottomStyle",
+		"borderBottomColor"
+	],
+	borderColor: [
+		"borderTopColor",
+		"borderRightColor",
+		"borderBottomColor",
+		"borderLeftColor"
+	],
+	borderImage: [
+		"borderImageSource",
+		"borderImageSlice",
+		"borderImageWidth",
+		"borderImageOutset",
+		"borderImageRepeat"
+	],
+	borderInlineEnd: [
+		"borderInlineEndWidth",
+		"borderInlineEndStyle",
+		"borderInlineEndColor"
+	],
+	borderInlineStart: [
+		"borderInlineStartWidth",
+		"borderInlineStartStyle",
+		"borderInlineStartColor"
+	],
+	borderLeft: [
+		"borderLeftWidth",
+		"borderLeftStyle",
+		"borderLeftColor"
+	],
+	borderRadius: [
+		"borderTopLeftRadius",
+		"borderTopRightRadius",
+		"borderBottomRightRadius",
+		"borderBottomLeftRadius"
+	],
+	borderRight: [
+		"borderRightWidth",
+		"borderRightStyle",
+		"borderRightColor"
+	],
+	borderStyle: [
+		"borderTopStyle",
+		"borderRightStyle",
+		"borderBottomStyle",
+		"borderLeftStyle"
+	],
+	borderTop: [
+		"borderTopWidth",
+		"borderTopStyle",
+		"borderTopColor"
+	],
+	borderWidth: [
+		"borderTopWidth",
+		"borderRightWidth",
+		"borderBottomWidth",
+		"borderLeftWidth"
+	],
+	columnRule: [
+		"columnRuleWidth",
+		"columnRuleStyle",
+		"columnRuleColor"
+	],
+	columns: ["columnWidth", "columnCount"],
+	container: ["contain", "content"],
+	containIntrinsicSize: ["containIntrinsicSizeInline", "containIntrinsicSizeBlock"],
+	cue: ["cueBefore", "cueAfter"],
+	flex: [
+		"flexGrow",
+		"flexShrink",
+		"flexBasis"
+	],
+	flexFlow: ["flexDirection", "flexWrap"],
+	font: [
+		"fontStyle",
+		"fontVariantCaps",
+		"fontVariantEastAsian",
+		"fontVariantLigatures",
+		"fontVariantNumeric",
+		"fontVariantPosition",
+		"fontWeight",
+		"fontStretch",
+		"fontSize",
+		"lineHeight",
+		"fontFamily"
+	],
+	fontSynthesis: [
+		"fontSynthesisWeight",
+		"fontSynthesisStyle",
+		"fontSynthesisSmallCaps"
+	],
+	fontVariant: [
+		"fontVariantCaps",
+		"fontVariantEastAsian",
+		"fontVariantLigatures",
+		"fontVariantNumeric",
+		"fontVariantPosition"
+	],
+	gap: ["columnGap", "rowGap"],
+	grid: [
+		"gridTemplateColumns",
+		"gridTemplateRows",
+		"gridTemplateAreas",
+		"gridAutoColumns",
+		"gridAutoRows",
+		"gridAutoFlow"
+	],
+	gridArea: [
+		"gridRowStart",
+		"gridColumnStart",
+		"gridRowEnd",
+		"gridColumnEnd"
+	],
+	gridColumn: ["gridColumnStart", "gridColumnEnd"],
+	gridGap: ["gridColumnGap", "gridRowGap"],
+	gridRow: ["gridRowStart", "gridRowEnd"],
+	gridTemplate: [
+		"gridTemplateColumns",
+		"gridTemplateRows",
+		"gridTemplateAreas"
+	],
+	inset: [
+		"top",
+		"right",
+		"bottom",
+		"left"
+	],
+	listStyle: [
+		"listStyleType",
+		"listStylePosition",
+		"listStyleImage"
+	],
+	margin: [
+		"marginTop",
+		"marginRight",
+		"marginBottom",
+		"marginLeft"
+	],
+	mask: [
+		"maskImage",
+		"maskMode",
+		"maskRepeat",
+		"maskPosition",
+		"maskClip",
+		"maskOrigin",
+		"maskSize",
+		"maskComposite"
+	],
+	maskBorder: [
+		"maskBorderSource",
+		"maskBorderMode",
+		"maskBorderSlice",
+		"maskBorderWidth",
+		"maskBorderOutset",
+		"maskBorderRepeat"
+	],
+	offset: [
+		"offsetPosition",
+		"offsetPath",
+		"offsetDistance",
+		"offsetRotate",
+		"offsetAnchor"
+	],
+	outline: [
+		"outlineWidth",
+		"outlineStyle",
+		"outlineColor"
+	],
+	overflow: ["overflowX", "overflowY"],
+	padding: [
+		"paddingTop",
+		"paddingRight",
+		"paddingBottom",
+		"paddingLeft"
+	],
+	pause: ["pauseBefore", "pauseAfter"],
+	placeContent: ["alignContent", "justifyContent"],
+	placeItems: ["alignItems", "justifyItems"],
+	placeSelf: ["alignSelf", "justifySelf"],
+	rest: ["restBefore", "restAfter"],
+	scrollMargin: [
+		"scrollMarginTop",
+		"scrollMarginRight",
+		"scrollMarginBottom",
+		"scrollMarginLeft"
+	],
+	scrollPadding: [
+		"scrollPaddingTop",
+		"scrollPaddingRight",
+		"scrollPaddingBottom",
+		"scrollPaddingLeft"
+	],
+	scrollPaddingBlock: ["scrollPaddingBlockStart", "scrollPaddingBlockEnd"],
+	scrollPaddingInline: ["scrollPaddingInlineStart", "scrollPaddingInlineEnd"],
+	scrollSnapMargin: [
+		"scrollSnapMarginTop",
+		"scrollSnapMarginRight",
+		"scrollSnapMarginBottom",
+		"scrollSnapMarginLeft"
+	],
+	scrollSnapMarginBlock: ["scrollSnapMarginBlockStart", "scrollSnapMarginBlockEnd"],
+	scrollSnapMarginInline: ["scrollSnapMarginInlineStart", "scrollSnapMarginInlineEnd"],
+	scrollTimeline: ["scrollTimelineSource", "scrollTimelineOrientation"],
+	textDecoration: [
+		"textDecorationLine",
+		"textDecorationStyle",
+		"textDecorationColor"
+	],
+	textEmphasis: ["textEmphasisStyle", "textEmphasisColor"],
+	transition: [
+		"transitionProperty",
+		"transitionDuration",
+		"transitionTimingFunction",
+		"transitionDelay"
+	]
+};
+
+//#endregion
+//#region src/rules/prefer-atomic-properties.ts
+const RULE_NAME$4 = "prefer-atomic-properties";
+const rule$4 = require_utils.createRule({
+	create(context) {
+		const whitelist = context.options[0]?.whitelist ?? [];
+		const longhandCache = /* @__PURE__ */ new Map();
+		const getLonghand = (name) => {
+			if (longhandCache.has(name)) return longhandCache.get(name);
+			const longhand = resolveLonghand(name, context) ?? name;
+			longhandCache.set(name, longhand);
+			return longhand;
+		};
+		const compositePropertyCache = /* @__PURE__ */ new Map();
+		const resolveCompositeProperty = (name) => {
+			if (compositePropertyCache.has(name)) return compositePropertyCache.get(name);
+			if (Object.hasOwn(compositeProperties, name)) {
+				compositePropertyCache.set(name, name);
+				return name;
+			}
+			const longhand = getLonghand(name);
+			if (isValidProperty(longhand, context) && Object.hasOwn(compositeProperties, longhand)) {
+				compositePropertyCache.set(name, longhand);
+				return longhand;
+			}
+			compositePropertyCache.set(name, void 0);
+		};
+		const bambooPropertyCache = /* @__PURE__ */ new WeakMap();
+		const isCachedBambooProperty = (node) => {
+			if (bambooPropertyCache.has(node)) return bambooPropertyCache.get(node);
+			const result = isBambooProp(node, context);
+			bambooPropertyCache.set(node, result);
+			return Boolean(result);
+		};
+		const bambooAttributeCache = /* @__PURE__ */ new WeakMap();
+		const isCachedBambooAttribute = (node) => {
+			if (bambooAttributeCache.has(node)) return bambooAttributeCache.get(node);
+			const result = isBambooAttribute(node, context);
+			bambooAttributeCache.set(node, result);
+			return Boolean(result);
+		};
+		const recipeVariantCache = /* @__PURE__ */ new WeakMap();
+		const isCachedRecipeVariant = (node) => {
+			if (recipeVariantCache.has(node)) return recipeVariantCache.get(node);
+			const result = isRecipeVariant(node, context);
+			recipeVariantCache.set(node, result);
+			return Boolean(result);
+		};
+		const sendReport = (node, composite) => {
+			if (whitelist.includes(node.name)) return;
+			const atomics = compositeProperties[composite].map((name) => `\`${name}\``).join(",\n");
+			context.report({
+				data: {
+					atomics,
+					composite: node.name
+				},
+				messageId: "atomic",
+				node
+			});
+		};
+		return {
+			JSXAttribute(node) {
+				if (!isJSXIdentifier(node.name)) return;
+				if (!isCachedBambooProperty(node)) return;
+				const composite = resolveCompositeProperty(node.name.name);
+				if (!composite) return;
+				sendReport(node.name, composite);
+			},
+			Property(node) {
+				if (!isIdentifier(node.key)) return;
+				if (!isCachedBambooAttribute(node)) return;
+				if (isCachedRecipeVariant(node)) return;
+				const composite = resolveCompositeProperty(node.key.name);
+				if (!composite) return;
+				sendReport(node.key, composite);
+			}
+		};
+	},
+	defaultOptions: [{ whitelist: [] }],
+	meta: {
+		docs: { description: "Encourage the use of atomic properties instead of composite properties in the codebase." },
+		messages: { atomic: "Use atomic properties instead of `{{composite}}`. Prefer: \n{{atomics}}" },
+		schema: [{
+			additionalProperties: false,
+			properties: { whitelist: {
+				items: {
+					minLength: 0,
+					type: "string"
+				},
+				type: "array",
+				uniqueItems: true
+			} },
+			type: "object"
+		}],
+		type: "suggestion"
+	},
+	name: RULE_NAME$4
+});
+
+//#endregion
+//#region src/rules/prefer-composite-properties.ts
+const RULE_NAME$3 = "prefer-composite-properties";
+const rule$3 = require_utils.createRule({
+	create(context) {
+		const whitelist = context.options[0]?.whitelist ?? [];
+		const longhandCache = /* @__PURE__ */ new Map();
+		const getLonghand = (name) => {
+			if (longhandCache.has(name)) return longhandCache.get(name);
+			const longhand = resolveLonghand(name, context) ?? name;
+			longhandCache.set(name, longhand);
+			return longhand;
+		};
+		const compositePropertyCache = /* @__PURE__ */ new Map();
+		const resolveCompositeProperty = (name) => {
+			if (compositePropertyCache.has(name)) return compositePropertyCache.get(name);
+			const longhand = getLonghand(name);
+			if (!isValidProperty(longhand, context)) {
+				compositePropertyCache.set(name, void 0);
+				return;
+			}
+			const composite = Object.keys(compositeProperties).find((cpd) => compositeProperties[cpd].includes(longhand));
+			compositePropertyCache.set(name, composite);
+			return composite;
+		};
+		const bambooPropertyCache = /* @__PURE__ */ new WeakMap();
+		const isCachedBambooProperty = (node) => {
+			if (bambooPropertyCache.has(node)) return bambooPropertyCache.get(node);
+			const result = isBambooProp(node, context);
+			bambooPropertyCache.set(node, result);
+			return Boolean(result);
+		};
+		const bambooAttributeCache = /* @__PURE__ */ new WeakMap();
+		const isCachedBambooAttribute = (node) => {
+			if (bambooAttributeCache.has(node)) return bambooAttributeCache.get(node);
+			const result = isBambooAttribute(node, context);
+			bambooAttributeCache.set(node, result);
+			return Boolean(result);
+		};
+		const recipeVariantCache = /* @__PURE__ */ new WeakMap();
+		const isCachedRecipeVariant = (node) => {
+			if (recipeVariantCache.has(node)) return recipeVariantCache.get(node);
+			const result = isRecipeVariant(node, context);
+			recipeVariantCache.set(node, result);
+			return Boolean(result);
+		};
+		const sendReport = (node, composite) => {
+			if (whitelist.includes(node.name)) return;
+			context.report({
+				data: {
+					atomic: node.name,
+					composite
+				},
+				messageId: "composite",
+				node
+			});
+		};
+		return {
+			JSXAttribute(node) {
+				if (!isJSXIdentifier(node.name)) return;
+				if (!isCachedBambooProperty(node)) return;
+				const composite = resolveCompositeProperty(node.name.name);
+				if (!composite) return;
+				sendReport(node.name, composite);
+			},
+			Property(node) {
+				if (!isIdentifier(node.key)) return;
+				if (!isCachedBambooAttribute(node)) return;
+				if (isCachedRecipeVariant(node)) return;
+				const composite = resolveCompositeProperty(node.key.name);
+				if (!composite) return;
+				sendReport(node.key, composite);
+			}
+		};
+	},
+	defaultOptions: [{ whitelist: [] }],
+	meta: {
+		docs: { description: "Encourage the use of composite properties instead of atomic properties in the codebase." },
+		messages: { composite: "Use composite property instead of `{{atomic}}`. Prefer: `{{composite}}`." },
+		schema: [{
+			additionalProperties: false,
+			properties: { whitelist: {
+				items: {
+					minLength: 0,
+					type: "string"
+				},
+				type: "array",
+				uniqueItems: true
+			} },
+			type: "object"
+		}],
+		type: "suggestion"
+	},
+	name: RULE_NAME$3
+});
+
+//#endregion
+//#region src/rules/prefer-longhand-properties.ts
+const RULE_NAME$2 = "prefer-longhand-properties";
+const rule$2 = require_utils.createRule({
+	create(context) {
+		const whitelist = context.options[0]?.whitelist ?? [];
+		const longhandCache = /* @__PURE__ */ new Map();
+		const getLonghand = (name) => {
+			if (longhandCache.has(name)) return longhandCache.get(name);
+			const longhand = resolveLonghand(name, context);
+			longhandCache.set(name, longhand);
+			return longhand;
+		};
+		const bambooPropertyCache = /* @__PURE__ */ new WeakMap();
+		const isCachedBambooProperty = (node) => {
+			if (bambooPropertyCache.has(node)) return bambooPropertyCache.get(node);
+			const result = isBambooProp(node, context);
+			bambooPropertyCache.set(node, result);
+			return Boolean(result);
+		};
+		const bambooAttributeCache = /* @__PURE__ */ new WeakMap();
+		const isCachedBambooAttribute = (node) => {
+			if (bambooAttributeCache.has(node)) return bambooAttributeCache.get(node);
+			const result = isBambooAttribute(node, context);
+			bambooAttributeCache.set(node, result);
+			return Boolean(result);
+		};
+		const recipeVariantCache = /* @__PURE__ */ new WeakMap();
+		const isCachedRecipeVariant = (node) => {
+			if (recipeVariantCache.has(node)) return recipeVariantCache.get(node);
+			const result = isRecipeVariant(node, context);
+			recipeVariantCache.set(node, result);
+			return Boolean(result);
+		};
+		const sendReport = (node) => {
+			if (whitelist.includes(node.name)) return;
+			const longhand = getLonghand(node.name);
+			if (!longhand || longhand === node.name) return;
+			const data = {
+				longhand,
+				shorthand: node.name
+			};
+			context.report({
+				data,
+				messageId: "longhand",
+				node,
+				suggest: [{
+					data,
+					fix: (fixer) => fixer.replaceText(node, longhand),
+					messageId: "replace"
+				}]
+			});
+		};
+		return {
+			JSXAttribute(node) {
+				if (!isJSXIdentifier(node.name)) return;
+				if (!isCachedBambooProperty(node)) return;
+				sendReport(node.name);
+			},
+			Property(node) {
+				if (!isIdentifier(node.key)) return;
+				if (!isCachedBambooAttribute(node)) return;
+				if (isCachedRecipeVariant(node)) return;
+				sendReport(node.key);
+			}
+		};
+	},
+	defaultOptions: [{ whitelist: [] }],
+	meta: {
+		docs: { description: "Discourage the use of shorthand properties and promote the preference for longhand properties in the codebase." },
+		hasSuggestions: true,
+		messages: {
+			longhand: "Use longhand property instead of `{{shorthand}}`. Prefer `{{longhand}}`.",
+			replace: "Replace `{{shorthand}}` with `{{longhand}}`."
+		},
+		schema: [{
+			additionalProperties: false,
+			properties: { whitelist: {
+				items: {
+					minLength: 0,
+					type: "string"
+				},
+				type: "array",
+				uniqueItems: true
+			} },
+			type: "object"
+		}],
+		type: "suggestion"
+	},
+	name: RULE_NAME$2
+});
+
+//#endregion
+//#region src/rules/prefer-shorthand-properties.ts
+const RULE_NAME$1 = "prefer-shorthand-properties";
+const rule$1 = require_utils.createRule({
+	create(context) {
+		const whitelist = context.options[0]?.whitelist ?? [];
+		const longhandCache = /* @__PURE__ */ new Map();
+		const getLonghand = (name) => {
+			if (longhandCache.has(name)) return longhandCache.get(name);
+			const longhand = resolveLonghand(name, context);
+			longhandCache.set(name, longhand);
+			return longhand;
+		};
+		const shorthandsCache = /* @__PURE__ */ new Map();
+		const getShorthands = (name) => {
+			if (shorthandsCache.has(name)) return shorthandsCache.get(name);
+			const shorthands = resolveShorthands(name, context);
+			shorthandsCache.set(name, shorthands);
+			return shorthands;
+		};
+		const bambooPropertyCache = /* @__PURE__ */ new WeakMap();
+		const isCachedBambooProperty = (node) => {
+			if (bambooPropertyCache.has(node)) return bambooPropertyCache.get(node);
+			const result = isBambooProp(node, context);
+			bambooPropertyCache.set(node, result);
+			return Boolean(result);
+		};
+		const bambooAttributeCache = /* @__PURE__ */ new WeakMap();
+		const isCachedBambooAttribute = (node) => {
+			if (bambooAttributeCache.has(node)) return bambooAttributeCache.get(node);
+			const result = isBambooAttribute(node, context);
+			bambooAttributeCache.set(node, result);
+			return Boolean(result);
+		};
+		const recipeVariantCache = /* @__PURE__ */ new WeakMap();
+		const isCachedRecipeVariant = (node) => {
+			if (recipeVariantCache.has(node)) return recipeVariantCache.get(node);
+			const result = isRecipeVariant(node, context);
+			recipeVariantCache.set(node, result);
+			return Boolean(result);
+		};
+		const sendReport = (node) => {
+			if (whitelist.includes(node.name)) return;
+			if (getLonghand(node.name)) return;
+			const shorthands = getShorthands(node.name);
+			if (!shorthands || shorthands.length === 0) return;
+			const shorthandList = shorthands.map((s) => `\`${s}\``).join(", ");
+			const data = {
+				longhand: node.name,
+				shorthand: shorthandList
+			};
+			context.report({
+				data,
+				messageId: "shorthand",
+				node,
+				suggest: [{
+					data,
+					fix: (fixer) => fixer.replaceText(node, shorthands[0]),
+					messageId: "replace"
+				}]
+			});
+		};
+		return {
+			JSXAttribute(node) {
+				if (!isJSXIdentifier(node.name)) return;
+				if (!isCachedBambooProperty(node)) return;
+				sendReport(node.name);
+			},
+			Property(node) {
+				if (!isIdentifier(node.key)) return;
+				if (!isCachedBambooAttribute(node)) return;
+				if (isCachedRecipeVariant(node)) return;
+				sendReport(node.key);
+			}
+		};
+	},
+	defaultOptions: [{ whitelist: [] }],
+	meta: {
+		docs: { description: "Discourage the use of longhand properties and promote the preference for shorthand properties in the codebase." },
+		hasSuggestions: true,
+		messages: {
+			replace: "Replace `{{longhand}}` with `{{shorthand}}`.",
+			shorthand: "Use shorthand property instead of `{{longhand}}`. Prefer `{{shorthand}}`."
+		},
+		schema: [{
+			additionalProperties: false,
+			properties: { whitelist: {
+				items: {
+					minLength: 0,
+					type: "string"
+				},
+				type: "array",
+				uniqueItems: true
+			} },
+			type: "object"
+		}],
+		type: "suggestion"
+	},
+	name: RULE_NAME$1
+});
+
+//#endregion
+//#region src/rules/prefer-unified-property-style.ts
+const RULE_NAME = "prefer-unified-property-style";
+const rule = require_utils.createRule({
+	create(context) {
+		const longhandCache = /* @__PURE__ */ new Map();
+		const getLonghand = (name) => {
+			if (longhandCache.has(name)) return longhandCache.get(name);
+			const longhand = resolveLonghand(name, context) ?? name;
+			longhandCache.set(name, longhand);
+			return longhand;
+		};
+		const compositePropertyCache = /* @__PURE__ */ new Map();
+		const resolveCompositeProperty = (name) => {
+			if (compositePropertyCache.has(name)) return compositePropertyCache.get(name);
+			if (name in compositeProperties) {
+				compositePropertyCache.set(name, name);
+				return name;
+			}
+			const longhand = getLonghand(name);
+			if (isValidProperty(longhand, context) && longhand in compositeProperties) {
+				compositePropertyCache.set(name, longhand);
+				return longhand;
+			}
+			compositePropertyCache.set(name, void 0);
+		};
+		const bambooPropertyCache = /* @__PURE__ */ new WeakMap();
+		const isCachedBambooProperty = (node) => {
+			if (bambooPropertyCache.has(node)) return bambooPropertyCache.get(node);
+			const result = isBambooProp(node, context);
+			bambooPropertyCache.set(node, result);
+			return Boolean(result);
+		};
+		const bambooAttributeCache = /* @__PURE__ */ new WeakMap();
+		const isCachedBambooAttribute = (node) => {
+			if (bambooAttributeCache.has(node)) return bambooAttributeCache.get(node);
+			const result = isBambooAttribute(node, context);
+			bambooAttributeCache.set(node, result);
+			return Boolean(result);
+		};
+		const recipeVariantCache = /* @__PURE__ */ new WeakMap();
+		const isCachedRecipeVariant = (node) => {
+			if (recipeVariantCache.has(node)) return recipeVariantCache.get(node);
+			const result = isRecipeVariant(node, context);
+			recipeVariantCache.set(node, result);
+			return Boolean(result);
+		};
+		const sendReport = (node, composite, siblings) => {
+			const atomicPropertiesSet = new Set(siblings.filter((property) => compositeProperties[composite].includes(getLonghand(property))));
+			if (atomicPropertiesSet.size === 0) return;
+			const atomicProperties = Array.from(atomicPropertiesSet).map((property) => `\`${property}\``).join(", ");
+			const atomics = compositeProperties[composite].map((name) => `\`${name}\``).join(", ");
+			context.report({
+				data: {
+					atomicProperties,
+					atomics,
+					composite
+				},
+				messageId: "unify",
+				node
+			});
+		};
+		return {
+			JSXAttribute(node) {
+				if (!isJSXIdentifier(node.name)) return;
+				if (!isCachedBambooProperty(node)) return;
+				const composite = resolveCompositeProperty(node.name.name);
+				if (!composite) return;
+				if (!isJSXOpeningElement(node.parent)) return;
+				sendReport(node, composite, node.parent.attributes.map((attribute) => attribute.name.name));
+			},
+			Property(node) {
+				if (!isIdentifier(node.key)) return;
+				if (!isCachedBambooAttribute(node)) return;
+				if (isCachedRecipeVariant(node)) return;
+				const composite = resolveCompositeProperty(node.key.name);
+				if (!composite) return;
+				if (!isObjectExpression(node.parent)) return;
+				const siblings = node.parent.properties.filter((property) => property.type === "Property").map((property) => isIdentifier(property.key) ? property.key.name : "");
+				sendReport(node.key, composite, siblings);
+			}
+		};
+	},
+	defaultOptions: [],
+	meta: {
+		docs: { description: "Discourage mixing atomic and composite forms of the same property in a style declaration. Atomic styles give more consistent results." },
+		messages: { unify: "You're mixing atomic {{atomicProperties}} with composite property `{{composite}}`. Prefer atomic styling to mixing atomic and composite properties. Remove `{{composite}}` and use one or more of {{atomics}} instead." },
+		schema: [],
+		type: "suggestion"
+	},
+	name: RULE_NAME
+});
+
+//#endregion
+//#region src/rules/index.ts
+const rules = {
+	[RULE_NAME$18]: rule$18,
+	[RULE_NAME$17]: rule$17,
+	[RULE_NAME$16]: rule$16,
+	[RULE_NAME$15]: rule$15,
+	[RULE_NAME$14]: rule$14,
+	[RULE_NAME$13]: rule$13,
+	[RULE_NAME$12]: rule$12,
+	[RULE_NAME$11]: rule$11,
+	[RULE_NAME$10]: rule$10,
+	[RULE_NAME$9]: rule$9,
+	[RULE_NAME$8]: rule$8,
+	[RULE_NAME$7]: rule$7,
+	[RULE_NAME$6]: rule$6,
+	[RULE_NAME$5]: rule$5,
+	[RULE_NAME$4]: rule$4,
+	[RULE_NAME$3]: rule$3,
+	[RULE_NAME$2]: rule$2,
+	[RULE_NAME$1]: rule$1,
+	[RULE_NAME]: rule
+};
+
+//#endregion
+//#region src/configs/all.ts
+const errorRules = [
+	RULE_NAME$18,
+	RULE_NAME$17,
+	RULE_NAME$9
+];
+const allRules = Object.fromEntries(Object.entries(rules).map(([name]) => {
+	return [`@bamboocss/${name}`, errorRules.includes(name) ? "error" : "warn"];
+}));
+var all_default = {
+	parser: "@typescript-eslint/parser",
+	parserOptions: { sourceType: "module" },
+	plugins: ["@bamboocss"],
+	rules: allRules
+};
+
+//#endregion
+//#region src/configs/recommended.ts
+var recommended_default = {
+	parser: "@typescript-eslint/parser",
+	parserOptions: { sourceType: "module" },
+	plugins: ["@bamboocss"],
+	rules: {
+		"@bamboocss/file-not-included": "error",
+		"@bamboocss/no-config-function-in-source": "error",
+		"@bamboocss/no-debug": "warn",
+		"@bamboocss/no-deprecated-tokens": "warn",
+		"@bamboocss/no-dynamic-styling": "warn",
+		"@bamboocss/no-hardcoded-color": "warn",
+		"@bamboocss/no-invalid-nesting": "error",
+		"@bamboocss/no-invalid-token-paths": "error",
+		"@bamboocss/no-property-renaming": "warn",
+		"@bamboocss/no-unsafe-token-fn-usage": "warn"
+	}
+};
+
+//#endregion
+//#region src/index.ts
+const plugin = {
+	configs: {
+		all: all_default,
+		recommended: recommended_default
+	},
+	meta: {
+		name,
+		version
+	},
+	rules
+};
+module.exports = plugin;
+
+//#endregion
+//# sourceMappingURL=index.cjs.map