@pandacss/eslint-plugin 0.1.14 → 0.2.0

package/dist/index.js

@@ -7957,7 +7957,7 @@ init_cjs_shims();
 
 // package.json
 var name = "@pandacss/eslint-plugin";
-var version = "0.1.14";
+var version = "0.2.0";
 
 // src/configs/all.ts
 init_cjs_shims();
@@ -7984,7 +7984,8 @@ var syncAction = (...args) => {
   try {
     return _syncAction(...args);
   } catch (error) {
-    return;
+    console.error("syncAction error:", error);
+    return void 0;
   }
 };
 
@@ -8063,13 +8064,17 @@ var _getImports = (context) => {
   }));
   return imports;
 };
+var importsCache = /* @__PURE__ */ new WeakMap();
 var 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;
 };
 var isValidStyledProp = (node, context) => {
-  if (typeof node === "string")
-    return;
   return isJSXIdentifier(node) && isValidProperty(node.name, context);
 };
 var isPandaIsh = (name2, context) => {
@@ -8087,7 +8092,8 @@ var findDeclaration = (name2, context) => {
     if (isVariableDeclarator(decl))
       return decl;
   } catch (error) {
-    return;
+    console.error("Error in findDeclaration:", error);
+    return void 0;
   }
 };
 var isLocalStyledFactory = (node, context) => {
@@ -8163,6 +8169,8 @@ var isInJSXProp = (node, context) => {
     return;
   if (!isPandaProp(jsxAttrAncestor, context))
     return;
+  if (typeof jsxAttrAncestor.name === "string")
+    return;
   if (!isValidStyledProp(jsxAttrAncestor.name, context))
     return;
   return true;
@@ -8191,6 +8199,7 @@ var isColorToken = (value, context) => {
     return;
   return syncAction("isColorToken", getSyncOpts(context), value);
 };
+var invalidTokensCache = /* @__PURE__ */ new Map();
 var extractTokens = (value) => {
   const regex = /token\(([^"'(),]+)(?:,\s*([^"'(),]+))?\)|\{([^{}]+)\}/g;
   const matches = [];
@@ -8208,10 +8217,15 @@ var extractTokens = (value) => {
   return matches.filter(Boolean);
 };
 var 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;
 };
 var getTokenImport = (context) => {
   const imports = _getImports(context);
@@ -8259,31 +8273,38 @@ function isRecipeVariant(node, context) {
 }
 
 // src/rules/file-not-included.ts
+var import_utils4 = require("@typescript-eslint/utils");
 var RULE_NAME = "file-not-included";
 var rule = createRule({
   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;
       }
     };
   }
@@ -8292,56 +8313,82 @@ var file_not_included_default = rule;
 
 // src/rules/no-config-function-in-source.ts
 init_cjs_shims();
+var import_utils6 = require("@typescript-eslint/utils");
 var RULE_NAME2 = "no-config-function-in-source";
+var CONFIG_FUNCTIONS = /* @__PURE__ */ new Set([
+  "defineConfig",
+  "defineRecipe",
+  "defineSlotRecipe",
+  "defineParts",
+  "definePattern",
+  "definePreset",
+  "defineKeyframes",
+  "defineGlobalStyles",
+  "defineUtility",
+  "defineTextStyles",
+  "defineLayerStyles",
+  "defineStyles",
+  "defineTokens",
+  "defineSemanticTokens"
+]);
 var 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;
               }
             }
           ]
@@ -8351,25 +8398,10 @@ var rule2 = createRule({
   }
 });
 var no_config_function_in_source_default = rule2;
-var CONFIG_FUNCTIONS = [
-  "defineConfig",
-  "defineRecipe",
-  "defineSlotRecipe",
-  "defineParts",
-  "definePattern",
-  "definePreset",
-  "defineKeyframes",
-  "defineGlobalStyles",
-  "defineUtility",
-  "defineTextStyles",
-  "defineLayerStyles",
-  "defineStyles",
-  "defineTokens",
-  "defineSemanticTokens"
-];
 
 // src/rules/no-debug.ts
 init_cjs_shims();
+var import_utils8 = require("@typescript-eslint/utils");
 var RULE_NAME3 = "no-debug";
 var rule3 = createRule({
   name: RULE_NAME3,
@@ -8382,16 +8414,14 @@ var rule3 = createRule({
       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({
@@ -8405,9 +8435,7 @@ var rule3 = createRule({
           ]
         });
       },
-      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))
@@ -8430,50 +8458,72 @@ var no_debug_default = rule3;
 
 // src/rules/no-dynamic-styling.ts
 init_cjs_shims();
+var import_utils9 = require("@typescript-eslint/utils");
 var RULE_NAME4 = "no-dynamic-styling";
 var rule4 = createRule({
   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 (isArrayExpression(node.value.expression)) {
-          return checkElements(node.value.expression, context);
-        }
         if (!isPandaProp(node, context))
           return;
-        if (isArrayExpression(node.value.expression)) {
-          return checkElements(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({
@@ -8481,19 +8531,19 @@ var rule4 = createRule({
           messageId: isRecipeVariant(node, context) ? "dynamicRecipeVariant" : "dynamicProperty"
         });
       },
+      // Object Properties
       Property(node) {
         if (!isIdentifier(node.key))
           return;
-        if (isLiteral(node.value))
+        if (!isPandaAttribute(node, context))
           return;
-        if (isTemplateLiteral(node.value) && node.value.expressions.length === 0)
+        if (isRecipeVariant(node, context))
           return;
-        if (isObjectExpression(node.value))
-          return;
-        if (!isPandaAttribute(node, context))
+        if (isStaticValue(node.value))
           return;
         if (isArrayExpression(node.value)) {
-          return checkElements(node.value, context);
+          checkArrayElements(node.value);
+          return;
         }
         context.report({
           node: node.value,
@@ -8503,25 +8553,12 @@ var rule4 = createRule({
     };
   }
 });
-function checkElements(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"
-    });
-  });
-}
 var no_dynamic_styling_default = rule4;
 
 // src/rules/no-escape-hatch.ts
 init_cjs_shims();
 var import_shared = require("@pandacss/shared");
+var import_utils12 = require("@typescript-eslint/utils");
 var RULE_NAME5 = "no-escape-hatch";
 var rule5 = createRule({
   name: RULE_NAME5,
@@ -8530,47 +8567,37 @@ var rule5 = createRule({
       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 (0, import_shared.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))
+    const handleNodeValue = (node, value) => {
+      if (!hasEscapeHatch(value))
         return;
-      if (node.expressions.length > 0)
-        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), (0, import_shared.getArbitraryValue)(value));
+              return fixer.replaceTextRange(removeBrackets(node.range), (0, import_shared.getArbitraryValue)(value));
             }
           }
         ]
@@ -8582,23 +8609,36 @@ var rule5 = createRule({
           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);
+        }
       }
     };
   }
@@ -8607,6 +8647,7 @@ var no_escape_hatch_default = rule5;
 
 // src/rules/no-hardcoded-color.ts
 init_cjs_shims();
+var import_utils14 = require("@typescript-eslint/utils");
 var RULE_NAME6 = "no-hardcoded-color";
 var rule6 = createRule({
   name: RULE_NAME6,
@@ -8617,7 +8658,7 @@ var rule6 = createRule({
     messages: {
       invalidColor: "`{{color}}` is not a valid color token."
     },
-    type: "suggestion",
+    type: "problem",
     schema: [
       {
         type: "object",
@@ -8625,7 +8666,8 @@ var rule6 = createRule({
           noOpacity: {
             type: "boolean"
           }
-        }
+        },
+        additionalProperties: false
       }
     ]
   },
@@ -8636,19 +8678,55 @@ var rule6 = createRule({
   ],
   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) {
@@ -8656,49 +8734,38 @@ var rule6 = createRule({
           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);
+        }
       }
     };
   }
@@ -8708,6 +8775,7 @@ var no_hardcoded_color_default = rule6;
 // src/rules/no-important.ts
 init_cjs_shims();
 var import_shared2 = require("@pandacss/shared");
+var import_utils16 = require("@typescript-eslint/utils");
 var exclamationRegex = /\s*!$/;
 var importantRegex = /\s*!important\s*$/;
 var RULE_NAME7 = "no-important";
@@ -8715,56 +8783,72 @@ var rule7 = createRule({
   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 = (0, import_shared2.getArbitraryValue)(_value);
-      return exclamationRegex.test(value) || importantRegex.test(value);
+      const arbitraryValue = (0, import_shared2.getArbitraryValue)(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()))
+    const handleNodeValue = (node, value) => {
+      if (!hasImportantKeyword(value))
         return;
-      sendReport(node);
-    };
-    const handleTemplateLiteral = (node) => {
-      if (!isTemplateLiteral(node))
-        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",
@@ -8777,28 +8861,43 @@ var rule7 = createRule({
       });
     };
     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))
-          return;
-        if (!isPandaAttribute(node, context))
+        if (!isCachedPandaAttribute(node))
           return;
-        if (isRecipeVariant(node, context))
+        if (isCachedRecipeVariant(node))
           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);
+        }
       }
     };
   }
@@ -8807,40 +8906,84 @@ var no_important_default = rule7;
 
 // src/rules/no-invalid-nesting.ts
 init_cjs_shims();
+var import_utils18 = require("@typescript-eslint/utils");
 var RULE_NAME8 = "no-invalid-nesting";
 var rule8 = createRule({
   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))
-          return;
-        const caller = isInPandaFunction(node, context);
-        if (!caller && !isInJSXProp(node, context))
+      // 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;
-        if (isRecipeVariant(node, context))
-          return;
-        if (isStyledProperty(node, context))
+        if (isCachedRecipeVariant(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))
+        if (isCachedStyledProperty(node))
           return;
-        context.report({
-          node: node.key,
-          messageId: "nesting"
-        });
+        const keyNode = node.key;
+        if (isInvalidNestingSelector(keyNode)) {
+          context.report({
+            node: keyNode,
+            messageId: "nesting"
+          });
+        }
       }
     };
   }
@@ -8849,7 +8992,7 @@ var no_invalid_nesting_default = rule8;
 
 // src/rules/no-invalid-token-paths.ts
 init_cjs_shims();
-var import_utils12 = require("@typescript-eslint/utils");
+var import_utils20 = require("@typescript-eslint/utils");
 var import_ast_utils2 = require("@typescript-eslint/utils/ast-utils");
 var RULE_NAME9 = "no-invalid-token-paths";
 var rule9 = createRule({
@@ -8861,87 +9004,89 @@ var rule9 = createRule({
     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))
-          return;
-        handleLiteral(node.value);
-        if (!isJSXExpressionContainer(node.value))
+        if (!node.value || !isPandaProp(node, context))
           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 (!(0, import_ast_utils2.isNodeOfTypes)([import_utils12.AST_NODE_TYPES.Literal, import_utils12.AST_NODE_TYPES.TemplateLiteral])(node.value))
+        if (!isIdentifier(node.key) || !(0, import_ast_utils2.isNodeOfTypes)([import_utils20.AST_NODE_TYPES.Literal, import_utils20.AST_NODE_TYPES.TemplateLiteral])(node.value) || !isPandaAttribute(node, context) || isRecipeVariant(node, context)) {
           return;
-        if (!isPandaAttribute(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)
+        if (!caller || !isPandaIsh(caller, context))
           return;
-        if (!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);
+            }
+          });
         });
       }
     };
@@ -8966,29 +9111,69 @@ var rule10 = createRule({
   },
   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);
       }
@@ -9043,11 +9228,11 @@ var rule11 = createRule({
   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,
@@ -9055,17 +9240,53 @@ var rule11 = createRule({
   },
   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: [
@@ -9076,7 +9297,7 @@ var rule11 = createRule({
               logical
             },
             fix: (fixer) => {
-              return fixer.replaceTextRange(node.range, logical);
+              return fixer.replaceText(node, logical);
             }
           }
         ]
@@ -9086,16 +9307,16 @@ var rule11 = createRule({
       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);
       }
@@ -9111,19 +9332,46 @@ var rule12 = createRule({
   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,
@@ -9133,10 +9381,9 @@ var rule12 = createRule({
     };
     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 {
@@ -9145,24 +9392,24 @@ var rule12 = createRule({
           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);
       }
     };
   }
@@ -9171,7 +9418,7 @@ var no_property_renaming_default = rule12;
 
 // src/rules/no-unsafe-token-fn-usage.ts
 init_cjs_shims();
-var import_utils17 = require("@typescript-eslint/utils");
+var import_utils25 = require("@typescript-eslint/utils");
 var import_shared3 = require("@pandacss/shared");
 var RULE_NAME13 = "no-unsafe-token-fn-usage";
 var rule13 = createRule({
@@ -9181,8 +9428,8 @@ var rule13 = createRule({
       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,
@@ -9190,11 +9437,42 @@ var rule13 = createRule({
   },
   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;
@@ -9202,17 +9480,12 @@ var rule13 = createRule({
         return;
       const value = node.arguments[0];
       if (isLiteral(value)) {
-        sendReport(node, tokenWrap((0, import_shared3.getArbitraryValue)(value.value?.toString() ?? "")));
+        const val = (0, import_shared3.getArbitraryValue)(value.value?.toString() ?? "");
+        sendReport(node, tokenWrap(val));
+      } else if (isTemplateLiteral(value) && value.expressions.length === 0) {
+        const val = (0, import_shared3.getArbitraryValue)(value.quasis[0].value.raw);
+        sendReport(node, tokenWrap(val));
       }
-      if (isTemplateLiteral(value)) {
-        sendReport(node, tokenWrap((0, import_shared3.getArbitraryValue)(value.quasis[0].value.raw)));
-      }
-    };
-    const isCompositeValue = (input) => {
-      if (!input)
-        return;
-      const tokenRegex = /^(?:token\([^)]*\)|\{[^}]*\})$/;
-      return !tokenRegex.test(input);
     };
     const handleLiteral = (node) => {
       if (!isLiteral(node))
@@ -9223,54 +9496,63 @@ var rule13 = createRule({
       sendReport(node, value);
     };
     const handleTemplateLiteral = (node) => {
-      if (!isTemplateLiteral(node))
-        return;
-      if (node.expressions.length > 0)
+      if (!isTemplateLiteral(node) || node.expressions.length > 0)
         return;
-      sendReport(node, (0, import_shared3.getArbitraryValue)(node.quasis[0].value.raw));
+      const value = (0, import_shared3.getArbitraryValue)(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))
-          return;
-        if (isRecipeVariant(node, context))
+        if (isCachedRecipeVariant(node))
           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);
+        }
       }
     };
   }
@@ -9287,8 +9569,8 @@ var rule14 = createRule({
       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,
@@ -9296,15 +9578,51 @@ var rule14 = createRule({
   },
   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,
@@ -9312,9 +9630,7 @@ var rule14 = createRule({
           {
             messageId: "replace",
             data,
-            fix: (fixer) => {
-              return fixer.replaceTextRange(node.range, longhand);
-            }
+            fix: (fixer) => fixer.replaceText(node, longhand)
           }
         ]
       });
@@ -9323,16 +9639,16 @@ var rule14 = createRule({
       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);
       }
@@ -9351,8 +9667,8 @@ var rule15 = createRule({
       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,
@@ -9360,19 +9676,64 @@ var rule15 = createRule({
   },
   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,
@@ -9380,9 +9741,7 @@ var rule15 = createRule({
           {
             messageId: "replace",
             data,
-            fix: (fixer) => {
-              return fixer.replaceTextRange(node.range, shorthands[0]);
-            }
+            fix: (fixer) => fixer.replaceText(node, shorthands[0])
           }
         ]
       });
@@ -9391,16 +9750,16 @@ var rule15 = createRule({
       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);
       }
@@ -9535,26 +9894,69 @@ var rule16 = createRule({
       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: {
@@ -9567,18 +9969,24 @@ var rule16 = createRule({
       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);
       }
     };
   }
@@ -9595,28 +10003,69 @@ var rule17 = createRule({
       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
         }
       });
@@ -9625,18 +10074,24 @@ var rule17 = createRule({
       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);
       }
     };
   }
@@ -9650,35 +10105,82 @@ var rule18 = createRule({
   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 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 sendReport = (node, cmp, siblings) => {
-      const _atomicProperties = siblings.filter((prop) => compositeProperties[cmp].includes(getLonghand(prop))).map((prop) => `\`${prop}\``);
-      if (!_atomicProperties.length)
+    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
         }
@@ -9688,30 +10190,30 @@ var rule18 = createRule({
       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);
       }
     };
   }