@pandacss/eslint-plugin 0.1.15 → 0.2.0

package/dist/index.mjs

@@ -10,7 +10,7 @@ var name, version;
 var init_package = __esm({
   "package.json"() {
     name = "@pandacss/eslint-plugin";
-    version = "0.1.15";
+    version = "0.2.0";
   }
 });
 
@@ -34,7 +34,8 @@ var init_utils = __esm({
       try {
         return _syncAction(...args);
       } catch (error) {
-        return;
+        console.error("syncAction error:", error);
+        return void 0;
       }
     };
   }
@@ -8008,7 +8009,7 @@ function isRecipeVariant(node, context) {
   if (length < requiredLength + extraLength)
     return true;
 }
-var import_scope_manager, getAncestor, getSyncOpts, getImportSpecifiers, hasPkgImport, isPandaConfigFunction, _getImports, getImports, isValidStyledProp, isPandaIsh, findDeclaration, isLocalStyledFactory, isValidFile, isValidProperty, isPandaImport, isPandaProp, isStyledProperty, isInPandaFunction, isInJSXProp, isPandaAttribute, resolveLonghand, resolveShorthands, isColorAttribute, isColorToken, extractTokens, getInvalidTokens, getTokenImport, getTaggedTemplateCaller;
+var import_scope_manager, getAncestor, getSyncOpts, getImportSpecifiers, hasPkgImport, isPandaConfigFunction, _getImports, importsCache, getImports, isValidStyledProp, isPandaIsh, findDeclaration, isLocalStyledFactory, isValidFile, isValidProperty, isPandaImport, isPandaProp, isStyledProperty, isInPandaFunction, isInJSXProp, isPandaAttribute, resolveLonghand, resolveShorthands, isColorAttribute, isColorToken, invalidTokensCache, extractTokens, getInvalidTokens, getTokenImport, getTaggedTemplateCaller;
 var init_helpers = __esm({
   "src/utils/helpers.ts"() {
     "use strict";
@@ -8064,13 +8065,17 @@ var init_helpers = __esm({
       }));
       return imports;
     };
+    importsCache = /* @__PURE__ */ new WeakMap();
     getImports = (context) => {
+      if (importsCache.has(context)) {
+        return importsCache.get(context);
+      }
       const imports = _getImports(context);
-      return imports.filter((imp) => syncAction("matchImports", getSyncOpts(context), imp));
+      const filteredImports = imports.filter((imp) => syncAction("matchImports", getSyncOpts(context), imp));
+      importsCache.set(context, filteredImports);
+      return filteredImports;
     };
     isValidStyledProp = (node, context) => {
-      if (typeof node === "string")
-        return;
       return isJSXIdentifier(node) && isValidProperty(node.name, context);
     };
     isPandaIsh = (name2, context) => {
@@ -8088,7 +8093,8 @@ var init_helpers = __esm({
         if (isVariableDeclarator(decl))
           return decl;
       } catch (error) {
-        return;
+        console.error("Error in findDeclaration:", error);
+        return void 0;
       }
     };
     isLocalStyledFactory = (node, context) => {
@@ -8164,6 +8170,8 @@ var init_helpers = __esm({
         return;
       if (!isPandaProp(jsxAttrAncestor, context))
         return;
+      if (typeof jsxAttrAncestor.name === "string")
+        return;
       if (!isValidStyledProp(jsxAttrAncestor.name, context))
         return;
       return true;
@@ -8192,6 +8200,7 @@ var init_helpers = __esm({
         return;
       return syncAction("isColorToken", getSyncOpts(context), value);
     };
+    invalidTokensCache = /* @__PURE__ */ new Map();
     extractTokens = (value) => {
       const regex = /token\(([^"'(),]+)(?:,\s*([^"'(),]+))?\)|\{([^{}]+)\}/g;
       const matches = [];
@@ -8209,10 +8218,15 @@ var init_helpers = __esm({
       return matches.filter(Boolean);
     };
     getInvalidTokens = (value, context) => {
+      if (invalidTokensCache.has(value)) {
+        return invalidTokensCache.get(value);
+      }
       const tokens = extractTokens(value);
       if (!tokens.length)
         return [];
-      return syncAction("filterInvalidTokens", getSyncOpts(context), tokens);
+      const invalidTokens = syncAction("filterInvalidTokens", getSyncOpts(context), tokens);
+      invalidTokensCache.set(value, invalidTokens);
+      return invalidTokens;
     };
     getTokenImport = (context) => {
       const imports = _getImports(context);
@@ -8237,6 +8251,7 @@ var init_helpers = __esm({
 });
 
 // src/rules/file-not-included.ts
+import "@typescript-eslint/utils";
 var RULE_NAME, rule, file_not_included_default;
 var init_file_not_included = __esm({
   "src/rules/file-not-included.ts"() {
@@ -8249,26 +8264,32 @@ var init_file_not_included = __esm({
       name: RULE_NAME,
       meta: {
         docs: {
-          description: "Disallow the use of panda css in files that are not included in the specified panda `include` config."
+          description: "Disallow the use of Panda CSS in files that are not included in the specified Panda CSS `include` config."
         },
         messages: {
-          include: "The use of Panda CSS is not allowed in this file. Please check the specified `include` config."
+          include: "The use of Panda CSS is not allowed in this file. Please ensure the file is included in the Panda CSS `include` configuration."
         },
-        type: "suggestion",
+        type: "problem",
         schema: []
       },
       defaultOptions: [],
       create(context) {
+        const isFileIncluded = isValidFile(context);
+        if (isFileIncluded) {
+          return {};
+        }
+        let hasReported = false;
         return {
           ImportDeclaration(node) {
-            if (!isPandaImport(node, context))
+            if (hasReported)
               return;
-            if (isValidFile(context))
+            if (!isPandaImport(node, context))
               return;
             context.report({
               node,
               messageId: "include"
             });
+            hasReported = true;
           }
         };
       }
@@ -8278,7 +8299,8 @@ var init_file_not_included = __esm({
 });
 
 // src/rules/no-config-function-in-source.ts
-var RULE_NAME2, rule2, no_config_function_in_source_default, CONFIG_FUNCTIONS;
+import "@typescript-eslint/utils";
+var RULE_NAME2, CONFIG_FUNCTIONS, rule2, no_config_function_in_source_default;
 var init_no_config_function_in_source = __esm({
   "src/rules/no-config-function-in-source.ts"() {
     "use strict";
@@ -8287,55 +8309,80 @@ var init_no_config_function_in_source = __esm({
     init_utils();
     init_helpers();
     RULE_NAME2 = "no-config-function-in-source";
+    CONFIG_FUNCTIONS = /* @__PURE__ */ new Set([
+      "defineConfig",
+      "defineRecipe",
+      "defineSlotRecipe",
+      "defineParts",
+      "definePattern",
+      "definePreset",
+      "defineKeyframes",
+      "defineGlobalStyles",
+      "defineUtility",
+      "defineTextStyles",
+      "defineLayerStyles",
+      "defineStyles",
+      "defineTokens",
+      "defineSemanticTokens"
+    ]);
     rule2 = createRule({
       name: RULE_NAME2,
       meta: {
         docs: {
-          description: "Prohibit the use of config functions outside the Panda config."
+          description: "Prohibit the use of config functions outside the Panda config file."
         },
         messages: {
-          configFunction: "Unnecessary`{{name}}` call. \nConfig functions should only be used in panda config.",
+          configFunction: "Unnecessary `{{name}}` call. Config functions should only be used in the Panda config file.",
           delete: "Delete `{{name}}` call."
         },
-        type: "suggestion",
+        type: "problem",
         hasSuggestions: true,
         schema: []
       },
       defaultOptions: [],
       create(context) {
-        if (!hasPkgImport(context))
+        if (!hasPkgImport(context)) {
+          return {};
+        }
+        const isPandaFile = isValidFile(context);
+        if (!isPandaFile) {
           return {};
+        }
         return {
           CallExpression(node) {
-            if (!isValidFile(context))
-              return;
             if (!isIdentifier(node.callee))
               return;
-            if (!CONFIG_FUNCTIONS.includes(node.callee.name))
+            const functionName = node.callee.name;
+            if (!CONFIG_FUNCTIONS.has(functionName))
               return;
-            if (!isPandaConfigFunction(context, node.callee.name))
+            if (!isPandaConfigFunction(context, functionName))
               return;
             context.report({
               node,
               messageId: "configFunction",
               data: {
-                name: node.callee.name
+                name: functionName
               },
               suggest: [
                 {
                   messageId: "delete",
                   data: {
-                    name: node.callee.name
+                    name: functionName
                   },
                   fix(fixer) {
                     const declaration = getAncestor(isVariableDeclaration, node);
-                    const importSpec = getImportSpecifiers(context).find(
-                      (s) => isIdentifier(node.callee) && s.specifier.local.name === node.callee.name
-                    );
-                    return [
-                      fixer.remove(declaration ?? node),
-                      importSpec?.specifier ? fixer.remove(importSpec?.specifier) : {}
-                    ];
+                    const importSpecifiers = getImportSpecifiers(context);
+                    const importSpec = importSpecifiers.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;
                   }
                 }
               ]
@@ -8345,32 +8392,16 @@ var init_no_config_function_in_source = __esm({
       }
     });
     no_config_function_in_source_default = rule2;
-    CONFIG_FUNCTIONS = [
-      "defineConfig",
-      "defineRecipe",
-      "defineSlotRecipe",
-      "defineParts",
-      "definePattern",
-      "definePreset",
-      "defineKeyframes",
-      "defineGlobalStyles",
-      "defineUtility",
-      "defineTextStyles",
-      "defineLayerStyles",
-      "defineStyles",
-      "defineTokens",
-      "defineSemanticTokens"
-    ];
   }
 });
 
 // src/rules/no-debug.ts
+import "@typescript-eslint/utils";
 var RULE_NAME3, rule3, no_debug_default;
 var init_no_debug = __esm({
   "src/rules/no-debug.ts"() {
     "use strict";
     init_esm_shims();
-    init_nodes();
     init_utils();
     init_helpers();
     RULE_NAME3 = "no-debug";
@@ -8385,16 +8416,14 @@ var init_no_debug = __esm({
           prop: "Remove the debug prop.",
           property: "Remove the debug property."
         },
-        type: "suggestion",
+        type: "problem",
         hasSuggestions: true,
         schema: []
       },
       defaultOptions: [],
       create(context) {
         return {
-          JSXAttribute(node) {
-            if (!isJSXIdentifier(node.name) || node.name.name !== "debug")
-              return;
+          'JSXAttribute[name.name="debug"]'(node) {
             if (!isPandaProp(node, context))
               return;
             context.report({
@@ -8408,9 +8437,7 @@ var init_no_debug = __esm({
               ]
             });
           },
-          Property(node) {
-            if (!isIdentifier(node.key) || node.key.name !== "debug")
-              return;
+          'Property[key.name="debug"]'(node) {
             if (!isPandaAttribute(node, context))
               return;
             if (isRecipeVariant(node, context))
@@ -8434,20 +8461,7 @@ var init_no_debug = __esm({
 });
 
 // src/rules/no-dynamic-styling.ts
-function checkArrayElements(array, context) {
-  array.elements.forEach((node) => {
-    if (!node)
-      return;
-    if (isLiteral(node))
-      return;
-    if (isTemplateLiteral(node) && node.expressions.length === 0)
-      return;
-    context.report({
-      node,
-      messageId: "dynamic"
-    });
-  });
-}
+import "@typescript-eslint/utils";
 var RULE_NAME4, rule4, no_dynamic_styling_default;
 var init_no_dynamic_styling = __esm({
   "src/rules/no-dynamic-styling.ts"() {
@@ -8461,42 +8475,66 @@ var init_no_dynamic_styling = __esm({
       name: RULE_NAME4,
       meta: {
         docs: {
-          description: "Ensure user doesn't use dynamic styling at any point. \nPrefer to use static styles, leverage css variables or recipes for known dynamic styles."
+          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"
+          dynamic: "Remove dynamic value. Prefer static styles.",
+          dynamicProperty: "Remove dynamic property. Prefer static style property.",
+          dynamicRecipeVariant: "Remove dynamic variant. Prefer static variant definition."
         },
-        type: "suggestion",
+        type: "problem",
         schema: []
       },
       defaultOptions: [],
       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) {
+          array.elements.forEach((element) => {
+            if (!element)
+              return;
+            if (isStaticValue(element))
+              return;
+            context.report({
+              node: element,
+              messageId: "dynamic"
+            });
+          });
+        }
         return {
+          // JSX Attributes
           JSXAttribute(node) {
             if (!node.value)
               return;
             if (isLiteral(node.value))
               return;
-            if (isJSXExpressionContainer(node.value) && isLiteral(node.value.expression))
-              return;
-            if (isJSXExpressionContainer(node.value) && isTemplateLiteral(node.value.expression) && node.value.expression.expressions.length === 0)
-              return;
-            if (isObjectExpression(node.value.expression))
-              return;
             if (!isPandaProp(node, context))
               return;
-            if (isArrayExpression(node.value.expression)) {
-              return checkArrayElements(node.value.expression, context);
+            if (isJSXExpressionContainer(node.value)) {
+              const expr = node.value.expression;
+              if (isStaticValue(expr))
+                return;
+              if (isArrayExpression(expr)) {
+                checkArrayElements(expr);
+                return;
+              }
             }
             context.report({
               node: node.value,
               messageId: "dynamic"
             });
           },
-          // Dynamic properties
-          "Property[computed=true]"(node) {
+          // Dynamic properties with computed keys
+          "Property[computed=true]": (node) => {
             if (!isInPandaFunction(node, context))
               return;
             context.report({
@@ -8504,19 +8542,19 @@ var init_no_dynamic_styling = __esm({
               messageId: isRecipeVariant(node, context) ? "dynamicRecipeVariant" : "dynamicProperty"
             });
           },
+          // Object Properties
           Property(node) {
             if (!isIdentifier(node.key))
               return;
-            if (isLiteral(node.value))
-              return;
-            if (isTemplateLiteral(node.value) && node.value.expressions.length === 0)
+            if (!isPandaAttribute(node, context))
               return;
-            if (isObjectExpression(node.value))
+            if (isRecipeVariant(node, context))
               return;
-            if (!isPandaAttribute(node, context))
+            if (isStaticValue(node.value))
               return;
             if (isArrayExpression(node.value)) {
-              return checkArrayElements(node.value, context);
+              checkArrayElements(node.value);
+              return;
             }
             context.report({
               node: node.value,
@@ -8532,6 +8570,7 @@ var init_no_dynamic_styling = __esm({
 
 // src/rules/no-escape-hatch.ts
 import { getArbitraryValue } from "@pandacss/shared";
+import "@typescript-eslint/utils";
 var RULE_NAME5, rule5, no_escape_hatch_default;
 var init_no_escape_hatch = __esm({
   "src/rules/no-escape-hatch.ts"() {
@@ -8548,47 +8587,37 @@ var init_no_escape_hatch = __esm({
           description: "Prohibit the use of escape hatch syntax in the code."
         },
         messages: {
-          escapeHatch: "Avoid using the escape hatch [value] for undefined tokens. \nDefine a corresponding token in your design system for better consistency and maintainability.",
+          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 (`[]`)."
         },
-        type: "suggestion",
+        type: "problem",
         hasSuggestions: true,
         schema: []
       },
       defaultOptions: [],
       create(context) {
-        const removeQuotes = ([start, end]) => [start + 1, end - 1];
+        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 handleLiteral = (node) => {
-          if (!isLiteral(node))
-            return;
-          if (!hasEscapeHatch(node.value?.toString()))
-            return;
-          sendReport(node);
-        };
-        const handleTemplateLiteral = (node) => {
-          if (!isTemplateLiteral(node))
-            return;
-          if (node.expressions.length > 0)
+        const handleNodeValue = (node, value) => {
+          if (!hasEscapeHatch(value))
             return;
-          if (!hasEscapeHatch(node.quasis[0].value.raw))
-            return;
-          sendReport(node.quasis[0], node.quasis[0].value.raw);
-        };
-        const sendReport = (node, _value) => {
-          const value = _value ?? node.value?.toString();
-          return context.report({
+          context.report({
             node,
             messageId: "escapeHatch",
             suggest: [
               {
                 messageId: "remove",
                 fix: (fixer) => {
-                  return fixer.replaceTextRange(removeQuotes(node.range), getArbitraryValue(value));
+                  return fixer.replaceTextRange(removeBrackets(node.range), getArbitraryValue(value));
                 }
               }
             ]
@@ -8600,23 +8629,36 @@ var init_no_escape_hatch = __esm({
               return;
             if (!isPandaProp(node, context))
               return;
-            handleLiteral(node.value);
-            if (!isJSXExpressionContainer(node.value))
-              return;
-            handleLiteral(node.value.expression);
-            handleTemplateLiteral(node.value.expression);
+            const { value } = node;
+            if (isLiteral(value)) {
+              const val = value.value?.toString() ?? "";
+              handleNodeValue(value, val);
+            } else if (isJSXExpressionContainer(value)) {
+              const expr = value.expression;
+              if (isLiteral(expr)) {
+                const val = expr.value?.toString() ?? "";
+                handleNodeValue(expr, val);
+              } else if (isTemplateLiteral(expr) && expr.expressions.length === 0) {
+                const val = expr.quasis[0].value.raw;
+                handleNodeValue(expr.quasis[0], val);
+              }
+            }
           },
           Property(node) {
             if (!isIdentifier(node.key))
               return;
-            if (!isLiteral(node.value) && !isTemplateLiteral(node.value))
-              return;
             if (!isPandaAttribute(node, context))
               return;
             if (isRecipeVariant(node, context))
               return;
-            handleLiteral(node.value);
-            handleTemplateLiteral(node.value);
+            const value = node.value;
+            if (isLiteral(value)) {
+              const val = value.value?.toString() ?? "";
+              handleNodeValue(value, val);
+            } else if (isTemplateLiteral(value) && value.expressions.length === 0) {
+              const val = value.quasis[0].value.raw;
+              handleNodeValue(value.quasis[0], val);
+            }
           }
         };
       }
@@ -8626,6 +8668,7 @@ var init_no_escape_hatch = __esm({
 });
 
 // src/rules/no-hardcoded-color.ts
+import "@typescript-eslint/utils";
 var RULE_NAME6, rule6, no_hardcoded_color_default;
 var init_no_hardcoded_color = __esm({
   "src/rules/no-hardcoded-color.ts"() {
@@ -8644,7 +8687,7 @@ var init_no_hardcoded_color = __esm({
         messages: {
           invalidColor: "`{{color}}` is not a valid color token."
         },
-        type: "suggestion",
+        type: "problem",
         schema: [
           {
             type: "object",
@@ -8652,7 +8695,8 @@ var init_no_hardcoded_color = __esm({
               noOpacity: {
                 type: "boolean"
               }
-            }
+            },
+            additionalProperties: false
           }
         ]
       },
@@ -8663,19 +8707,55 @@ var init_no_hardcoded_color = __esm({
       ],
       create(context) {
         const noOpacity = context.options[0]?.noOpacity;
-        const isTokenFn = (value) => {
+        const colorTokenCache = /* @__PURE__ */ new Map();
+        const colorAttributeCache = /* @__PURE__ */ new Map();
+        const isColorToken2 = (token) => {
+          if (colorTokenCache.has(token)) {
+            return colorTokenCache.get(token);
+          }
+          const result = isColorToken(token, context);
+          colorTokenCache.set(token, result);
+          return !!result;
+        };
+        const isColorAttribute2 = (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;
           const tokens = extractTokens(value);
           return tokens.length > 0;
         };
-        const testColorToken = (value) => {
+        const isValidColorToken = (value) => {
           if (!value)
             return false;
-          const color = value?.split("/");
-          const isOpacityToken = !!color[1]?.length;
-          const isValidToken = isColorToken(color[0], context);
-          return noOpacity ? isValidToken && !isOpacityToken : isValidToken;
+          const [colorToken, opacity] = value.split("/");
+          const hasOpacity = opacity !== void 0 && opacity.length > 0;
+          const isValidToken = isColorToken2(colorToken);
+          return noOpacity ? isValidToken && !hasOpacity : isValidToken;
+        };
+        const reportInvalidColor = (node, color) => {
+          context.report({
+            node,
+            messageId: "invalidColor",
+            data: {
+              color
+            }
+          });
+        };
+        const checkColorValue = (node, value, attributeName) => {
+          if (!isColorAttribute2(attributeName))
+            return;
+          if (isTokenFunctionUsed(value))
+            return;
+          if (isValidColorToken(value))
+            return;
+          reportInvalidColor(node, value);
         };
         return {
           JSXAttribute(node) {
@@ -8683,49 +8763,38 @@ var init_no_hardcoded_color = __esm({
               return;
             if (!isPandaProp(node, context) || !node.value)
               return;
-            if (isLiteral(node.value) && isColorAttribute(node.name.name, context) && !isTokenFn(node.value.value?.toString()) && !testColorToken(node.value.value?.toString())) {
-              context.report({
-                node: node.value,
-                messageId: "invalidColor",
-                data: {
-                  color: node.value.value?.toString()
-                }
-              });
-            }
-            if (!isJSXExpressionContainer(node.value))
-              return;
-            if (isLiteral(node.value.expression) && isColorAttribute(node.name.name, context) && !isTokenFn(node.value.expression.value?.toString()) && !testColorToken(node.value.expression.value?.toString())) {
-              context.report({
-                node: node.value.expression,
-                messageId: "invalidColor",
-                data: {
-                  color: node.value.expression.value?.toString()
-                }
-              });
+            const attributeName = node.name.name;
+            const valueNode = node.value;
+            if (isLiteral(valueNode)) {
+              const value = valueNode.value?.toString() || "";
+              checkColorValue(valueNode, value, attributeName);
+            } else if (isJSXExpressionContainer(valueNode)) {
+              const expression = valueNode.expression;
+              if (isLiteral(expression)) {
+                const value = expression.value?.toString() || "";
+                checkColorValue(expression, value, 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 (!isLiteral(node.value))
-              return;
             if (!isPandaAttribute(node, context))
               return;
             if (isRecipeVariant(node, context))
               return;
-            if (!isColorAttribute(node.key.name, context))
-              return;
-            if (isTokenFn(node.value.value?.toString()))
-              return;
-            if (testColorToken(node.value.value?.toString()))
-              return;
-            context.report({
-              node: node.value,
-              messageId: "invalidColor",
-              data: {
-                color: node.value.value?.toString()
-              }
-            });
+            const attributeName = node.key.name;
+            const valueNode = node.value;
+            if (isLiteral(valueNode)) {
+              const value = valueNode.value?.toString() || "";
+              checkColorValue(valueNode, value, attributeName);
+            } else if (isTemplateLiteral(valueNode) && valueNode.expressions.length === 0) {
+              const value = valueNode.quasis[0].value.raw;
+              checkColorValue(valueNode.quasis[0], value, attributeName);
+            }
           }
         };
       }
@@ -8736,6 +8805,7 @@ var init_no_hardcoded_color = __esm({
 
 // src/rules/no-important.ts
 import { getArbitraryValue as getArbitraryValue2 } from "@pandacss/shared";
+import "@typescript-eslint/utils";
 var exclamationRegex, importantRegex, RULE_NAME7, rule7, no_important_default;
 var init_no_important = __esm({
   "src/rules/no-important.ts"() {
@@ -8751,56 +8821,72 @@ var init_no_important = __esm({
       name: RULE_NAME7,
       meta: {
         docs: {
-          description: "Disallow usage of important keyword. Prioroitize specificity for a maintainable and predictable styling structure."
+          description: "Disallow usage of !important keyword. Prioritize specificity for a maintainable and predictable styling structure."
         },
         messages: {
-          important: "Avoid using the !important keyword. Refactor your code to prioritize specificity for predictable styling.",
+          important: "Avoid using the {{keyword}} keyword. Refactor your code to prioritize specificity for predictable styling.",
           remove: "Remove the `{{keyword}}` keyword."
         },
-        type: "suggestion",
+        type: "problem",
         hasSuggestions: true,
         schema: []
       },
       defaultOptions: [],
       create(context) {
-        const removeQuotes = ([start, end]) => [start + 1, end - 1];
-        const hasImportantKeyword = (_value) => {
-          if (!_value)
+        const removeQuotes = (range) => {
+          const [start, end] = range;
+          return [start + 1, end - 1];
+        };
+        const pandaPropCache = /* @__PURE__ */ new WeakMap();
+        const pandaAttributeCache = /* @__PURE__ */ new WeakMap();
+        const recipeVariantCache = /* @__PURE__ */ new WeakMap();
+        const isCachedPandaProp = (node) => {
+          if (pandaPropCache.has(node)) {
+            return pandaPropCache.get(node);
+          }
+          const result = isPandaProp(node, context);
+          pandaPropCache.set(node, result);
+          return !!result;
+        };
+        const isCachedPandaAttribute = (node) => {
+          if (pandaAttributeCache.has(node)) {
+            return pandaAttributeCache.get(node);
+          }
+          const result = isPandaAttribute(node, context);
+          pandaAttributeCache.set(node, result);
+          return !!result;
+        };
+        const isCachedRecipeVariant = (node) => {
+          if (recipeVariantCache.has(node)) {
+            return recipeVariantCache.get(node);
+          }
+          const result = isRecipeVariant(node, context);
+          recipeVariantCache.set(node, result);
+          return !!result;
+        };
+        const hasImportantKeyword = (value) => {
+          if (!value)
             return false;
-          const value = getArbitraryValue2(_value);
-          return exclamationRegex.test(value) || importantRegex.test(value);
+          const arbitraryValue = getArbitraryValue2(value);
+          return exclamationRegex.test(arbitraryValue) || importantRegex.test(arbitraryValue);
         };
         const removeImportantKeyword = (input) => {
-          if (exclamationRegex.test(input)) {
-            return { fixed: input.replace(exclamationRegex, ""), keyword: "!" };
-          } else if (importantRegex.test(input)) {
-            return { fixed: input.replace(importantRegex, ""), keyword: "!important" };
+          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 handleLiteral = (node) => {
-          if (!isLiteral(node))
-            return;
-          if (!hasImportantKeyword(node.value?.toString()))
-            return;
-          sendReport(node);
-        };
-        const handleTemplateLiteral = (node) => {
-          if (!isTemplateLiteral(node))
+        const handleNodeValue = (node, value) => {
+          if (!hasImportantKeyword(value))
             return;
-          if (node.expressions.length > 0)
-            return;
-          if (!hasImportantKeyword(node.quasis[0].value.raw))
-            return;
-          sendReport(node.quasis[0], node.quasis[0].value.raw);
-        };
-        const sendReport = (node, _value) => {
-          const value = _value ?? node.value?.toString();
-          const { keyword, fixed } = removeImportantKeyword(value);
-          return context.report({
+          const { fixed, keyword } = removeImportantKeyword(value);
+          context.report({
             node,
             messageId: "important",
+            data: { keyword },
             suggest: [
               {
                 messageId: "remove",
@@ -8813,28 +8899,43 @@ var init_no_important = __esm({
           });
         };
         return {
+          // JSX Attributes
           JSXAttribute(node) {
             if (!node.value)
               return;
-            if (!isPandaProp(node, context))
-              return;
-            handleLiteral(node.value);
-            if (!isJSXExpressionContainer(node.value))
+            if (!isCachedPandaProp(node))
               return;
-            handleLiteral(node.value.expression);
-            handleTemplateLiteral(node.value.expression);
+            const valueNode = node.value;
+            if (isLiteral(valueNode)) {
+              const val = valueNode.value?.toString() ?? "";
+              handleNodeValue(valueNode, val);
+            } else if (isJSXExpressionContainer(valueNode)) {
+              const expr = valueNode.expression;
+              if (isLiteral(expr)) {
+                const val = expr.value?.toString() ?? "";
+                handleNodeValue(expr, val);
+              } else if (isTemplateLiteral(expr) && expr.expressions.length === 0) {
+                const val = expr.quasis[0].value.raw;
+                handleNodeValue(expr.quasis[0], val);
+              }
+            }
           },
+          // Object Properties
           Property(node) {
             if (!isIdentifier(node.key))
               return;
-            if (!isLiteral(node.value) && !isTemplateLiteral(node.value))
+            if (!isCachedPandaAttribute(node))
               return;
-            if (!isPandaAttribute(node, context))
+            if (isCachedRecipeVariant(node))
               return;
-            if (isRecipeVariant(node, context))
-              return;
-            handleLiteral(node.value);
-            handleTemplateLiteral(node.value);
+            const valueNode = node.value;
+            if (isLiteral(valueNode)) {
+              const val = valueNode.value?.toString() ?? "";
+              handleNodeValue(valueNode, val);
+            } else if (isTemplateLiteral(valueNode) && valueNode.expressions.length === 0) {
+              const val = valueNode.quasis[0].value.raw;
+              handleNodeValue(valueNode.quasis[0], val);
+            }
           }
         };
       }
@@ -8844,6 +8945,7 @@ var init_no_important = __esm({
 });
 
 // src/rules/no-invalid-nesting.ts
+import "@typescript-eslint/utils";
 var RULE_NAME8, rule8, no_invalid_nesting_default;
 var init_no_invalid_nesting = __esm({
   "src/rules/no-invalid-nesting.ts"() {
@@ -8857,35 +8959,78 @@ var init_no_invalid_nesting = __esm({
       name: RULE_NAME8,
       meta: {
         docs: {
-          description: "Warn against invalid nesting. i.e. nested styles that don't contain the `&` character."
+          description: "Warn against invalid nesting. Nested styles must contain the `&` character."
         },
         messages: {
           nesting: "Invalid style nesting. Nested styles must contain the `&` character."
         },
-        type: "suggestion",
+        type: "problem",
         schema: []
       },
       defaultOptions: [],
       create(context) {
+        const pandaFunctionCache = /* @__PURE__ */ new WeakMap();
+        const jsxPropCache = /* @__PURE__ */ new WeakMap();
+        const recipeVariantCache = /* @__PURE__ */ new WeakMap();
+        const styledPropertyCache = /* @__PURE__ */ new WeakMap();
+        const isCachedInPandaFunction = (node) => {
+          if (pandaFunctionCache.has(node)) {
+            return pandaFunctionCache.get(node);
+          }
+          const result = !!isInPandaFunction(node, context);
+          pandaFunctionCache.set(node, result);
+          return !!result;
+        };
+        const isCachedInJSXProp = (node) => {
+          if (jsxPropCache.has(node)) {
+            return jsxPropCache.get(node);
+          }
+          const result = isInJSXProp(node, context);
+          jsxPropCache.set(node, result);
+          return !!result;
+        };
+        const isCachedRecipeVariant = (node) => {
+          if (recipeVariantCache.has(node)) {
+            return recipeVariantCache.get(node);
+          }
+          const result = isRecipeVariant(node, context);
+          recipeVariantCache.set(node, result);
+          return !!result;
+        };
+        const isCachedStyledProperty = (node) => {
+          if (styledPropertyCache.has(node)) {
+            return styledPropertyCache.get(node);
+          }
+          const result = isStyledProperty(node, context);
+          styledPropertyCache.set(node, result);
+          return !!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(node) {
-            if (!isObjectExpression(node.value) || isIdentifier(node.key))
+          // Use AST selector to target Property nodes with non-Identifier keys whose value is an ObjectExpression
+          'Property[key.type!=/Identifier/][value.type="ObjectExpression"]'(node) {
+            const inPandaFunction = isCachedInPandaFunction(node);
+            const inJSXProp = isCachedInJSXProp(node);
+            if (!inPandaFunction && !inJSXProp)
               return;
-            const caller = isInPandaFunction(node, context);
-            if (!caller && !isInJSXProp(node, context))
-              return;
-            if (isRecipeVariant(node, context))
+            if (isCachedRecipeVariant(node))
               return;
-            if (isStyledProperty(node, context))
+            if (isCachedStyledProperty(node))
               return;
-            const invalidLiteral = isLiteral(node.key) && typeof node.key.value === "string" && !node.key.value.includes("&");
-            const invalidTemplateLiteral = isTemplateLiteral(node.key) && !node.key.quasis[0].value.raw.includes("&");
-            if (!(invalidLiteral || invalidTemplateLiteral))
-              return;
-            context.report({
-              node: node.key,
-              messageId: "nesting"
-            });
+            const keyNode = node.key;
+            if (isInvalidNestingSelector(keyNode)) {
+              context.report({
+                node: keyNode,
+                messageId: "nesting"
+              });
+            }
           }
         };
       }
@@ -8915,87 +9060,89 @@ var init_no_invalid_token_paths = __esm({
         messages: {
           noInvalidTokenPaths: "`{{token}}` is an invalid token path."
         },
-        type: "suggestion",
+        type: "problem",
         schema: []
       },
       defaultOptions: [],
       create(context) {
-        const handleLiteral = (node) => {
-          if (!isLiteral(node))
-            return;
-          sendReport(node);
-        };
-        const handleTemplateLiteral = (node) => {
-          if (!isTemplateLiteral(node))
+        const invalidTokensCache2 = /* @__PURE__ */ new Map();
+        const sendReport = (node, value) => {
+          if (!value)
             return;
-          if (node.expressions.length > 0)
+          let tokens = invalidTokensCache2.get(value);
+          if (!tokens) {
+            tokens = getInvalidTokens(value, context);
+            invalidTokensCache2.set(value, tokens);
+          }
+          if (tokens.length === 0)
             return;
-          sendReport(node.quasis[0], node.quasis[0].value.raw);
+          tokens.forEach((token) => {
+            context.report({
+              node,
+              messageId: "noInvalidTokenPaths",
+              data: { token }
+            });
+          });
         };
-        const sendReport = (node, _value) => {
-          const value = _value ?? node.value?.toString();
-          const tokens = getInvalidTokens(value, context);
-          if (!tokens)
+        const handleLiteralOrTemplate = (node) => {
+          if (!node)
             return;
-          if (tokens.length > 0) {
-            tokens.forEach((token) => {
-              context.report({
-                node,
-                messageId: "noInvalidTokenPaths",
-                data: { token }
-              });
-            });
+          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)
-              return;
-            if (!isPandaProp(node, context))
+            if (!node.value || !isPandaProp(node, context))
               return;
-            handleLiteral(node.value);
-            if (!isJSXExpressionContainer(node.value))
-              return;
-            handleLiteral(node.value.expression);
-            handleTemplateLiteral(node.value.expression);
+            if (isLiteral(node.value)) {
+              handleLiteralOrTemplate(node.value);
+            } else if (isJSXExpressionContainer(node.value)) {
+              handleLiteralOrTemplate(node.value.expression);
+            }
           },
           Property(node) {
-            if (!isIdentifier(node.key))
-              return;
-            if (!isNodeOfTypes([AST_NODE_TYPES2.Literal, AST_NODE_TYPES2.TemplateLiteral])(node.value))
-              return;
-            if (!isPandaAttribute(node, context))
+            if (!isIdentifier(node.key) || !isNodeOfTypes([AST_NODE_TYPES2.Literal, AST_NODE_TYPES2.TemplateLiteral])(node.value) || !isPandaAttribute(node, context) || isRecipeVariant(node, context)) {
               return;
-            if (isRecipeVariant(node, context))
-              return;
-            handleLiteral(node.value);
-            handleTemplateLiteral(node.value);
+            }
+            handleLiteralOrTemplate(node.value);
           },
           TaggedTemplateExpression(node) {
             const caller = getTaggedTemplateCaller(node);
-            if (!caller)
-              return;
-            if (!isPandaIsh(caller, context))
+            if (!caller || !isPandaIsh(caller, context))
               return;
-            const quasis = node.quasi.quasis[0];
-            const styles = quasis.value.raw;
-            const tokens = getInvalidTokens(styles, context);
-            if (!tokens)
-              return;
-            tokens.forEach((token, i, arr) => {
-              if (arr.indexOf(token) < i)
+            const quasis = node.quasi.quasis;
+            quasis.forEach((quasi) => {
+              const styles = quasi.value.raw;
+              if (!styles)
                 return;
-              let index = styles.indexOf(token);
-              while (index !== -1) {
-                const start = quasis.range[0] + 1 + index;
-                const end = start + token.length;
-                context.report({
-                  loc: { start: context.sourceCode.getLocFromIndex(start), end: context.sourceCode.getLocFromIndex(end) },
-                  messageId: "noInvalidTokenPaths",
-                  data: { token }
-                });
-                index = styles.indexOf(token, index + 1);
+              let tokens = invalidTokensCache2.get(styles);
+              if (!tokens) {
+                tokens = getInvalidTokens(styles, context);
+                invalidTokensCache2.set(styles, tokens);
               }
+              if (tokens.length === 0)
+                return;
+              tokens.forEach((token) => {
+                let index = styles.indexOf(token);
+                while (index !== -1) {
+                  const start = quasi.range[0] + index + 1;
+                  const end = start + token.length;
+                  context.report({
+                    loc: {
+                      start: context.sourceCode.getLocFromIndex(start),
+                      end: context.sourceCode.getLocFromIndex(end)
+                    },
+                    messageId: "noInvalidTokenPaths",
+                    data: { token }
+                  });
+                  index = styles.indexOf(token, index + token.length);
+                }
+              });
             });
           }
         };
@@ -9029,29 +9176,69 @@ var init_no_margin_properties = __esm({
       },
       defaultOptions: [],
       create(context) {
-        const getLonghand = (name2) => resolveLonghand(name2, context) ?? name2;
+        const longhandCache = /* @__PURE__ */ new Map();
+        const getLonghand = (name2) => {
+          if (longhandCache.has(name2)) {
+            return longhandCache.get(name2);
+          }
+          const longhand = resolveLonghand(name2, context) ?? name2;
+          longhandCache.set(name2, longhand);
+          return longhand;
+        };
+        const marginRegex = /margin/i;
+        const isMarginProperty = (name2) => {
+          const longhand = getLonghand(name2).toLowerCase();
+          return marginRegex.test(longhand);
+        };
         const sendReport = (node) => {
-          if (!getLonghand(node.name).toLowerCase().includes("margin"))
+          if (!isMarginProperty(node.name))
             return;
-          return context.report({
+          context.report({
             node,
             messageId: "noMargin"
           });
         };
+        const pandaPropCache = /* @__PURE__ */ new WeakMap();
+        const isCachedPandaProp = (node) => {
+          if (pandaPropCache.has(node)) {
+            return pandaPropCache.get(node);
+          }
+          const result = isPandaProp(node, context);
+          pandaPropCache.set(node, result);
+          return !!result;
+        };
+        const pandaAttributeCache = /* @__PURE__ */ new WeakMap();
+        const isCachedPandaAttribute = (node) => {
+          if (pandaAttributeCache.has(node)) {
+            return pandaAttributeCache.get(node);
+          }
+          const result = isPandaAttribute(node, context);
+          pandaAttributeCache.set(node, result);
+          return !!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 !!result;
+        };
         return {
           JSXAttribute(node) {
             if (!isJSXIdentifier(node.name))
               return;
-            if (!isPandaProp(node, context))
+            if (!isCachedPandaProp(node))
               return;
             sendReport(node.name);
           },
           Property(node) {
             if (!isIdentifier(node.key))
               return;
-            if (!isPandaAttribute(node, context))
+            if (!isCachedPandaAttribute(node))
               return;
-            if (isRecipeVariant(node, context))
+            if (isCachedRecipeVariant(node))
               return;
             sendReport(node.key);
           }
@@ -9120,11 +9307,11 @@ var init_no_physical_properties = __esm({
       name: RULE_NAME11,
       meta: {
         docs: {
-          description: "Encourage the use of [logical properties](https://mdn.io/logical-properties-basic-concepts) over physical proeprties, to foster a responsive and adaptable user interface."
+          description: "Encourage the use of logical properties over physical properties to foster a responsive and adaptable user interface."
         },
         messages: {
-          physical: "Use logical property of {{physical}} instead. Prefer `{{logical}}`",
-          replace: "Replace `{{physical}}` with `{{logical}}`"
+          physical: "Use logical property instead of {{physical}}. Prefer `{{logical}}`.",
+          replace: "Replace `{{physical}}` with `{{logical}}`."
         },
         type: "suggestion",
         hasSuggestions: true,
@@ -9132,17 +9319,53 @@ var init_no_physical_properties = __esm({
       },
       defaultOptions: [],
       create(context) {
-        const getLonghand = (name2) => resolveLonghand(name2, context) ?? name2;
+        const longhandCache = /* @__PURE__ */ new Map();
+        const pandaPropCache = /* @__PURE__ */ new WeakMap();
+        const pandaAttributeCache = /* @__PURE__ */ new WeakMap();
+        const recipeVariantCache = /* @__PURE__ */ new WeakMap();
+        const getLonghand = (name2) => {
+          if (longhandCache.has(name2)) {
+            return longhandCache.get(name2);
+          }
+          const longhand = resolveLonghand(name2, context) ?? name2;
+          longhandCache.set(name2, longhand);
+          return longhand;
+        };
+        const isCachedPandaProp = (node) => {
+          if (pandaPropCache.has(node)) {
+            return pandaPropCache.get(node);
+          }
+          const result = isPandaProp(node, context);
+          pandaPropCache.set(node, result);
+          return !!result;
+        };
+        const isCachedPandaAttribute = (node) => {
+          if (pandaAttributeCache.has(node)) {
+            return pandaAttributeCache.get(node);
+          }
+          const result = isPandaAttribute(node, context);
+          pandaAttributeCache.set(node, result);
+          return !!result;
+        };
+        const isCachedRecipeVariant = (node) => {
+          if (recipeVariantCache.has(node)) {
+            return recipeVariantCache.get(node);
+          }
+          const result = isRecipeVariant(node, context);
+          recipeVariantCache.set(node, result);
+          return !!result;
+        };
         const sendReport = (node) => {
-          if (!(getLonghand(node.name) in physicalProperties))
+          const longhandName = getLonghand(node.name);
+          if (!(longhandName in physicalProperties))
             return;
-          const logical = physicalProperties[getLonghand(node.name)];
-          const longhand = resolveLonghand(node.name, context);
-          return context.report({
+          const logical = physicalProperties[longhandName];
+          const physicalName = `\`${node.name}\`${longhandName !== node.name ? ` (resolved to \`${longhandName}\`)` : ""}`;
+          context.report({
             node,
             messageId: "physical",
             data: {
-              physical: `\`${node.name}\`${longhand ? ` - \`${longhand}\`` : ""}`,
+              physical: physicalName,
               logical
             },
             suggest: [
@@ -9153,7 +9376,7 @@ var init_no_physical_properties = __esm({
                   logical
                 },
                 fix: (fixer) => {
-                  return fixer.replaceTextRange(node.range, logical);
+                  return fixer.replaceText(node, logical);
                 }
               }
             ]
@@ -9163,16 +9386,16 @@ var init_no_physical_properties = __esm({
           JSXAttribute(node) {
             if (!isJSXIdentifier(node.name))
               return;
-            if (!isPandaProp(node, context))
+            if (!isCachedPandaProp(node))
               return;
             sendReport(node.name);
           },
           Property(node) {
             if (!isIdentifier(node.key))
               return;
-            if (!isPandaAttribute(node, context))
+            if (!isCachedPandaAttribute(node))
               return;
-            if (isRecipeVariant(node, context))
+            if (isCachedRecipeVariant(node))
               return;
             sendReport(node.key);
           }
@@ -9197,19 +9420,46 @@ var init_no_property_renaming = __esm({
       name: RULE_NAME12,
       meta: {
         docs: {
-          description: "Ensure user does not rename a property for a pattern or style prop. \nIt doesn't get tracked."
+          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. Panada will not track this prop."
+          noRenaming: "Incoming `{{prop}}` prop is different from the expected `{{expected}}` attribute. Panda will not track this prop."
         },
-        type: "suggestion",
+        type: "problem",
         schema: []
       },
       defaultOptions: [],
       create(context) {
+        const pandaPropCache = /* @__PURE__ */ new WeakMap();
+        const pandaAttributeCache = /* @__PURE__ */ new WeakMap();
+        const recipeVariantCache = /* @__PURE__ */ new WeakMap();
+        const isCachedPandaProp = (node) => {
+          if (pandaPropCache.has(node)) {
+            return pandaPropCache.get(node);
+          }
+          const result = isPandaProp(node, context);
+          pandaPropCache.set(node, result);
+          return !!result;
+        };
+        const isCachedPandaAttribute = (node) => {
+          if (pandaAttributeCache.has(node)) {
+            return pandaAttributeCache.get(node);
+          }
+          const result = isPandaAttribute(node, context);
+          pandaAttributeCache.set(node, result);
+          return !!result;
+        };
+        const isCachedRecipeVariant = (node) => {
+          if (recipeVariantCache.has(node)) {
+            return recipeVariantCache.get(node);
+          }
+          const result = isRecipeVariant(node, context);
+          recipeVariantCache.set(node, result);
+          return !!result;
+        };
         const sendReport = (node, expected, prop) => {
-          return context.report({
-            node: node.value,
+          context.report({
+            node,
             messageId: "noRenaming",
             data: {
               expected,
@@ -9219,10 +9469,9 @@ var init_no_property_renaming = __esm({
         };
         const handleReport = (node, value, attr) => {
           if (isIdentifier(value) && attr !== value.name) {
-            return sendReport(node, attr, value.name);
-          }
-          if (isMemberExpression(value) && isIdentifier(value.property) && attr !== value.property.name) {
-            return sendReport(node, attr, value.property.name);
+            sendReport(node, attr, value.name);
+          } else if (isMemberExpression(value) && isIdentifier(value.property) && attr !== value.property.name) {
+            sendReport(node, attr, value.property.name);
           }
         };
         return {
@@ -9231,24 +9480,24 @@ var init_no_property_renaming = __esm({
               return;
             if (!isJSXExpressionContainer(node.value))
               return;
-            if (!isPandaProp(node, context))
+            if (!isCachedPandaProp(node))
               return;
             const attr = node.name.name.toString();
             const expression = node.value.expression;
-            handleReport(node, expression, attr);
+            handleReport(node.value, expression, attr);
           },
           Property(node) {
             if (!isIdentifier(node.key))
               return;
             if (!isIdentifier(node.value) && !isMemberExpression(node.value))
               return;
-            if (!isPandaAttribute(node, context))
+            if (!isCachedPandaAttribute(node))
               return;
-            if (isRecipeVariant(node, context))
+            if (isCachedRecipeVariant(node))
               return;
-            const attr = node.key.name.toString();
+            const attr = node.key.name;
             const value = node.value;
-            handleReport(node, value, attr);
+            handleReport(node.value, value, attr);
           }
         };
       }
@@ -9276,8 +9525,8 @@ var init_no_unsafe_token_fn_usage = __esm({
           description: "Prevent users from using the token function in situations where they could simply use the raw design token."
         },
         messages: {
-          noUnsafeTokenFnUsage: "Unneccessary token function usage. Prefer design token",
-          replace: "Replace token function with `{{safe}}`"
+          noUnsafeTokenFnUsage: "Unnecessary token function usage. Prefer design token.",
+          replace: "Replace token function with `{{safe}}`."
         },
         type: "suggestion",
         hasSuggestions: true,
@@ -9285,11 +9534,42 @@ var init_no_unsafe_token_fn_usage = __esm({
       },
       defaultOptions: [],
       create(context) {
+        let tokenImportCache;
+        const getCachedTokenImport = () => {
+          if (tokenImportCache !== void 0) {
+            return tokenImportCache;
+          }
+          tokenImportCache = getTokenImport(context);
+          return tokenImportCache;
+        };
         const isUnsafeCallExpression = (node) => {
-          const tkImport = getTokenImport(context);
+          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;
+          const tokenRegex = /^(?:token\([^)]*\)|\{[^}]*\})$/;
+          return !tokenRegex.test(input);
+        };
+        const sendReport = (node, value) => {
+          const tkImports = extractTokens(value);
+          if (!tkImports.length)
+            return;
+          const token = tkImports[0].replace(/^[^.]*\./, "");
+          context.report({
+            node,
+            messageId: "noUnsafeTokenFnUsage",
+            suggest: [
+              {
+                messageId: "replace",
+                data: { safe: token },
+                fix: (fixer) => fixer.replaceText(node, `'${token}'`)
+              }
+            ]
+          });
+        };
         const handleRuntimeFm = (node) => {
           if (!isCallExpression(node))
             return;
@@ -9297,17 +9577,12 @@ var init_no_unsafe_token_fn_usage = __esm({
             return;
           const value = node.arguments[0];
           if (isLiteral(value)) {
-            sendReport(node, tokenWrap(getArbitraryValue3(value.value?.toString() ?? "")));
+            const val = getArbitraryValue3(value.value?.toString() ?? "");
+            sendReport(node, tokenWrap(val));
+          } else if (isTemplateLiteral(value) && value.expressions.length === 0) {
+            const val = getArbitraryValue3(value.quasis[0].value.raw);
+            sendReport(node, tokenWrap(val));
           }
-          if (isTemplateLiteral(value)) {
-            sendReport(node, tokenWrap(getArbitraryValue3(value.quasis[0].value.raw)));
-          }
-        };
-        const isCompositeValue = (input) => {
-          if (!input)
-            return;
-          const tokenRegex = /^(?:token\([^)]*\)|\{[^}]*\})$/;
-          return !tokenRegex.test(input);
         };
         const handleLiteral = (node) => {
           if (!isLiteral(node))
@@ -9318,54 +9593,63 @@ var init_no_unsafe_token_fn_usage = __esm({
           sendReport(node, value);
         };
         const handleTemplateLiteral = (node) => {
-          if (!isTemplateLiteral(node))
+          if (!isTemplateLiteral(node) || node.expressions.length > 0)
             return;
-          if (node.expressions.length > 0)
-            return;
-          sendReport(node, getArbitraryValue3(node.quasis[0].value.raw));
+          const value = getArbitraryValue3(node.quasis[0].value.raw);
+          sendReport(node, value);
         };
-        const sendReport = (node, value) => {
-          const tkImports = extractTokens(value);
-          if (!tkImports.length)
-            return;
-          const token = tkImports[0].replace(/^[^.]*\./, "");
-          return context.report({
-            node,
-            messageId: "noUnsafeTokenFnUsage",
-            suggest: [
-              {
-                messageId: "replace",
-                data: { safe: token },
-                fix: (fixer) => {
-                  return fixer.replaceTextRange(node.range, `'${token}'`);
-                }
-              }
-            ]
-          });
+        const pandaPropCache = /* @__PURE__ */ new WeakMap();
+        const isCachedPandaProp = (node) => {
+          if (pandaPropCache.has(node)) {
+            return pandaPropCache.get(node);
+          }
+          const result = isPandaProp(node, context);
+          pandaPropCache.set(node, result);
+          return !!result;
+        };
+        const pandaAttributeCache = /* @__PURE__ */ new WeakMap();
+        const isCachedPandaAttribute = (node) => {
+          if (pandaAttributeCache.has(node)) {
+            return pandaAttributeCache.get(node);
+          }
+          const result = isPandaAttribute(node, context);
+          pandaAttributeCache.set(node, result);
+          return !!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 !!result;
         };
         return {
           JSXAttribute(node) {
             if (!node.value)
               return;
-            if (!isPandaProp(node, context))
+            if (!isCachedPandaProp(node))
               return;
             handleLiteral(node.value);
-            if (!isJSXExpressionContainer(node.value))
-              return;
-            handleLiteral(node.value.expression);
-            handleTemplateLiteral(node.value.expression);
-            handleRuntimeFm(node.value.expression);
+            if (isJSXExpressionContainer(node.value)) {
+              const expression = node.value.expression;
+              handleLiteral(expression);
+              handleTemplateLiteral(expression);
+              handleRuntimeFm(expression);
+            }
           },
           Property(node) {
-            if (!isCallExpression(node.value) && !isLiteral(node.value) && !isTemplateLiteral(node.value))
+            if (!isCachedPandaAttribute(node))
               return;
-            if (!isPandaAttribute(node, context))
+            if (isCachedRecipeVariant(node))
               return;
-            if (isRecipeVariant(node, context))
-              return;
-            handleRuntimeFm(node.value);
-            handleLiteral(node.value);
-            handleTemplateLiteral(node.value);
+            const valueNode = node.value;
+            if (isCallExpression(valueNode) || isLiteral(valueNode) || isTemplateLiteral(valueNode)) {
+              handleRuntimeFm(valueNode);
+              handleLiteral(valueNode);
+              handleTemplateLiteral(valueNode);
+            }
           }
         };
       }
@@ -9391,8 +9675,8 @@ var init_prefer_longhand_properties = __esm({
           description: "Discourage the use of shorthand properties and promote the preference for longhand properties in the codebase."
         },
         messages: {
-          longhand: "Use longhand property of `{{shorthand}}` instead. Prefer `{{longhand}}`",
-          replace: "Replace `{{shorthand}}` with `{{longhand}}`"
+          longhand: "Use longhand property instead of `{{shorthand}}`. Prefer `{{longhand}}`.",
+          replace: "Replace `{{shorthand}}` with `{{longhand}}`."
         },
         type: "suggestion",
         hasSuggestions: true,
@@ -9400,15 +9684,51 @@ var init_prefer_longhand_properties = __esm({
       },
       defaultOptions: [],
       create(context) {
+        const longhandCache = /* @__PURE__ */ new Map();
+        const getLonghand = (name2) => {
+          if (longhandCache.has(name2)) {
+            return longhandCache.get(name2);
+          }
+          const longhand = resolveLonghand(name2, context);
+          longhandCache.set(name2, longhand);
+          return longhand;
+        };
+        const pandaPropCache = /* @__PURE__ */ new WeakMap();
+        const isCachedPandaProp = (node) => {
+          if (pandaPropCache.has(node)) {
+            return pandaPropCache.get(node);
+          }
+          const result = isPandaProp(node, context);
+          pandaPropCache.set(node, result);
+          return !!result;
+        };
+        const pandaAttributeCache = /* @__PURE__ */ new WeakMap();
+        const isCachedPandaAttribute = (node) => {
+          if (pandaAttributeCache.has(node)) {
+            return pandaAttributeCache.get(node);
+          }
+          const result = isPandaAttribute(node, context);
+          pandaAttributeCache.set(node, result);
+          return !!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 !!result;
+        };
         const sendReport = (node) => {
-          const longhand = resolveLonghand(node.name, context);
-          if (!longhand)
+          const longhand = getLonghand(node.name);
+          if (!longhand || longhand === node.name)
             return;
           const data = {
             shorthand: node.name,
             longhand
           };
-          return context.report({
+          context.report({
             node,
             messageId: "longhand",
             data,
@@ -9416,9 +9736,7 @@ var init_prefer_longhand_properties = __esm({
               {
                 messageId: "replace",
                 data,
-                fix: (fixer) => {
-                  return fixer.replaceTextRange(node.range, longhand);
-                }
+                fix: (fixer) => fixer.replaceText(node, longhand)
               }
             ]
           });
@@ -9427,16 +9745,16 @@ var init_prefer_longhand_properties = __esm({
           JSXAttribute(node) {
             if (!isJSXIdentifier(node.name))
               return;
-            if (!isPandaProp(node, context))
+            if (!isCachedPandaProp(node))
               return;
             sendReport(node.name);
           },
           Property(node) {
             if (!isIdentifier(node.key))
               return;
-            if (!isPandaAttribute(node, context))
+            if (!isCachedPandaAttribute(node))
               return;
-            if (isRecipeVariant(node, context))
+            if (isCachedRecipeVariant(node))
               return;
             sendReport(node.key);
           }
@@ -9464,8 +9782,8 @@ var init_prefer_shorthand_properties = __esm({
           description: "Discourage the use of longhand properties and promote the preference for shorthand properties in the codebase."
         },
         messages: {
-          shorthand: "Use shorthand property of `{{longhand}}` instead. Prefer {{shorthand}}",
-          replace: "Replace `{{longhand}}` with `{{shorthand}}`"
+          shorthand: "Use shorthand property instead of `{{longhand}}`. Prefer `{{shorthand}}`.",
+          replace: "Replace `{{longhand}}` with `{{shorthand}}`."
         },
         type: "suggestion",
         hasSuggestions: true,
@@ -9473,19 +9791,64 @@ var init_prefer_shorthand_properties = __esm({
       },
       defaultOptions: [],
       create(context) {
+        const longhandCache = /* @__PURE__ */ new Map();
+        const getLonghand = (name2) => {
+          if (longhandCache.has(name2)) {
+            return longhandCache.get(name2);
+          }
+          const longhand = resolveLonghand(name2, context);
+          longhandCache.set(name2, longhand);
+          return longhand;
+        };
+        const shorthandsCache = /* @__PURE__ */ new Map();
+        const getShorthands = (name2) => {
+          if (shorthandsCache.has(name2)) {
+            return shorthandsCache.get(name2);
+          }
+          const shorthands = resolveShorthands(name2, context);
+          shorthandsCache.set(name2, shorthands);
+          return shorthands;
+        };
+        const pandaPropCache = /* @__PURE__ */ new WeakMap();
+        const isCachedPandaProp = (node) => {
+          if (pandaPropCache.has(node)) {
+            return pandaPropCache.get(node);
+          }
+          const result = isPandaProp(node, context);
+          pandaPropCache.set(node, result);
+          return !!result;
+        };
+        const pandaAttributeCache = /* @__PURE__ */ new WeakMap();
+        const isCachedPandaAttribute = (node) => {
+          if (pandaAttributeCache.has(node)) {
+            return pandaAttributeCache.get(node);
+          }
+          const result = isPandaAttribute(node, context);
+          pandaAttributeCache.set(node, result);
+          return !!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 !!result;
+        };
         const sendReport = (node) => {
-          const longhand = resolveLonghand(node.name, context);
+          const longhand = getLonghand(node.name);
           if (longhand)
             return;
-          const shorthands = resolveShorthands(node.name, context);
-          if (!shorthands)
+          const shorthands = getShorthands(node.name);
+          if (!shorthands || shorthands.length === 0)
             return;
-          const shorthand = shorthands.map((s) => `\`${s}\``)?.join(", ");
+          const shorthandList = shorthands.map((s) => `\`${s}\``).join(", ");
           const data = {
             longhand: node.name,
-            shorthand
+            shorthand: shorthandList
           };
-          return context.report({
+          context.report({
             node,
             messageId: "shorthand",
             data,
@@ -9493,9 +9856,7 @@ var init_prefer_shorthand_properties = __esm({
               {
                 messageId: "replace",
                 data,
-                fix: (fixer) => {
-                  return fixer.replaceTextRange(node.range, shorthands[0]);
-                }
+                fix: (fixer) => fixer.replaceText(node, shorthands[0])
               }
             ]
           });
@@ -9504,16 +9865,16 @@ var init_prefer_shorthand_properties = __esm({
           JSXAttribute(node) {
             if (!isJSXIdentifier(node.name))
               return;
-            if (!isPandaProp(node, context))
+            if (!isCachedPandaProp(node))
               return;
             sendReport(node.name);
           },
           Property(node) {
             if (!isIdentifier(node.key))
               return;
-            if (!isPandaAttribute(node, context))
+            if (!isCachedPandaAttribute(node))
               return;
-            if (isRecipeVariant(node, context))
+            if (isCachedRecipeVariant(node))
               return;
             sendReport(node.key);
           }
@@ -9650,8 +10011,8 @@ var init_prefer_atomic_properties = __esm({
   "src/rules/prefer-atomic-properties.ts"() {
     "use strict";
     init_esm_shims();
-    init_helpers();
     init_utils();
+    init_helpers();
     init_composite_properties();
     init_nodes();
     RULE_NAME16 = "prefer-atomic-properties";
@@ -9662,26 +10023,69 @@ var init_prefer_atomic_properties = __esm({
           description: "Encourage the use of atomic properties instead of composite properties in the codebase."
         },
         messages: {
-          atomic: "Use atomic properties of `{{composite}}` instead. Prefer: \n{{atomics}}"
+          atomic: "Use atomic properties instead of `{{composite}}`. Prefer: \n{{atomics}}"
         },
         type: "suggestion",
         schema: []
       },
       defaultOptions: [],
       create(context) {
+        const longhandCache = /* @__PURE__ */ new Map();
+        const getLonghand = (name2) => {
+          if (longhandCache.has(name2)) {
+            return longhandCache.get(name2);
+          }
+          const longhand = resolveLonghand(name2, context) ?? name2;
+          longhandCache.set(name2, longhand);
+          return longhand;
+        };
+        const compositePropertyCache = /* @__PURE__ */ new Map();
         const resolveCompositeProperty = (name2) => {
-          if (Object.hasOwn(compositeProperties, name2))
+          if (compositePropertyCache.has(name2)) {
+            return compositePropertyCache.get(name2);
+          }
+          if (Object.hasOwn(compositeProperties, name2)) {
+            compositePropertyCache.set(name2, name2);
             return name2;
-          const longhand = resolveLonghand(name2, context) ?? name2;
-          if (isValidProperty(longhand, context) && Object.hasOwn(compositeProperties, longhand))
+          }
+          const longhand = getLonghand(name2);
+          if (isValidProperty(longhand, context) && Object.hasOwn(compositeProperties, longhand)) {
+            compositePropertyCache.set(name2, longhand);
             return longhand;
+          }
+          compositePropertyCache.set(name2, void 0);
+          return void 0;
         };
-        const sendReport = (node) => {
-          const cmp = resolveCompositeProperty(node.name);
-          if (!cmp)
-            return;
-          const atomics = compositeProperties[cmp].map((name2) => `\`${name2}\``).join(",\n");
-          return context.report({
+        const pandaPropCache = /* @__PURE__ */ new WeakMap();
+        const isCachedPandaProp = (node) => {
+          if (pandaPropCache.has(node)) {
+            return pandaPropCache.get(node);
+          }
+          const result = isPandaProp(node, context);
+          pandaPropCache.set(node, result);
+          return !!result;
+        };
+        const pandaAttributeCache = /* @__PURE__ */ new WeakMap();
+        const isCachedPandaAttribute = (node) => {
+          if (pandaAttributeCache.has(node)) {
+            return pandaAttributeCache.get(node);
+          }
+          const result = isPandaAttribute(node, context);
+          pandaAttributeCache.set(node, result);
+          return !!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 !!result;
+        };
+        const sendReport = (node, composite) => {
+          const atomics = compositeProperties[composite].map((name2) => `\`${name2}\``).join(",\n");
+          context.report({
             node,
             messageId: "atomic",
             data: {
@@ -9694,18 +10098,24 @@ var init_prefer_atomic_properties = __esm({
           JSXAttribute(node) {
             if (!isJSXIdentifier(node.name))
               return;
-            if (!isPandaProp(node, context))
+            if (!isCachedPandaProp(node))
               return;
-            sendReport(node.name);
+            const composite = resolveCompositeProperty(node.name.name);
+            if (!composite)
+              return;
+            sendReport(node.name, composite);
           },
           Property(node) {
             if (!isIdentifier(node.key))
               return;
-            if (!isPandaAttribute(node, context))
+            if (!isCachedPandaAttribute(node))
               return;
-            if (isRecipeVariant(node, context))
+            if (isCachedRecipeVariant(node))
               return;
-            sendReport(node.key);
+            const composite = resolveCompositeProperty(node.key.name);
+            if (!composite)
+              return;
+            sendReport(node.key, composite);
           }
         };
       }
@@ -9732,28 +10142,69 @@ var init_prefer_composite_properties = __esm({
           description: "Encourage the use of composite properties instead of atomic properties in the codebase."
         },
         messages: {
-          composite: "Use composite property of `{{atomic}}` instead. \nPrefer: {{composite}}"
+          composite: "Use composite property instead of `{{atomic}}`. Prefer: `{{composite}}`."
         },
         type: "suggestion",
         schema: []
       },
       defaultOptions: [],
       create(context) {
-        const resolveCompositeProperty = (name2) => {
+        const longhandCache = /* @__PURE__ */ new Map();
+        const getLonghand = (name2) => {
+          if (longhandCache.has(name2)) {
+            return longhandCache.get(name2);
+          }
           const longhand = resolveLonghand(name2, context) ?? name2;
-          if (!isValidProperty(longhand, context))
-            return;
-          return Object.keys(compositeProperties).find((cpd) => compositeProperties[cpd].includes(longhand));
+          longhandCache.set(name2, longhand);
+          return longhand;
         };
-        const sendReport = (node) => {
-          const cmp = resolveCompositeProperty(node.name);
-          if (!cmp)
-            return;
-          return context.report({
+        const compositePropertyCache = /* @__PURE__ */ new Map();
+        const resolveCompositeProperty = (name2) => {
+          if (compositePropertyCache.has(name2)) {
+            return compositePropertyCache.get(name2);
+          }
+          const longhand = getLonghand(name2);
+          if (!isValidProperty(longhand, context)) {
+            compositePropertyCache.set(name2, void 0);
+            return void 0;
+          }
+          const composite = Object.keys(compositeProperties).find((cpd) => compositeProperties[cpd].includes(longhand));
+          compositePropertyCache.set(name2, composite);
+          return composite;
+        };
+        const pandaPropCache = /* @__PURE__ */ new WeakMap();
+        const isCachedPandaProp = (node) => {
+          if (pandaPropCache.has(node)) {
+            return pandaPropCache.get(node);
+          }
+          const result = isPandaProp(node, context);
+          pandaPropCache.set(node, result);
+          return !!result;
+        };
+        const pandaAttributeCache = /* @__PURE__ */ new WeakMap();
+        const isCachedPandaAttribute = (node) => {
+          if (pandaAttributeCache.has(node)) {
+            return pandaAttributeCache.get(node);
+          }
+          const result = isPandaAttribute(node, context);
+          pandaAttributeCache.set(node, result);
+          return !!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 !!result;
+        };
+        const sendReport = (node, composite) => {
+          context.report({
             node,
             messageId: "composite",
             data: {
-              composite: cmp,
+              composite,
               atomic: node.name
             }
           });
@@ -9762,18 +10213,24 @@ var init_prefer_composite_properties = __esm({
           JSXAttribute(node) {
             if (!isJSXIdentifier(node.name))
               return;
-            if (!isPandaProp(node, context))
+            if (!isCachedPandaProp(node))
               return;
-            sendReport(node.name);
+            const composite = resolveCompositeProperty(node.name.name);
+            if (!composite)
+              return;
+            sendReport(node.name, composite);
           },
           Property(node) {
             if (!isIdentifier(node.key))
               return;
-            if (!isPandaAttribute(node, context))
+            if (!isCachedPandaAttribute(node))
               return;
-            if (isRecipeVariant(node, context))
+            if (isCachedRecipeVariant(node))
               return;
-            sendReport(node.key);
+            const composite = resolveCompositeProperty(node.key.name);
+            if (!composite)
+              return;
+            sendReport(node.key, composite);
           }
         };
       }
@@ -9797,35 +10254,82 @@ var init_prefer_unified_property_style = __esm({
       name: RULE_NAME18,
       meta: {
         docs: {
-          description: "Discourage against mixing atomic and composite forms of the same property in a style declaration. Atomic styles give more consistent results"
+          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}}. \nPrefer atomic styling to mixing atomic and composite properties. \nRemove `{{composite}}` and use one or more of {{atomics}} instead"
+          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."
         },
         type: "suggestion",
         schema: []
       },
       defaultOptions: [],
       create(context) {
-        const getLonghand = (name2) => resolveLonghand(name2, context) ?? name2;
+        const longhandCache = /* @__PURE__ */ new Map();
+        const getLonghand = (name2) => {
+          if (longhandCache.has(name2)) {
+            return longhandCache.get(name2);
+          }
+          const longhand = resolveLonghand(name2, context) ?? name2;
+          longhandCache.set(name2, longhand);
+          return longhand;
+        };
+        const compositePropertyCache = /* @__PURE__ */ new Map();
         const resolveCompositeProperty = (name2) => {
-          if (name2 in compositeProperties)
+          if (compositePropertyCache.has(name2)) {
+            return compositePropertyCache.get(name2);
+          }
+          if (name2 in compositeProperties) {
+            compositePropertyCache.set(name2, name2);
             return name2;
+          }
           const longhand = getLonghand(name2);
-          if (isValidProperty(longhand, context) && longhand in compositeProperties)
+          if (isValidProperty(longhand, context) && longhand in compositeProperties) {
+            compositePropertyCache.set(name2, longhand);
             return longhand;
+          }
+          compositePropertyCache.set(name2, void 0);
+          return void 0;
         };
-        const sendReport = (node, cmp, siblings) => {
-          const _atomicProperties = siblings.filter((prop) => compositeProperties[cmp].includes(getLonghand(prop))).map((prop) => `\`${prop}\``);
-          if (!_atomicProperties.length)
+        const pandaPropCache = /* @__PURE__ */ new WeakMap();
+        const isCachedPandaProp = (node) => {
+          if (pandaPropCache.has(node)) {
+            return pandaPropCache.get(node);
+          }
+          const result = isPandaProp(node, context);
+          pandaPropCache.set(node, result);
+          return !!result;
+        };
+        const pandaAttributeCache = /* @__PURE__ */ new WeakMap();
+        const isCachedPandaAttribute = (node) => {
+          if (pandaAttributeCache.has(node)) {
+            return pandaAttributeCache.get(node);
+          }
+          const result = isPandaAttribute(node, context);
+          pandaAttributeCache.set(node, result);
+          return !!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 !!result;
+        };
+        const sendReport = (node, composite, siblings) => {
+          const atomicPropertiesSet = new Set(
+            siblings.filter((prop) => compositeProperties[composite].includes(getLonghand(prop)))
+          );
+          if (atomicPropertiesSet.size === 0)
             return;
-          const atomicProperties = _atomicProperties.join(", ") + (_atomicProperties.length === 1 ? " style" : " styles");
-          const atomics = compositeProperties[cmp].map((name2) => `\`${name2}\``).join(", ");
+          const atomicProperties = Array.from(atomicPropertiesSet).map((prop) => `\`${prop}\``).join(", ");
+          const atomics = compositeProperties[composite].map((name2) => `\`${name2}\``).join(", ");
           context.report({
             node,
             messageId: "unify",
             data: {
-              composite: cmp,
+              composite,
               atomicProperties,
               atomics
             }
@@ -9835,30 +10339,30 @@ var init_prefer_unified_property_style = __esm({
           JSXAttribute(node) {
             if (!isJSXIdentifier(node.name))
               return;
-            if (!isPandaProp(node, context))
+            if (!isCachedPandaProp(node))
               return;
-            const cmp = resolveCompositeProperty(node.name.name);
-            if (!cmp)
+            const composite = resolveCompositeProperty(node.name.name);
+            if (!composite)
               return;
             if (!isJSXOpeningElement(node.parent))
               return;
             const siblings = node.parent.attributes.map((attr) => attr.name.name);
-            sendReport(node, cmp, siblings);
+            sendReport(node, composite, siblings);
           },
           Property(node) {
             if (!isIdentifier(node.key))
               return;
-            if (!isPandaAttribute(node, context))
+            if (!isCachedPandaAttribute(node))
               return;
-            if (isRecipeVariant(node, context))
+            if (isCachedRecipeVariant(node))
               return;
-            const cmp = resolveCompositeProperty(node.key.name);
-            if (!cmp)
+            const composite = resolveCompositeProperty(node.key.name);
+            if (!composite)
               return;
             if (!isObjectExpression(node.parent))
               return;
-            const siblings = node.parent.properties.map((prop) => isIdentifier(prop.key) && prop.key.name);
-            sendReport(node.key, cmp, siblings);
+            const siblings = node.parent.properties.filter((prop) => prop.type === "Property").map((prop) => isIdentifier(prop.key) ? prop.key.name : "");
+            sendReport(node.key, composite, siblings);
           }
         };
       }