@bamboocss/eslint-plugin 1.12.0

package/dist/index.mjs

@@ -0,0 +1,2458 @@
+import { c as __commonJSMin, l as __esmMin, n as init_utils, r as syncAction, t as createRule } from "./utils-CwjhPHe9.mjs";
+import { getArbitraryValue } from "@bamboocss/shared";
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+import { isNodeOfType, isNodeOfTypes } from "@typescript-eslint/utils/ast-utils";
+import { analyze } from "@typescript-eslint/scope-manager";
+import "@typescript-eslint/utils/ts-eslint";
+
+//#region package.json
+var name = "@bamboocss/eslint-plugin";
+var version = "1.12.0";
+
+//#endregion
+//#region src/utils/nodes.ts
+var isIdentifier, isLiteral, isTemplateLiteral, isArrayExpression, isObjectExpression, isMemberExpression, isVariableDeclarator, isVariableDeclaration, isJSXMemberExpression, isJSXOpeningElement, isJSXExpressionContainer, isJSXAttribute, isJSXIdentifier, isCallExpression, isImportDeclaration, isImportSpecifier;
+var init_nodes = __esmMin((() => {
+	isIdentifier = isNodeOfType(AST_NODE_TYPES.Identifier);
+	isLiteral = isNodeOfType(AST_NODE_TYPES.Literal);
+	isTemplateLiteral = isNodeOfType(AST_NODE_TYPES.TemplateLiteral);
+	isArrayExpression = isNodeOfType(AST_NODE_TYPES.ArrayExpression);
+	isObjectExpression = isNodeOfType(AST_NODE_TYPES.ObjectExpression);
+	isMemberExpression = isNodeOfType(AST_NODE_TYPES.MemberExpression);
+	isVariableDeclarator = isNodeOfType(AST_NODE_TYPES.VariableDeclarator);
+	isVariableDeclaration = isNodeOfType(AST_NODE_TYPES.VariableDeclaration);
+	isJSXMemberExpression = isNodeOfType(AST_NODE_TYPES.JSXMemberExpression);
+	isJSXOpeningElement = isNodeOfType(AST_NODE_TYPES.JSXOpeningElement);
+	isJSXExpressionContainer = isNodeOfType(AST_NODE_TYPES.JSXExpressionContainer);
+	isJSXAttribute = isNodeOfType(AST_NODE_TYPES.JSXAttribute);
+	isJSXIdentifier = isNodeOfType(AST_NODE_TYPES.JSXIdentifier);
+	isCallExpression = isNodeOfType(AST_NODE_TYPES.CallExpression);
+	isImportDeclaration = isNodeOfType(AST_NODE_TYPES.ImportDeclaration);
+	isImportSpecifier = isNodeOfType(AST_NODE_TYPES.ImportSpecifier);
+}));
+
+//#endregion
+//#region src/utils/helpers.ts
+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;
+}
+var getAncestor, getSyncOptions, getImportSpecifiers, hasPkgImport, isBambooConfigFunction, rawImportsCache, _getImports, importsCache, getImports, isValidStyledProperty, matchFile, isBambooIsh, scopeCache, findDeclaration, isLocalStyledFactory, isValidFile, isValidProperty, isBambooImport, isBambooProp, isStyledProperty, isInBambooFunction, isInJSXProp, isBambooAttribute, resolveLonghand, resolveShorthands, isColorAttribute, isColorToken, extractTokens, invalidTokensCache, getInvalidTokens, deprecatedTokensCache, getDeprecatedTokens, getTokenImport, getTaggedTemplateCaller, isStyledTaggedTemplate;
+var init_helpers = __esmMin((() => {
+	init_utils();
+	init_nodes();
+	getAncestor = (ofType, for_) => {
+		let current = for_.parent;
+		while (current) {
+			if (ofType(current)) return current;
+			current = current.parent;
+		}
+	};
+	getSyncOptions = (context) => {
+		return {
+			configPath: context.settings["@bamboocss/configPath"],
+			currentFile: context.filename
+		};
+	};
+	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;
+	};
+	hasPkgImport = (context) => {
+		return _getImports(context).some(({ mod }) => mod === "@bamboocss/dev");
+	};
+	isBambooConfigFunction = (context, name) => {
+		return _getImports(context).some(({ alias, mod }) => alias === name && mod === "@bamboocss/dev");
+	};
+	rawImportsCache = /* @__PURE__ */ new WeakMap();
+	_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;
+	};
+	importsCache = /* @__PURE__ */ new WeakMap();
+	getImports = (context) => {
+		if (importsCache.has(context)) return importsCache.get(context);
+		const imports = _getImports(context);
+		const result = syncAction("filterImports", getSyncOptions(context), imports) ?? [];
+		importsCache.set(context, result);
+		return result;
+	};
+	isValidStyledProperty = (node, context) => {
+		return isJSXIdentifier(node) && isValidProperty(node.name, context);
+	};
+	matchFile = (name, imports, context) => {
+		return syncAction("matchFile", getSyncOptions(context), name, imports);
+	};
+	isBambooIsh = (name, context) => {
+		const imports = getImports(context);
+		if (imports.length === 0) return false;
+		const jsxFactory = syncAction("getJsxFactory", getSyncOptions(context));
+		if (jsxFactory && name === jsxFactory) return imports.some((imp) => imp.name === name || imp.alias === name);
+		return matchFile(name, imports, context);
+	};
+	scopeCache = /* @__PURE__ */ new WeakMap();
+	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 = 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;
+		}
+	};
+	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;
+	};
+	isValidFile = (context) => {
+		return syncAction("isValidFile", getSyncOptions(context));
+	};
+	isValidProperty = (name, context, calleName) => {
+		return syncAction("isValidProperty", getSyncOptions(context), name, calleName);
+	};
+	isBambooImport = (node, context) => {
+		return getImports(context).some((imp) => imp.mod === node.source.value);
+	};
+	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;
+	};
+	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;
+	};
+	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;
+	};
+	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;
+	};
+	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);
+	};
+	resolveLonghand = (name, context) => {
+		return syncAction("resolveLongHand", getSyncOptions(context), name);
+	};
+	resolveShorthands = (name, context) => {
+		return syncAction("resolveShorthands", getSyncOptions(context), name);
+	};
+	isColorAttribute = (attribute, context) => {
+		return syncAction("isColorAttribute", getSyncOptions(context), attribute);
+	};
+	isColorToken = (value, context) => {
+		if (!value) return;
+		return syncAction("isColorToken", getSyncOptions(context), value);
+	};
+	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);
+	};
+	invalidTokensCache = /* @__PURE__ */ new Map();
+	getInvalidTokens = (value, context) => {
+		if (invalidTokensCache.has(value)) return invalidTokensCache.get(value);
+		const tokens = extractTokens(value);
+		if (!tokens.length) return [];
+		const invalidTokens = syncAction("filterInvalidTokens", getSyncOptions(context), tokens);
+		invalidTokensCache.set(value, invalidTokens);
+		return invalidTokens;
+	};
+	deprecatedTokensCache = /* @__PURE__ */ new Map();
+	getDeprecatedTokens = (property, value, context) => {
+		const propertyCategory = 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 = syncAction("filterDeprecatedTokens", getSyncOptions(context), values);
+		deprecatedTokensCache.set(value, deprecatedTokens);
+		return deprecatedTokens;
+	};
+	getTokenImport = (context) => {
+		return _getImports(context).find((imp) => imp.name === "token");
+	};
+	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;
+		}
+	};
+	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);
+	};
+}));
+
+//#endregion
+//#region src/rules/file-not-included.ts
+var RULE_NAME$18, rule$18;
+var init_file_not_included = __esmMin((() => {
+	init_utils();
+	init_helpers();
+	RULE_NAME$18 = "file-not-included";
+	rule$18 = 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
+var RULE_NAME$17, CONFIG_FUNCTIONS, rule$17;
+var init_no_config_function_in_source = __esmMin((() => {
+	init_utils();
+	init_helpers();
+	init_nodes();
+	RULE_NAME$17 = "no-config-function-in-source";
+	CONFIG_FUNCTIONS = new Set([
+		"defineConfig",
+		"defineGlobalStyles",
+		"defineKeyframes",
+		"defineLayerStyles",
+		"defineParts",
+		"definePattern",
+		"definePreset",
+		"defineRecipe",
+		"defineSemanticTokens",
+		"defineSlotRecipe",
+		"defineStyles",
+		"defineTextStyles",
+		"defineTokens",
+		"defineUtility"
+	]);
+	rule$17 = 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
+var RULE_NAME$16, rule$16;
+var init_no_debug = __esmMin((() => {
+	init_utils();
+	init_helpers();
+	init_nodes();
+	RULE_NAME$16 = "no-debug";
+	rule$16 = 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
+var RULE_NAME$15, rule$15;
+var init_no_deprecated_tokens = __esmMin((() => {
+	init_utils();
+	init_helpers();
+	init_nodes();
+	RULE_NAME$15 = "no-deprecated-tokens";
+	rule$15 = 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) || !isNodeOfTypes([AST_NODE_TYPES.Literal, 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
+var RULE_NAME$14, rule$14;
+var init_no_dynamic_styling = __esmMin((() => {
+	init_utils();
+	init_helpers();
+	init_nodes();
+	RULE_NAME$14 = "no-dynamic-styling";
+	rule$14 = 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
+var RULE_NAME$13, rule$13;
+var init_no_escape_hatch = __esmMin((() => {
+	init_utils();
+	init_helpers();
+	init_nodes();
+	RULE_NAME$13 = "no-escape-hatch";
+	rule$13 = 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 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), 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
+var RULE_NAME$12, rule$12;
+var init_no_hardcoded_color = __esmMin((() => {
+	init_utils();
+	init_helpers();
+	init_nodes();
+	RULE_NAME$12 = "no-hardcoded-color";
+	rule$12 = 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
+var exclamationRegex, importantRegex, RULE_NAME$11, rule$11;
+var init_no_important = __esmMin((() => {
+	init_utils();
+	init_helpers();
+	init_nodes();
+	exclamationRegex = /\s*!$/;
+	importantRegex = /\s*!important\s*$/;
+	RULE_NAME$11 = "no-important";
+	rule$11 = 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 = 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(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
+var RULE_NAME$10, rule$10;
+var init_no_invalid_nesting = __esmMin((() => {
+	init_utils();
+	init_helpers();
+	init_nodes();
+	RULE_NAME$10 = "no-invalid-nesting";
+	rule$10 = 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
+var RULE_NAME$9, rule$9;
+var init_no_invalid_token_paths = __esmMin((() => {
+	init_utils();
+	init_helpers();
+	init_nodes();
+	RULE_NAME$9 = "no-invalid-token-paths";
+	rule$9 = 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) || !isNodeOfTypes([AST_NODE_TYPES.Literal, 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
+var RULE_NAME$8, rule$8;
+var init_no_margin_properties = __esmMin((() => {
+	init_utils();
+	init_helpers();
+	init_nodes();
+	RULE_NAME$8 = "no-margin-properties";
+	rule$8 = 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
+var physicalProperties, physicalPropertyValues;
+var init_physical_properties = __esmMin((() => {
+	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"
+	};
+	physicalPropertyValues = { textAlign: {
+		left: "start",
+		right: "end"
+	} };
+}));
+
+//#endregion
+//#region src/rules/no-physical-properties.ts
+var RULE_NAME$7, MESSAGES, PropertyCache, extractStringLiteralValue, createPropertyReport, createValueReport, rule$7;
+var init_no_physical_properties = __esmMin((() => {
+	init_utils();
+	init_helpers();
+	init_nodes();
+	init_physical_properties();
+	RULE_NAME$7 = "no-physical-properties";
+	MESSAGES = {
+		physical: "Use logical property instead of {{physical}}. Prefer `{{logical}}`.",
+		physicalValue: "Use logical value instead of {{physical}}. Prefer `{{logical}}`.",
+		replace: "Replace `{{physical}}` with `{{logical}}`."
+	};
+	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);
+		}
+	};
+	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;
+	};
+	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"
+			}]
+		});
+	};
+	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"
+			}]
+		});
+	};
+	rule$7 = 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
+var RULE_NAME$6, rule$6;
+var init_no_property_renaming = __esmMin((() => {
+	init_utils();
+	init_helpers();
+	init_nodes();
+	RULE_NAME$6 = "no-property-renaming";
+	rule$6 = 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
+var RULE_NAME$5, rule$5;
+var init_no_unsafe_token_fn_usage = __esmMin((() => {
+	init_utils();
+	init_helpers();
+	init_nodes();
+	RULE_NAME$5 = "no-unsafe-token-fn-usage";
+	rule$5 = 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(getArbitraryValue(value.value?.toString() ?? "")));
+				else if (isTemplateLiteral(value) && value.expressions.length === 0) sendReport(node, tokenWrap(getArbitraryValue(value.quasis[0].value.raw)));
+			};
+			const handleLiteral = (node) => {
+				if (!isLiteral(node)) return;
+				const value = getArbitraryValue(node.value?.toString() ?? "");
+				if (isCompositeValue(value)) return;
+				sendReport(node, value);
+			};
+			const handleTemplateLiteral = (node) => {
+				if (!isTemplateLiteral(node) || node.expressions.length > 0) return;
+				const value = 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
+var compositeProperties;
+var init_composite_properties = __esmMin((() => {
+	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
+var RULE_NAME$4, rule$4;
+var init_prefer_atomic_properties = __esmMin((() => {
+	init_utils();
+	init_composite_properties();
+	init_helpers();
+	init_nodes();
+	RULE_NAME$4 = "prefer-atomic-properties";
+	rule$4 = 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
+var RULE_NAME$3, rule$3;
+var init_prefer_composite_properties = __esmMin((() => {
+	init_utils();
+	init_composite_properties();
+	init_helpers();
+	init_nodes();
+	RULE_NAME$3 = "prefer-composite-properties";
+	rule$3 = 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
+var RULE_NAME$2, rule$2;
+var init_prefer_longhand_properties = __esmMin((() => {
+	init_utils();
+	init_helpers();
+	init_nodes();
+	RULE_NAME$2 = "prefer-longhand-properties";
+	rule$2 = 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
+var RULE_NAME$1, rule$1;
+var init_prefer_shorthand_properties = __esmMin((() => {
+	init_utils();
+	init_helpers();
+	init_nodes();
+	RULE_NAME$1 = "prefer-shorthand-properties";
+	rule$1 = 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
+var RULE_NAME, rule;
+var init_prefer_unified_property_style = __esmMin((() => {
+	init_utils();
+	init_composite_properties();
+	init_helpers();
+	init_nodes();
+	RULE_NAME = "prefer-unified-property-style";
+	rule = 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
+var rules;
+var init_rules = __esmMin((() => {
+	init_file_not_included();
+	init_no_config_function_in_source();
+	init_no_debug();
+	init_no_deprecated_tokens();
+	init_no_dynamic_styling();
+	init_no_escape_hatch();
+	init_no_hardcoded_color();
+	init_no_important();
+	init_no_invalid_nesting();
+	init_no_invalid_token_paths();
+	init_no_margin_properties();
+	init_no_physical_properties();
+	init_no_property_renaming();
+	init_no_unsafe_token_fn_usage();
+	init_prefer_atomic_properties();
+	init_prefer_composite_properties();
+	init_prefer_longhand_properties();
+	init_prefer_shorthand_properties();
+	init_prefer_unified_property_style();
+	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
+var errorRules, allRules, all_default;
+var init_all = __esmMin((() => {
+	init_rules();
+	init_file_not_included();
+	init_no_config_function_in_source();
+	init_no_invalid_token_paths();
+	errorRules = [
+		RULE_NAME$18,
+		RULE_NAME$17,
+		RULE_NAME$9
+	];
+	allRules = Object.fromEntries(Object.entries(rules).map(([name]) => {
+		return [`@bamboocss/${name}`, errorRules.includes(name) ? "error" : "warn"];
+	}));
+	all_default = {
+		parser: "@typescript-eslint/parser",
+		parserOptions: { sourceType: "module" },
+		plugins: ["@bamboocss"],
+		rules: allRules
+	};
+}));
+
+//#endregion
+//#region src/configs/recommended.ts
+var recommended_default;
+var init_recommended = __esmMin((() => {
+	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
+var require_src = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	init_all();
+	init_recommended();
+	init_rules();
+	const plugin = {
+		configs: {
+			all: all_default,
+			recommended: recommended_default
+		},
+		meta: {
+			name,
+			version
+		},
+		rules
+	};
+	module.exports = plugin;
+}));
+
+//#endregion
+export default require_src();
+
+export {  };
+//# sourceMappingURL=index.mjs.map