@pandacss/eslint-plugin 0.3.2 → 2.0.0-beta.10

package/dist/index.mjs

@@ -1,2834 +0,0 @@
-import {
-  __commonJS,
-  __esm,
-  init_esm_shims
-} from "./chunk-KBOB3H6E.mjs";
-
-// package.json
-var name, version;
-var init_package = __esm({
-  "package.json"() {
-    name = "@pandacss/eslint-plugin";
-    version = "0.3.2";
-  }
-});
-
-// src/utils/cache.ts
-import "@typescript-eslint/scope-manager";
-function ruleStarted() {
-  numRulesRunning++;
-  if (!resetMicrotaskScheduled) {
-    queueMicrotask(resetCacheMicrotask);
-    resetMicrotaskScheduled = true;
-  }
-}
-function ruleFinished() {
-  numRulesRunning--;
-  if (numRulesRunning === 0) {
-    resetCache();
-  }
-}
-function resetCache() {
-  cache.imports = null;
-  cache.scopeAnalysis = null;
-}
-function resetCacheMicrotask() {
-  resetCache();
-  numRulesRunning = 0;
-  resetMicrotaskScheduled = false;
-}
-var cache, numRulesRunning, resetMicrotaskScheduled;
-var init_cache = __esm({
-  "src/utils/cache.ts"() {
-    "use strict";
-    init_esm_shims();
-    cache = {
-      imports: null,
-      scopeAnalysis: null
-    };
-    numRulesRunning = 0;
-    resetMicrotaskScheduled = false;
-  }
-});
-
-// src/utils/index.ts
-import { ESLintUtils } from "@typescript-eslint/utils";
-import { createSyncFn } from "synckit";
-import { join } from "node:path";
-import { fileURLToPath } from "node:url";
-var _createRule, createRule, isBase, distDir, _syncAction, syncAction;
-var init_utils = __esm({
-  "src/utils/index.ts"() {
-    "use strict";
-    init_esm_shims();
-    init_cache();
-    _createRule = ESLintUtils.RuleCreator(
-      (name2) => `https://github.com/chakra-ui/eslint-plugin-panda/blob/main/docs/rules/${name2}.md`
-    );
-    createRule = (...args) => {
-      const rule20 = _createRule(...args);
-      const originalCreate = rule20.create;
-      rule20.create = (context) => {
-        ruleStarted();
-        const visitor = originalCreate(context);
-        const existingExit = visitor["Program:exit"];
-        if (existingExit) {
-          visitor["Program:exit"] = (node) => {
-            existingExit(node);
-            ruleFinished();
-          };
-        } else {
-          visitor["Program:exit"] = (_node) => ruleFinished();
-        }
-        return visitor;
-      };
-      return rule20;
-    };
-    isBase = process.env.NODE_ENV !== "test" || import.meta.url.includes("/dist/index");
-    distDir = fileURLToPath(new URL(isBase ? "./" : "../../dist", import.meta.url));
-    _syncAction = createSyncFn(join(distDir, "utils/worker.mjs"));
-    syncAction = (...args) => {
-      try {
-        return _syncAction(...args);
-      } catch (error) {
-        console.error("syncAction error:", error);
-        return void 0;
-      }
-    };
-  }
-});
-
-// src/utils/nodes.ts
-import { isNodeOfType } from "@typescript-eslint/utils/ast-utils";
-import { AST_NODE_TYPES } from "@typescript-eslint/utils";
-var isIdentifier, isLiteral, isTemplateLiteral, isArrayExpression, isObjectExpression, isMemberExpression, isVariableDeclarator, isVariableDeclaration, isJSXMemberExpression, isJSXOpeningElement, isJSXExpressionContainer, isJSXAttribute, isJSXIdentifier, isCallExpression, isImportDeclaration, isImportSpecifier, isProperty;
-var init_nodes = __esm({
-  "src/utils/nodes.ts"() {
-    "use strict";
-    init_esm_shims();
-    isIdentifier = isNodeOfType(AST_NODE_TYPES.Identifier);
-    isLiteral = isNodeOfType(AST_NODE_TYPES.Literal);
-    isTemplateLiteral = isNodeOfType(AST_NODE_TYPES.TemplateLiteral);
-    isArrayExpression = isNodeOfType(AST_NODE_TYPES.ArrayExpression);
-    isObjectExpression = isNodeOfType(AST_NODE_TYPES.ObjectExpression);
-    isMemberExpression = isNodeOfType(AST_NODE_TYPES.MemberExpression);
-    isVariableDeclarator = isNodeOfType(AST_NODE_TYPES.VariableDeclarator);
-    isVariableDeclaration = isNodeOfType(AST_NODE_TYPES.VariableDeclaration);
-    isJSXMemberExpression = isNodeOfType(AST_NODE_TYPES.JSXMemberExpression);
-    isJSXOpeningElement = isNodeOfType(AST_NODE_TYPES.JSXOpeningElement);
-    isJSXExpressionContainer = isNodeOfType(AST_NODE_TYPES.JSXExpressionContainer);
-    isJSXAttribute = isNodeOfType(AST_NODE_TYPES.JSXAttribute);
-    isJSXIdentifier = isNodeOfType(AST_NODE_TYPES.JSXIdentifier);
-    isCallExpression = isNodeOfType(AST_NODE_TYPES.CallExpression);
-    isImportDeclaration = isNodeOfType(AST_NODE_TYPES.ImportDeclaration);
-    isImportSpecifier = isNodeOfType(AST_NODE_TYPES.ImportSpecifier);
-    isProperty = isNodeOfType(AST_NODE_TYPES.Property);
-  }
-});
-
-// src/utils/helpers.ts
-import { analyze } from "@typescript-eslint/scope-manager";
-function isRecipeVariant(node, context) {
-  const caller = isInPandaFunction(node, context);
-  if (!caller) return;
-  const recipe = getImports(context).find((imp) => ["cva", "sva"].includes(imp.name) && imp.alias === caller);
-  if (!recipe) return;
-  let currentNode = node;
-  let length = 0;
-  let styleObjectParent = null;
-  while (currentNode) {
-    const keyName = currentNode?.key?.name;
-    if (keyName && ["base", "variants"].includes(keyName)) {
-      styleObjectParent = keyName;
-    }
-    currentNode = currentNode.parent;
-    if (!styleObjectParent) length++;
-  }
-  const isCvaCaller = caller === "cva";
-  const requiredLength = isCvaCaller ? 2 : 4;
-  const extraLength = styleObjectParent === "base" ? 0 : 4;
-  if (length < requiredLength + extraLength) return true;
-}
-var getAncestor, getSyncOpts, getImportSpecifiers, hasPkgImport, isPandaConfigFunction, _getImports, getImports, isValidStyledProp, isPandaIsh, findDeclaration, isLocalStyledFactory, isValidFile, isValidProperty, isPandaImport, isPandaProp, isStyledProperty, isInPandaFunction, isInJSXProp, isPandaAttribute, resolveLonghand, resolveShorthands, isColorAttribute, isColorToken, extractTokens, invalidTokensCache, getInvalidTokens, deprecatedTokensCache, getDeprecatedTokens, getTokenImport, getTaggedTemplateCaller;
-var init_helpers = __esm({
-  "src/utils/helpers.ts"() {
-    "use strict";
-    init_esm_shims();
-    init_utils();
-    init_cache();
-    init_nodes();
-    getAncestor = (ofType, for_) => {
-      let current = for_.parent;
-      while (current) {
-        if (ofType(current)) return current;
-        current = current.parent;
-      }
-      return;
-    };
-    getSyncOpts = (context) => {
-      return {
-        currentFile: context.filename,
-        configPath: context.settings["@pandacss/configPath"]
-      };
-    };
-    getImportSpecifiers = (context) => {
-      const specifiers = [];
-      context.sourceCode?.ast.body.forEach((node) => {
-        if (!isImportDeclaration(node)) return;
-        const mod = node.source.value;
-        if (!mod) return;
-        node.specifiers.forEach((specifier) => {
-          if (!isImportSpecifier(specifier)) return;
-          specifiers.push({ specifier, mod });
-        });
-      });
-      return specifiers;
-    };
-    hasPkgImport = (context) => {
-      const imports = _getImports(context);
-      return imports.some(({ mod }) => mod === "@pandacss/dev");
-    };
-    isPandaConfigFunction = (context, name2) => {
-      const imports = _getImports(context);
-      return imports.some(({ alias, mod }) => alias === name2 && mod === "@pandacss/dev");
-    };
-    _getImports = (context) => {
-      const specifiers = getImportSpecifiers(context);
-      const imports = specifiers.map(({ specifier, mod }) => ({
-        name: specifier.imported.name,
-        alias: specifier.local.name,
-        mod
-      }));
-      return imports;
-    };
-    getImports = (context) => {
-      if (cache.imports) {
-        return cache.imports;
-      }
-      const imports = _getImports(context);
-      const filteredImports = imports.filter((imp) => syncAction("matchImports", getSyncOpts(context), imp));
-      cache.imports = filteredImports;
-      return filteredImports;
-    };
-    isValidStyledProp = (node, context) => {
-      return isJSXIdentifier(node) && isValidProperty(node.name, context);
-    };
-    isPandaIsh = (name2, context) => {
-      const imports = getImports(context);
-      if (imports.length === 0) return false;
-      const jsxFactory = syncAction("getJsxFactory", getSyncOpts(context));
-      if (jsxFactory && name2 === jsxFactory) {
-        return imports.some((imp) => imp.name === name2 || imp.alias === name2);
-      }
-      return syncAction("matchFile", getSyncOpts(context), name2, imports);
-    };
-    findDeclaration = (name2, context) => {
-      try {
-        const src = context.sourceCode;
-        if (!src) {
-          console.warn("\u26A0\uFE0F ESLint's sourceCode is not available. Ensure that the rule is invoked with valid code.");
-          return void 0;
-        }
-        let scope;
-        if (cache.scopeAnalysis) {
-          scope = cache.scopeAnalysis;
-        } else {
-          scope = analyze(src.ast, {
-            sourceType: "module"
-          });
-          cache.scopeAnalysis = scope;
-        }
-        const decl = scope.variables.find((v) => v.name === name2)?.defs.find((d) => isIdentifier(d.name) && d.name.name === name2)?.node;
-        if (isVariableDeclarator(decl)) return decl;
-      } catch (error) {
-        console.error("Error in findDeclaration:", error);
-        return void 0;
-      }
-    };
-    isLocalStyledFactory = (node, context) => {
-      if (!isJSXIdentifier(node.name)) return;
-      const decl = findDeclaration(node.name.name, context);
-      if (!decl) return;
-      if (!isCallExpression(decl.init)) return;
-      if (!isIdentifier(decl.init.callee)) return;
-      if (!isPandaIsh(decl.init.callee.name, context)) return;
-      return true;
-    };
-    isValidFile = (context) => {
-      return syncAction("isValidFile", getSyncOpts(context));
-    };
-    isValidProperty = (name2, context, calleName) => {
-      return syncAction("isValidProperty", getSyncOpts(context), name2, calleName);
-    };
-    isPandaImport = (node, context) => {
-      const imports = getImports(context);
-      return imports.some((imp) => imp.mod === node.source.value);
-    };
-    isPandaProp = (node, context) => {
-      const jsxAncestor = getAncestor(isJSXOpeningElement, node);
-      if (!jsxAncestor) return;
-      if (!isJSXMemberExpression(jsxAncestor.name) && !isJSXIdentifier(jsxAncestor.name)) return;
-      const name2 = isJSXMemberExpression(jsxAncestor.name) ? jsxAncestor.name.object.name : jsxAncestor.name.name;
-      const prop = node.name.name;
-      const isPandaComponent = isPandaIsh(name2, context) || isLocalStyledFactory(jsxAncestor, context);
-      if (!isPandaComponent) return;
-      const patternName = isJSXMemberExpression(jsxAncestor.name) ? void 0 : name2;
-      if (typeof prop !== "string" || !isValidProperty(prop, context, patternName)) return;
-      return true;
-    };
-    isStyledProperty = (node, context, calleeName) => {
-      if (!isIdentifier(node.key) && !isLiteral(node.key) && !isTemplateLiteral(node.key)) return;
-      if (isIdentifier(node.key) && !isValidProperty(node.key.name, context, calleeName)) return;
-      if (isLiteral(node.key) && typeof node.key.value === "string" && !isValidProperty(node.key.value, context, calleeName))
-        return;
-      if (isTemplateLiteral(node.key) && !isValidProperty(node.key.quasis[0].value.raw, context, calleeName)) return;
-      return true;
-    };
-    isInPandaFunction = (node, context) => {
-      const callAncestor = getAncestor(isCallExpression, node);
-      if (!callAncestor) return;
-      let calleeName;
-      if (isIdentifier(callAncestor.callee)) {
-        calleeName = callAncestor.callee.name;
-      }
-      if (isMemberExpression(callAncestor.callee) && isIdentifier(callAncestor.callee.object)) {
-        calleeName = callAncestor.callee.object.name;
-      }
-      if (!calleeName) return;
-      if (!isPandaIsh(calleeName, context)) return;
-      return calleeName;
-    };
-    isInJSXProp = (node, context) => {
-      const jsxExprAncestor = getAncestor(isJSXExpressionContainer, node);
-      const jsxAttrAncestor = getAncestor(isJSXAttribute, node);
-      if (!jsxExprAncestor || !jsxAttrAncestor) return;
-      if (!isPandaProp(jsxAttrAncestor, context)) return;
-      if (typeof jsxAttrAncestor.name === "string") return;
-      if (!isValidStyledProp(jsxAttrAncestor.name, context)) return;
-      return true;
-    };
-    isPandaAttribute = (node, context) => {
-      const callAncestor = getAncestor(isCallExpression, node);
-      if (callAncestor) {
-        const callee = isInPandaFunction(node, context);
-        if (!callee) return;
-        return isStyledProperty(node, context, callee);
-      }
-      return isInJSXProp(node, context) && isStyledProperty(node, context);
-    };
-    resolveLonghand = (name2, context) => {
-      return syncAction("resolveLongHand", getSyncOpts(context), name2);
-    };
-    resolveShorthands = (name2, context) => {
-      return syncAction("resolveShorthands", getSyncOpts(context), name2);
-    };
-    isColorAttribute = (attr, context) => {
-      return syncAction("isColorAttribute", getSyncOpts(context), attr);
-    };
-    isColorToken = (value, context) => {
-      if (!value) return;
-      return syncAction("isColorToken", getSyncOpts(context), value);
-    };
-    extractTokens = (value) => {
-      const regex = /token\(([^"'(),]+)(?:,\s*([^"'(),]+))?\)|\{([^{\r\n}]+)\}/g;
-      const matches = [];
-      let match;
-      while ((match = regex.exec(value)) !== null) {
-        const tokenFromFirstSyntax = match[1] || match[2] || match[3];
-        const tokensFromSecondSyntax = match[4] && match[4].match(/(\w+\.\w+(\.\w+)?)/g);
-        if (tokenFromFirstSyntax) {
-          matches.push(tokenFromFirstSyntax);
-        }
-        if (tokensFromSecondSyntax) {
-          matches.push(...tokensFromSecondSyntax);
-        }
-      }
-      return matches.filter(Boolean);
-    };
-    invalidTokensCache = /* @__PURE__ */ new Map();
-    getInvalidTokens = (value, context) => {
-      if (invalidTokensCache.has(value)) {
-        return invalidTokensCache.get(value);
-      }
-      const tokens = extractTokens(value);
-      if (!tokens.length) return [];
-      const invalidTokens = syncAction("filterInvalidTokens", getSyncOpts(context), tokens);
-      invalidTokensCache.set(value, invalidTokens);
-      return invalidTokens;
-    };
-    deprecatedTokensCache = /* @__PURE__ */ new Map();
-    getDeprecatedTokens = (prop, value, context) => {
-      if (deprecatedTokensCache.has(value)) {
-        return deprecatedTokensCache.get(value);
-      }
-      const propCategory = syncAction("getPropCategory", getSyncOpts(context), prop);
-      const tokens = extractTokens(value);
-      if (!propCategory && !tokens.length) return [];
-      const values = tokens.length ? tokens : [{ category: propCategory, value: value.split("/")[0] }];
-      const deprecatedTokens = syncAction("filterDeprecatedTokens", getSyncOpts(context), values);
-      deprecatedTokensCache.set(value, deprecatedTokens);
-      return deprecatedTokens;
-    };
-    getTokenImport = (context) => {
-      const imports = _getImports(context);
-      return imports.find((imp) => imp.name === "token");
-    };
-    getTaggedTemplateCaller = (node) => {
-      if (isIdentifier(node.tag)) {
-        return node.tag.name;
-      }
-      if (isMemberExpression(node.tag)) {
-        if (!isIdentifier(node.tag.object)) return;
-        return node.tag.object.name;
-      }
-      if (isCallExpression(node.tag)) {
-        if (!isIdentifier(node.tag.callee)) return;
-        return node.tag.callee.name;
-      }
-    };
-  }
-});
-
-// 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"() {
-    "use strict";
-    init_esm_shims();
-    init_utils();
-    init_helpers();
-    RULE_NAME = "file-not-included";
-    rule = createRule({
-      name: RULE_NAME,
-      meta: {
-        docs: {
-          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 ensure the file is included in the Panda CSS `include` configuration."
-        },
-        type: "problem",
-        schema: []
-      },
-      defaultOptions: [],
-      create(context) {
-        const isFileIncluded = isValidFile(context);
-        if (isFileIncluded) {
-          return {};
-        }
-        let hasReported = false;
-        return {
-          ImportDeclaration(node) {
-            if (hasReported) return;
-            if (!isPandaImport(node, context)) return;
-            context.report({
-              node,
-              messageId: "include"
-            });
-            hasReported = true;
-          }
-        };
-      }
-    });
-    file_not_included_default = rule;
-  }
-});
-
-// src/rules/no-config-function-in-source.ts
-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";
-    init_esm_shims();
-    init_nodes();
-    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 file."
-        },
-        messages: {
-          configFunction: "Unnecessary `{{name}}` call. Config functions should only be used in the Panda config file.",
-          delete: "Delete `{{name}}` call."
-        },
-        type: "problem",
-        hasSuggestions: true,
-        schema: []
-      },
-      defaultOptions: [],
-      create(context) {
-        if (!hasPkgImport(context)) {
-          return {};
-        }
-        const isPandaFile = isValidFile(context);
-        if (!isPandaFile) {
-          return {};
-        }
-        return {
-          CallExpression(node) {
-            if (!isIdentifier(node.callee)) return;
-            const functionName = node.callee.name;
-            if (!CONFIG_FUNCTIONS.has(functionName)) return;
-            if (!isPandaConfigFunction(context, functionName)) return;
-            context.report({
-              node,
-              messageId: "configFunction",
-              data: {
-                name: functionName
-              },
-              suggest: [
-                {
-                  messageId: "delete",
-                  data: {
-                    name: functionName
-                  },
-                  fix(fixer) {
-                    const declaration = getAncestor(isVariableDeclaration, node);
-                    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;
-                  }
-                }
-              ]
-            });
-          }
-        };
-      }
-    });
-    no_config_function_in_source_default = rule2;
-  }
-});
-
-// 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_utils();
-    init_helpers();
-    RULE_NAME3 = "no-debug";
-    rule3 = createRule({
-      name: RULE_NAME3,
-      meta: {
-        docs: {
-          description: "Disallow the inclusion of the debug attribute when shipping code to the production environment."
-        },
-        messages: {
-          debug: "Unnecessary debug utility.",
-          prop: "Remove the debug prop.",
-          property: "Remove the debug property."
-        },
-        type: "problem",
-        hasSuggestions: true,
-        schema: []
-      },
-      defaultOptions: [],
-      create(context) {
-        return {
-          'JSXAttribute[name.name="debug"]'(node) {
-            if (!isPandaProp(node, context)) return;
-            context.report({
-              node,
-              messageId: "debug",
-              suggest: [
-                {
-                  messageId: "prop",
-                  fix: (fixer) => fixer.remove(node)
-                }
-              ]
-            });
-          },
-          'Property[key.name="debug"]'(node) {
-            if (!isPandaAttribute(node, context)) return;
-            if (isRecipeVariant(node, context)) return;
-            context.report({
-              node: node.key,
-              messageId: "debug",
-              suggest: [
-                {
-                  messageId: "property",
-                  fix: (fixer) => fixer.removeRange([node.range[0], node.range[1] + 1])
-                }
-              ]
-            });
-          }
-        };
-      }
-    });
-    no_debug_default = rule3;
-  }
-});
-
-// src/rules/no-deprecated-tokens.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES2 } from "@typescript-eslint/utils";
-import { isNodeOfTypes } from "@typescript-eslint/utils/ast-utils";
-var RULE_NAME4, rule4, no_deprecated_tokens_default;
-var init_no_deprecated_tokens = __esm({
-  "src/rules/no-deprecated-tokens.ts"() {
-    "use strict";
-    init_esm_shims();
-    init_helpers();
-    init_utils();
-    init_nodes();
-    RULE_NAME4 = "no-deprecated-tokens";
-    rule4 = createRule({
-      name: RULE_NAME4,
-      meta: {
-        docs: {
-          description: "Disallow the use of deprecated tokens within token function syntax."
-        },
-        messages: {
-          noDeprecatedTokenPaths: "`{{token}}` is a deprecated token.",
-          noDeprecatedTokens: "`{{token}}` is a deprecated {{category}} token."
-        },
-        type: "problem",
-        schema: []
-      },
-      defaultOptions: [],
-      create(context) {
-        const deprecatedTokensCache2 = /* @__PURE__ */ new Map();
-        const sendReport = (prop, node, value) => {
-          if (!value) return;
-          let tokens = deprecatedTokensCache2.get(value);
-          if (!tokens) {
-            tokens = getDeprecatedTokens(prop, value, context);
-            deprecatedTokensCache2.set(value, tokens);
-          }
-          if (tokens.length === 0) return;
-          tokens.forEach((token) => {
-            context.report({
-              node,
-              messageId: typeof token === "string" ? "noDeprecatedTokenPaths" : "noDeprecatedTokens",
-              data: {
-                token: typeof token === "string" ? token : token.value,
-                category: typeof token === "string" ? void 0 : token.category
-              }
-            });
-          });
-        };
-        const handleLiteralOrTemplate = (prop, node) => {
-          if (!node) return;
-          if (isLiteral(node)) {
-            const value = node.value?.toString();
-            sendReport(prop, node, value);
-          } else if (isTemplateLiteral(node) && node.expressions.length === 0) {
-            const value = node.quasis[0].value.raw;
-            sendReport(prop, node.quasis[0], value);
-          }
-        };
-        return {
-          JSXAttribute(node) {
-            if (!node.value || !isPandaProp(node, context)) return;
-            const prop = node.name.name;
-            if (isLiteral(node.value)) {
-              handleLiteralOrTemplate(prop, node.value);
-            } else if (isJSXExpressionContainer(node.value)) {
-              handleLiteralOrTemplate(prop, node.value.expression);
-            }
-          },
-          Property(node) {
-            if (!isIdentifier(node.key) || !isNodeOfTypes([AST_NODE_TYPES2.Literal, AST_NODE_TYPES2.TemplateLiteral])(node.value) || !isPandaAttribute(node, context) || isRecipeVariant(node, context)) {
-              return;
-            }
-            const prop = node.key.name;
-            handleLiteralOrTemplate(prop, node.value);
-          },
-          TaggedTemplateExpression(node) {
-            const caller = getTaggedTemplateCaller(node);
-            if (!caller || !isPandaIsh(caller, context)) return;
-            const quasis = node.quasi.quasis;
-            quasis.forEach((quasi) => {
-              const styles = quasi.value.raw;
-              if (!styles) return;
-              let tokens = deprecatedTokensCache2.get(styles);
-              if (!tokens) {
-                tokens = getDeprecatedTokens("", styles, context);
-                deprecatedTokensCache2.set(styles, tokens);
-              }
-              if (tokens.length === 0) return;
-              tokens.forEach((token) => {
-                const tokenValue = typeof token === "string" ? token : token.value;
-                let index = styles.indexOf(tokenValue);
-                while (index !== -1) {
-                  const start = quasi.range[0] + index + 1;
-                  const end = start + tokenValue.length;
-                  context.report({
-                    loc: {
-                      start: context.sourceCode.getLocFromIndex(start),
-                      end: context.sourceCode.getLocFromIndex(end)
-                    },
-                    messageId: typeof token === "string" ? "noDeprecatedTokenPaths" : "noDeprecatedTokens",
-                    data: {
-                      token: tokenValue,
-                      category: typeof token === "string" ? void 0 : token.category
-                    }
-                  });
-                  index = styles.indexOf(tokenValue, index + tokenValue.length);
-                }
-              });
-            });
-          }
-        };
-      }
-    });
-    no_deprecated_tokens_default = rule4;
-  }
-});
-
-// src/rules/no-dynamic-styling.ts
-import "@typescript-eslint/utils";
-var RULE_NAME5, rule5, no_dynamic_styling_default;
-var init_no_dynamic_styling = __esm({
-  "src/rules/no-dynamic-styling.ts"() {
-    "use strict";
-    init_esm_shims();
-    init_utils();
-    init_helpers();
-    init_nodes();
-    RULE_NAME5 = "no-dynamic-styling";
-    rule5 = createRule({
-      name: RULE_NAME5,
-      meta: {
-        docs: {
-          description: "Ensure users don't use dynamic styling. Prefer static styles, leverage CSS variables, or recipes for known dynamic styles."
-        },
-        messages: {
-          dynamic: "Remove dynamic value. Prefer static styles.",
-          dynamicProperty: "Remove dynamic property. Prefer static style property.",
-          dynamicRecipeVariant: "Remove dynamic variant. Prefer static variant definition."
-        },
-        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 (!isPandaProp(node, context)) return;
-            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 with computed keys
-          "Property[computed=true]": (node) => {
-            if (!isInPandaFunction(node, context)) return;
-            context.report({
-              node: node.key,
-              messageId: isRecipeVariant(node, context) ? "dynamicRecipeVariant" : "dynamicProperty"
-            });
-          },
-          // Object Properties
-          Property(node) {
-            if (!isIdentifier(node.key)) return;
-            if (!isPandaAttribute(node, context)) return;
-            if (isRecipeVariant(node, context)) return;
-            if (isStaticValue(node.value)) return;
-            if (isArrayExpression(node.value)) {
-              checkArrayElements(node.value);
-              return;
-            }
-            context.report({
-              node: node.value,
-              messageId: "dynamic"
-            });
-          }
-        };
-      }
-    });
-    no_dynamic_styling_default = rule5;
-  }
-});
-
-// src/rules/no-escape-hatch.ts
-import { getArbitraryValue } from "@pandacss/shared";
-import "@typescript-eslint/utils";
-var RULE_NAME6, rule6, no_escape_hatch_default;
-var init_no_escape_hatch = __esm({
-  "src/rules/no-escape-hatch.ts"() {
-    "use strict";
-    init_esm_shims();
-    init_helpers();
-    init_utils();
-    init_nodes();
-    RULE_NAME6 = "no-escape-hatch";
-    rule6 = createRule({
-      name: RULE_NAME6,
-      meta: {
-        docs: {
-          description: "Prohibit the use of escape hatch syntax in the code."
-        },
-        messages: {
-          escapeHatch: "Avoid using the escape hatch [value] for undefined tokens. Define a corresponding token in your design system for better consistency and maintainability.",
-          remove: "Remove the square brackets (`[]`)."
-        },
-        type: "problem",
-        hasSuggestions: true,
-        schema: []
-      },
-      defaultOptions: [],
-      create(context) {
-        const removeBrackets = (range) => {
-          const [start, end] = range;
-          return [start + 1, end - 1];
-        };
-        const hasEscapeHatch = (value) => {
-          if (!value) return false;
-          if (!value.includes("[")) return false;
-          return getArbitraryValue(value) !== value.trim();
-        };
-        const handleNodeValue = (node, value) => {
-          if (!hasEscapeHatch(value)) return;
-          context.report({
-            node,
-            messageId: "escapeHatch",
-            suggest: [
-              {
-                messageId: "remove",
-                fix: (fixer) => {
-                  return fixer.replaceTextRange(removeBrackets(node.range), getArbitraryValue(value));
-                }
-              }
-            ]
-          });
-        };
-        return {
-          JSXAttribute(node) {
-            if (!node.value) return;
-            if (!isPandaProp(node, context)) return;
-            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 (!isPandaAttribute(node, context)) return;
-            if (isRecipeVariant(node, context)) return;
-            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);
-            }
-          }
-        };
-      }
-    });
-    no_escape_hatch_default = rule6;
-  }
-});
-
-// src/rules/no-hardcoded-color.ts
-import "@typescript-eslint/utils";
-var RULE_NAME7, rule7, no_hardcoded_color_default;
-var init_no_hardcoded_color = __esm({
-  "src/rules/no-hardcoded-color.ts"() {
-    "use strict";
-    init_esm_shims();
-    init_helpers();
-    init_utils();
-    init_nodes();
-    RULE_NAME7 = "no-hardcoded-color";
-    rule7 = createRule({
-      name: RULE_NAME7,
-      meta: {
-        docs: {
-          description: "Enforce the exclusive use of design tokens as values for colors within the codebase."
-        },
-        messages: {
-          invalidColor: "`{{color}}` is not a valid color token."
-        },
-        type: "problem",
-        schema: [
-          {
-            type: "object",
-            properties: {
-              noOpacity: {
-                type: "boolean"
-              },
-              whitelist: {
-                type: "array",
-                items: {
-                  type: "string",
-                  minLength: 0
-                },
-                uniqueItems: true
-              }
-            },
-            additionalProperties: false
-          }
-        ]
-      },
-      defaultOptions: [
-        {
-          noOpacity: false,
-          whitelist: []
-        }
-      ],
-      create(context) {
-        const noOpacity = context.options[0]?.noOpacity;
-        const whitelist = context.options[0]?.whitelist ?? [];
-        const colorTokenCache = new Map(whitelist?.map((item) => [item, true]));
-        const colorAttributeCache = /* @__PURE__ */ new Map();
-        const 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 isCssVariable = (value) => {
-          if (!value) return false;
-          return value.trim().startsWith("var(");
-        };
-        const isValidColorToken = (value) => {
-          if (!value) return false;
-          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 (isCssVariable(value)) return;
-          if (isValidColorToken(value)) return;
-          reportInvalidColor(node, value);
-        };
-        return {
-          JSXAttribute(node) {
-            if (!isJSXIdentifier(node.name)) return;
-            if (!isPandaProp(node, context) || !node.value) return;
-            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 (!isPandaAttribute(node, context)) return;
-            if (isRecipeVariant(node, context)) return;
-            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);
-            }
-          }
-        };
-      }
-    });
-    no_hardcoded_color_default = rule7;
-  }
-});
-
-// src/rules/no-important.ts
-import { getArbitraryValue as getArbitraryValue2 } from "@pandacss/shared";
-import "@typescript-eslint/utils";
-var exclamationRegex, importantRegex, RULE_NAME8, rule8, no_important_default;
-var init_no_important = __esm({
-  "src/rules/no-important.ts"() {
-    "use strict";
-    init_esm_shims();
-    init_helpers();
-    init_utils();
-    init_nodes();
-    exclamationRegex = /\s*!$/;
-    importantRegex = /\s*!important\s*$/;
-    RULE_NAME8 = "no-important";
-    rule8 = createRule({
-      name: RULE_NAME8,
-      meta: {
-        docs: {
-          description: "Disallow usage of !important keyword. Prioritize specificity for a maintainable and predictable styling structure."
-        },
-        messages: {
-          important: "Avoid using the {{keyword}} keyword. Refactor your code to prioritize specificity for predictable styling.",
-          remove: "Remove the `{{keyword}}` keyword."
-        },
-        type: "problem",
-        hasSuggestions: true,
-        schema: []
-      },
-      defaultOptions: [],
-      create(context) {
-        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 arbitraryValue = getArbitraryValue2(value);
-          return exclamationRegex.test(arbitraryValue) || importantRegex.test(arbitraryValue);
-        };
-        const removeImportantKeyword = (input) => {
-          if (importantRegex.test(input)) {
-            return { fixed: input.replace(importantRegex, "").trimEnd(), keyword: "!important" };
-          } else if (exclamationRegex.test(input)) {
-            return { fixed: input.replace(exclamationRegex, "").trimEnd(), keyword: "!" };
-          } else {
-            return { fixed: input, keyword: null };
-          }
-        };
-        const handleNodeValue = (node, value) => {
-          if (!hasImportantKeyword(value)) return;
-          const { fixed, keyword } = removeImportantKeyword(value);
-          context.report({
-            node,
-            messageId: "important",
-            data: { keyword },
-            suggest: [
-              {
-                messageId: "remove",
-                data: { keyword },
-                fix: (fixer) => {
-                  return fixer.replaceTextRange(removeQuotes(node.range), fixed);
-                }
-              }
-            ]
-          });
-        };
-        return {
-          // JSX Attributes
-          JSXAttribute(node) {
-            if (!node.value) return;
-            if (!isCachedPandaProp(node)) return;
-            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 (!isCachedPandaAttribute(node)) return;
-            if (isCachedRecipeVariant(node)) return;
-            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);
-            }
-          }
-        };
-      }
-    });
-    no_important_default = rule8;
-  }
-});
-
-// src/rules/no-invalid-nesting.ts
-import "@typescript-eslint/utils";
-var RULE_NAME9, rule9, no_invalid_nesting_default;
-var init_no_invalid_nesting = __esm({
-  "src/rules/no-invalid-nesting.ts"() {
-    "use strict";
-    init_esm_shims();
-    init_nodes();
-    init_utils();
-    init_helpers();
-    RULE_NAME9 = "no-invalid-nesting";
-    rule9 = createRule({
-      name: RULE_NAME9,
-      meta: {
-        docs: {
-          description: "Warn against invalid nesting. Nested styles must contain the `&` character."
-        },
-        messages: {
-          nesting: "Invalid style nesting. Nested styles must contain the `&` character."
-        },
-        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 {
-          // 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 (isCachedRecipeVariant(node)) return;
-            if (isCachedStyledProperty(node)) return;
-            const keyNode = node.key;
-            if (isInvalidNestingSelector(keyNode)) {
-              context.report({
-                node: keyNode,
-                messageId: "nesting"
-              });
-            }
-          }
-        };
-      }
-    });
-    no_invalid_nesting_default = rule9;
-  }
-});
-
-// src/rules/no-invalid-token-paths.ts
-import { AST_NODE_TYPES as AST_NODE_TYPES3 } from "@typescript-eslint/utils";
-import { isNodeOfTypes as isNodeOfTypes2 } from "@typescript-eslint/utils/ast-utils";
-var RULE_NAME10, rule10, no_invalid_token_paths_default;
-var init_no_invalid_token_paths = __esm({
-  "src/rules/no-invalid-token-paths.ts"() {
-    "use strict";
-    init_esm_shims();
-    init_helpers();
-    init_utils();
-    init_nodes();
-    RULE_NAME10 = "no-invalid-token-paths";
-    rule10 = createRule({
-      name: RULE_NAME10,
-      meta: {
-        docs: {
-          description: "Disallow the use of invalid token paths within token function syntax."
-        },
-        messages: {
-          noInvalidTokenPaths: "`{{token}}` is an invalid token path."
-        },
-        type: "problem",
-        schema: []
-      },
-      defaultOptions: [],
-      create(context) {
-        const invalidTokensCache2 = /* @__PURE__ */ new Map();
-        const sendReport = (node, value) => {
-          if (!value) return;
-          let tokens = invalidTokensCache2.get(value);
-          if (!tokens) {
-            tokens = getInvalidTokens(value, context);
-            invalidTokensCache2.set(value, tokens);
-          }
-          if (tokens.length === 0) return;
-          tokens.forEach((token) => {
-            context.report({
-              node,
-              messageId: "noInvalidTokenPaths",
-              data: { token }
-            });
-          });
-        };
-        const handleLiteralOrTemplate = (node) => {
-          if (!node) return;
-          if (isLiteral(node)) {
-            const value = node.value?.toString();
-            sendReport(node, value);
-          } else if (isTemplateLiteral(node) && node.expressions.length === 0) {
-            const value = node.quasis[0].value.raw;
-            sendReport(node.quasis[0], value);
-          }
-        };
-        return {
-          JSXAttribute(node) {
-            if (!node.value || !isPandaProp(node, context)) return;
-            if (isLiteral(node.value)) {
-              handleLiteralOrTemplate(node.value);
-            } else if (isJSXExpressionContainer(node.value)) {
-              handleLiteralOrTemplate(node.value.expression);
-            }
-          },
-          Property(node) {
-            if (!isIdentifier(node.key) || !isNodeOfTypes2([AST_NODE_TYPES3.Literal, AST_NODE_TYPES3.TemplateLiteral])(node.value) || !isPandaAttribute(node, context) || isRecipeVariant(node, context)) {
-              return;
-            }
-            handleLiteralOrTemplate(node.value);
-          },
-          TaggedTemplateExpression(node) {
-            const caller = getTaggedTemplateCaller(node);
-            if (!caller || !isPandaIsh(caller, context)) return;
-            const quasis = node.quasi.quasis;
-            quasis.forEach((quasi) => {
-              const styles = quasi.value.raw;
-              if (!styles) return;
-              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);
-                }
-              });
-            });
-          }
-        };
-      }
-    });
-    no_invalid_token_paths_default = rule10;
-  }
-});
-
-// src/rules/no-margin-properties.ts
-var RULE_NAME11, rule11, no_margin_properties_default;
-var init_no_margin_properties = __esm({
-  "src/rules/no-margin-properties.ts"() {
-    "use strict";
-    init_esm_shims();
-    init_helpers();
-    init_utils();
-    init_nodes();
-    RULE_NAME11 = "no-margin-properties";
-    rule11 = createRule({
-      name: RULE_NAME11,
-      meta: {
-        docs: {
-          description: "Discourage using margin properties for spacing; prefer defining spacing in parent elements with `flex` or `grid` using the `gap` property for a more resilient layout. Margins make components less reusable in other contexts."
-        },
-        messages: {
-          noMargin: "Use flex or grid with the `gap` property to define spacing in parent elements for a more resilient layout."
-        },
-        type: "suggestion",
-        schema: [
-          {
-            type: "object",
-            properties: {
-              whitelist: {
-                type: "array",
-                items: {
-                  type: "string",
-                  minLength: 0
-                },
-                uniqueItems: true
-              }
-            },
-            additionalProperties: false
-          }
-        ]
-      },
-      defaultOptions: [
-        {
-          whitelist: []
-        }
-      ],
-      create(context) {
-        const whitelist = context.options[0]?.whitelist ?? [];
-        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 (whitelist.includes(node.name)) return;
-          if (!isMarginProperty(node.name)) return;
-          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 (!isCachedPandaProp(node)) return;
-            sendReport(node.name);
-          },
-          Property(node) {
-            if (!isIdentifier(node.key)) return;
-            if (!isCachedPandaAttribute(node)) return;
-            if (isCachedRecipeVariant(node)) return;
-            sendReport(node.key);
-          }
-        };
-      }
-    });
-    no_margin_properties_default = rule11;
-  }
-});
-
-// src/utils/physical-properties.ts
-var physicalProperties, physicalPropertyValues;
-var init_physical_properties = __esm({
-  "src/utils/physical-properties.ts"() {
-    "use strict";
-    init_esm_shims();
-    physicalProperties = {
-      borderBottom: "borderBlockEnd",
-      borderBottomColor: "borderBlockEndColor",
-      borderBottomStyle: "borderBlockEndStyle",
-      borderBottomWidth: "borderBlockEndWidth",
-      borderTop: "borderBlockStart",
-      borderTopColor: "borderBlockStartColor",
-      borderTopStyle: "borderBlockStartStyle",
-      borderTopWidth: "borderBlockStartWidth",
-      borderRight: "borderInlineEnd",
-      borderRightColor: "borderInlineEndColor",
-      borderRightStyle: "borderInlineEndStyle",
-      borderRightWidth: "borderInlineEndWidth",
-      borderLeft: "borderInlineStart",
-      borderLeftColor: "borderInlineStartColor",
-      borderLeftStyle: "borderInlineStartStyle",
-      borderLeftWidth: "borderInlineStartWidth",
-      borderTopLeftRadius: "borderStartStartRadius",
-      borderBottomLeftRadius: "borderEndStartRadius",
-      borderTopRightRadius: "borderStartEndRadius",
-      borderBottomRightRadius: "borderEndEndRadius",
-      marginBottom: "marginBlockEnd",
-      marginTop: "marginBlockStart",
-      marginRight: "marginInlineEnd",
-      marginLeft: "marginInlineStart",
-      paddingBottom: "paddingBlockEnd",
-      paddingTop: "paddingBlockStart",
-      paddingRight: "paddingInlineEnd",
-      paddingLeft: "paddingInlineStart",
-      left: "insetInlineStart",
-      right: "insetInlineEnd",
-      top: "insetBlockStart",
-      bottom: "insetBlockEnd"
-    };
-    physicalPropertyValues = {
-      // text-align physical values mapped to logical values
-      textAlign: {
-        left: "start",
-        right: "end"
-      }
-    };
-  }
-});
-
-// src/rules/no-physical-properties.ts
-var RULE_NAME12, MESSAGES, PropertyCache, extractStringLiteralValue, createPropertyReport, createValueReport, rule12, no_physical_properties_default;
-var init_no_physical_properties = __esm({
-  "src/rules/no-physical-properties.ts"() {
-    "use strict";
-    init_esm_shims();
-    init_helpers();
-    init_utils();
-    init_nodes();
-    init_physical_properties();
-    RULE_NAME12 = "no-physical-properties";
-    MESSAGES = {
-      physical: "Use logical property instead of {{physical}}. Prefer `{{logical}}`.",
-      physicalValue: "Use logical value instead of {{physical}}. Prefer `{{logical}}`.",
-      replace: "Replace `{{physical}}` with `{{logical}}`."
-    };
-    PropertyCache = class {
-      longhandCache = /* @__PURE__ */ new Map();
-      pandaPropCache = /* @__PURE__ */ new WeakMap();
-      pandaAttributeCache = /* @__PURE__ */ new WeakMap();
-      recipeVariantCache = /* @__PURE__ */ new WeakMap();
-      getLonghand(name2, context) {
-        if (this.longhandCache.has(name2)) {
-          return this.longhandCache.get(name2);
-        }
-        const longhand = resolveLonghand(name2, context) ?? name2;
-        this.longhandCache.set(name2, longhand);
-        return longhand;
-      }
-      isPandaProp(node, context) {
-        if (this.pandaPropCache.has(node)) {
-          return this.pandaPropCache.get(node);
-        }
-        const result = isPandaProp(node, context);
-        this.pandaPropCache.set(node, result);
-        return !!result;
-      }
-      isPandaAttribute(node, context) {
-        if (this.pandaAttributeCache.has(node)) {
-          return this.pandaAttributeCache.get(node);
-        }
-        const result = isPandaAttribute(node, context);
-        this.pandaAttributeCache.set(node, result);
-        return !!result;
-      }
-      isRecipeVariant(node, context) {
-        if (this.recipeVariantCache.has(node)) {
-          return this.recipeVariantCache.get(node);
-        }
-        const result = isRecipeVariant(node, context);
-        this.recipeVariantCache.set(node, result);
-        return !!result;
-      }
-    };
-    extractStringLiteralValue = (valueNode) => {
-      if (isLiteral(valueNode) && typeof valueNode.value === "string") {
-        return valueNode.value;
-      }
-      if (isJSXExpressionContainer(valueNode) && isLiteral(valueNode.expression) && typeof valueNode.expression.value === "string") {
-        return valueNode.expression.value;
-      }
-      return null;
-    };
-    createPropertyReport = (node, longhandName, logical, context) => {
-      const physicalName = `\`${node.name}\`${longhandName !== node.name ? ` (resolved to \`${longhandName}\`)` : ""}`;
-      context.report({
-        node,
-        messageId: "physical",
-        data: { physical: physicalName, logical },
-        suggest: [
-          {
-            messageId: "replace",
-            data: { physical: node.name, logical },
-            fix: (fixer) => fixer.replaceText(node, logical)
-          }
-        ]
-      });
-    };
-    createValueReport = (valueNode, valueText, logical, context) => {
-      context.report({
-        node: valueNode,
-        messageId: "physicalValue",
-        data: { physical: `"${valueText}"`, logical: `"${logical}"` },
-        suggest: [
-          {
-            messageId: "replace",
-            data: { physical: `"${valueText}"`, logical: `"${logical}"` },
-            fix: (fixer) => {
-              if (isLiteral(valueNode)) {
-                return fixer.replaceText(valueNode, `"${logical}"`);
-              }
-              if (isJSXExpressionContainer(valueNode) && isLiteral(valueNode.expression)) {
-                return fixer.replaceText(valueNode.expression, `"${logical}"`);
-              }
-              return null;
-            }
-          }
-        ]
-      });
-    };
-    rule12 = createRule({
-      name: RULE_NAME12,
-      meta: {
-        docs: {
-          description: "Encourage the use of logical properties over physical properties to foster a responsive and adaptable user interface."
-        },
-        messages: MESSAGES,
-        type: "suggestion",
-        hasSuggestions: true,
-        schema: [
-          {
-            type: "object",
-            properties: {
-              whitelist: {
-                type: "array",
-                items: {
-                  type: "string",
-                  minLength: 0
-                },
-                uniqueItems: true
-              }
-            },
-            additionalProperties: false
-          }
-        ]
-      },
-      defaultOptions: [{ whitelist: [] }],
-      create(context) {
-        const whitelist = context.options[0]?.whitelist ?? [];
-        const cache2 = new PropertyCache();
-        const checkPropertyName = (node) => {
-          if (whitelist.includes(node.name)) return;
-          const longhandName = cache2.getLonghand(node.name, context);
-          if (!(longhandName in physicalProperties)) return;
-          const logical = physicalProperties[longhandName];
-          createPropertyReport(node, longhandName, logical, context);
-        };
-        const checkPropertyValue = (keyNode, valueNode) => {
-          const propName = keyNode.name;
-          if (!(propName in physicalPropertyValues)) return false;
-          const valueText = extractStringLiteralValue(valueNode);
-          if (valueText === null) return false;
-          const valueMap = physicalPropertyValues[propName];
-          if (!valueMap[valueText]) return false;
-          createValueReport(valueNode, valueText, valueMap[valueText], context);
-          return true;
-        };
-        return {
-          JSXAttribute(node) {
-            if (!isJSXIdentifier(node.name)) return;
-            if (!cache2.isPandaProp(node, context)) return;
-            checkPropertyName(node.name);
-            if (node.value) {
-              checkPropertyValue(node.name, node.value);
-            }
-          },
-          Property(node) {
-            if (!isIdentifier(node.key)) return;
-            if (!cache2.isPandaAttribute(node, context)) return;
-            if (cache2.isRecipeVariant(node, context)) return;
-            checkPropertyName(node.key);
-            if (node.value) {
-              checkPropertyValue(node.key, node.value);
-            }
-          }
-        };
-      }
-    });
-    no_physical_properties_default = rule12;
-  }
-});
-
-// src/rules/no-property-renaming.ts
-var RULE_NAME13, rule13, no_property_renaming_default;
-var init_no_property_renaming = __esm({
-  "src/rules/no-property-renaming.ts"() {
-    "use strict";
-    init_esm_shims();
-    init_utils();
-    init_helpers();
-    init_nodes();
-    RULE_NAME13 = "no-property-renaming";
-    rule13 = createRule({
-      name: RULE_NAME13,
-      meta: {
-        docs: {
-          description: "Ensure that properties for patterns or style props are not renamed, as it prevents proper tracking."
-        },
-        messages: {
-          noRenaming: "Incoming `{{prop}}` prop is different from the expected `{{expected}}` attribute. Panda will not track this prop."
-        },
-        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) => {
-          context.report({
-            node,
-            messageId: "noRenaming",
-            data: {
-              expected,
-              prop
-            }
-          });
-        };
-        const handleReport = (node, value, attr) => {
-          if (isIdentifier(value) && attr !== value.name) {
-            sendReport(node, attr, value.name);
-          } else if (isMemberExpression(value) && isIdentifier(value.property) && attr !== value.property.name) {
-            sendReport(node, attr, value.property.name);
-          }
-        };
-        return {
-          JSXAttribute(node) {
-            if (!node.value) return;
-            if (!isJSXExpressionContainer(node.value)) return;
-            if (!isCachedPandaProp(node)) return;
-            const attr = node.name.name.toString();
-            const expression = node.value.expression;
-            handleReport(node.value, expression, attr);
-          },
-          Property(node) {
-            if (!isIdentifier(node.key)) return;
-            if (!isIdentifier(node.value) && !isMemberExpression(node.value)) return;
-            if (!isCachedPandaAttribute(node)) return;
-            if (isCachedRecipeVariant(node)) return;
-            const attr = node.key.name;
-            const value = node.value;
-            handleReport(node.value, value, attr);
-          }
-        };
-      }
-    });
-    no_property_renaming_default = rule13;
-  }
-});
-
-// src/rules/no-unsafe-token-fn-usage.ts
-import "@typescript-eslint/utils";
-import { getArbitraryValue as getArbitraryValue3 } from "@pandacss/shared";
-var RULE_NAME14, rule14, no_unsafe_token_fn_usage_default;
-var init_no_unsafe_token_fn_usage = __esm({
-  "src/rules/no-unsafe-token-fn-usage.ts"() {
-    "use strict";
-    init_esm_shims();
-    init_helpers();
-    init_utils();
-    init_nodes();
-    RULE_NAME14 = "no-unsafe-token-fn-usage";
-    rule14 = createRule({
-      name: RULE_NAME14,
-      meta: {
-        docs: {
-          description: "Prevent users from using the token function in situations where they could simply use the raw design token."
-        },
-        messages: {
-          noUnsafeTokenFnUsage: "Unnecessary token function usage. Prefer design token.",
-          replace: "Replace token function with `{{safe}}`."
-        },
-        type: "suggestion",
-        hasSuggestions: true,
-        schema: []
-      },
-      defaultOptions: [],
-      create(context) {
-        let tokenImportCache;
-        const getCachedTokenImport = () => {
-          if (tokenImportCache !== void 0) {
-            return tokenImportCache;
-          }
-          tokenImportCache = getTokenImport(context);
-          return tokenImportCache;
-        };
-        const isUnsafeCallExpression = (node) => {
-          const tkImport = getCachedTokenImport();
-          return isIdentifier(node.callee) && node.callee.name === tkImport?.alias;
-        };
-        const tokenWrap = (value) => value ? `token(${value})` : "";
-        const isCompositeValue = (input) => {
-          if (!input) return false;
-          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 handleRuntimeFn = (node) => {
-          if (!isCallExpression(node)) return;
-          if (!isUnsafeCallExpression(node)) return;
-          const value = node.arguments[0];
-          if (isLiteral(value)) {
-            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));
-          }
-        };
-        const handleLiteral = (node) => {
-          if (!isLiteral(node)) return;
-          const value = getArbitraryValue3(node.value?.toString() ?? "");
-          if (isCompositeValue(value)) return;
-          sendReport(node, value);
-        };
-        const handleTemplateLiteral = (node) => {
-          if (!isTemplateLiteral(node) || node.expressions.length > 0) return;
-          const value = getArbitraryValue3(node.quasis[0].value.raw);
-          if (isCompositeValue(value)) return;
-          sendReport(node, value);
-        };
-        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 (!isCachedPandaProp(node)) return;
-            handleLiteral(node.value);
-            if (isJSXExpressionContainer(node.value)) {
-              const expression = node.value.expression;
-              handleLiteral(expression);
-              handleTemplateLiteral(expression);
-              handleRuntimeFn(expression);
-            }
-          },
-          Property(node) {
-            if (!isCachedPandaAttribute(node)) return;
-            if (isCachedRecipeVariant(node)) return;
-            const valueNode = node.value;
-            if (isCallExpression(valueNode) || isLiteral(valueNode) || isTemplateLiteral(valueNode)) {
-              handleRuntimeFn(valueNode);
-              handleLiteral(valueNode);
-              handleTemplateLiteral(valueNode);
-            }
-          }
-        };
-      }
-    });
-    no_unsafe_token_fn_usage_default = rule14;
-  }
-});
-
-// src/rules/prefer-longhand-properties.ts
-var RULE_NAME15, rule15, prefer_longhand_properties_default;
-var init_prefer_longhand_properties = __esm({
-  "src/rules/prefer-longhand-properties.ts"() {
-    "use strict";
-    init_esm_shims();
-    init_helpers();
-    init_utils();
-    init_nodes();
-    RULE_NAME15 = "prefer-longhand-properties";
-    rule15 = createRule({
-      name: RULE_NAME15,
-      meta: {
-        docs: {
-          description: "Discourage the use of shorthand properties and promote the preference for longhand properties in the codebase."
-        },
-        messages: {
-          longhand: "Use longhand property instead of `{{shorthand}}`. Prefer `{{longhand}}`.",
-          replace: "Replace `{{shorthand}}` with `{{longhand}}`."
-        },
-        type: "suggestion",
-        hasSuggestions: true,
-        schema: [
-          {
-            type: "object",
-            properties: {
-              whitelist: {
-                type: "array",
-                items: {
-                  type: "string",
-                  minLength: 0
-                },
-                uniqueItems: true
-              }
-            },
-            additionalProperties: false
-          }
-        ]
-      },
-      defaultOptions: [
-        {
-          whitelist: []
-        }
-      ],
-      create(context) {
-        const whitelist = context.options[0]?.whitelist ?? [];
-        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) => {
-          if (whitelist.includes(node.name)) return;
-          const longhand = getLonghand(node.name);
-          if (!longhand || longhand === node.name) return;
-          const data = {
-            shorthand: node.name,
-            longhand
-          };
-          context.report({
-            node,
-            messageId: "longhand",
-            data,
-            suggest: [
-              {
-                messageId: "replace",
-                data,
-                fix: (fixer) => fixer.replaceText(node, longhand)
-              }
-            ]
-          });
-        };
-        return {
-          JSXAttribute(node) {
-            if (!isJSXIdentifier(node.name)) return;
-            if (!isCachedPandaProp(node)) return;
-            sendReport(node.name);
-          },
-          Property(node) {
-            if (!isIdentifier(node.key)) return;
-            if (!isCachedPandaAttribute(node)) return;
-            if (isCachedRecipeVariant(node)) return;
-            sendReport(node.key);
-          }
-        };
-      }
-    });
-    prefer_longhand_properties_default = rule15;
-  }
-});
-
-// src/rules/prefer-shorthand-properties.ts
-var RULE_NAME16, rule16, prefer_shorthand_properties_default;
-var init_prefer_shorthand_properties = __esm({
-  "src/rules/prefer-shorthand-properties.ts"() {
-    "use strict";
-    init_esm_shims();
-    init_helpers();
-    init_utils();
-    init_nodes();
-    RULE_NAME16 = "prefer-shorthand-properties";
-    rule16 = createRule({
-      name: RULE_NAME16,
-      meta: {
-        docs: {
-          description: "Discourage the use of longhand properties and promote the preference for shorthand properties in the codebase."
-        },
-        messages: {
-          shorthand: "Use shorthand property instead of `{{longhand}}`. Prefer `{{shorthand}}`.",
-          replace: "Replace `{{longhand}}` with `{{shorthand}}`."
-        },
-        type: "suggestion",
-        hasSuggestions: true,
-        schema: [
-          {
-            type: "object",
-            properties: {
-              whitelist: {
-                type: "array",
-                items: {
-                  type: "string",
-                  minLength: 0
-                },
-                uniqueItems: true
-              }
-            },
-            additionalProperties: false
-          }
-        ]
-      },
-      defaultOptions: [
-        {
-          whitelist: []
-        }
-      ],
-      create(context) {
-        const whitelist = context.options[0]?.whitelist ?? [];
-        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) => {
-          if (whitelist.includes(node.name)) return;
-          const longhand = getLonghand(node.name);
-          if (longhand) return;
-          const shorthands = getShorthands(node.name);
-          if (!shorthands || shorthands.length === 0) return;
-          const shorthandList = shorthands.map((s) => `\`${s}\``).join(", ");
-          const data = {
-            longhand: node.name,
-            shorthand: shorthandList
-          };
-          context.report({
-            node,
-            messageId: "shorthand",
-            data,
-            suggest: [
-              {
-                messageId: "replace",
-                data,
-                fix: (fixer) => fixer.replaceText(node, shorthands[0])
-              }
-            ]
-          });
-        };
-        return {
-          JSXAttribute(node) {
-            if (!isJSXIdentifier(node.name)) return;
-            if (!isCachedPandaProp(node)) return;
-            sendReport(node.name);
-          },
-          Property(node) {
-            if (!isIdentifier(node.key)) return;
-            if (!isCachedPandaAttribute(node)) return;
-            if (isCachedRecipeVariant(node)) return;
-            sendReport(node.key);
-          }
-        };
-      }
-    });
-    prefer_shorthand_properties_default = rule16;
-  }
-});
-
-// src/utils/composite-properties.ts
-var compositeProperties;
-var init_composite_properties = __esm({
-  "src/utils/composite-properties.ts"() {
-    "use strict";
-    init_esm_shims();
-    compositeProperties = {
-      animation: [
-        "animationName",
-        "animationDuration",
-        "animationTimingFunction",
-        "animationDelay",
-        "animationIterationCount",
-        "animationDirection",
-        "animationFillMode",
-        "animationPlayState"
-      ],
-      background: [
-        "backgroundImage",
-        "backgroundPosition",
-        "backgroundSize",
-        "backgroundRepeat",
-        "backgroundAttachment",
-        "backgroundOrigin",
-        "backgroundClip",
-        "backgroundColor"
-      ],
-      backgroundPosition: ["backgroundPositionX", "backgroundPositionY"],
-      border: ["borderWidth", "borderStyle", "borderColor"],
-      borderBlock: ["borderBlockWidth", "borderBlockStyle", "borderBlockColor"],
-      borderBlockColor: ["borderBlockStartColor", "borderBlockEndColor"],
-      borderBlockEnd: ["borderBlockEndWidth", "borderBlockEndStyle", "borderBlockEndColor"],
-      borderBlockStart: ["borderBlockStartWidth", "borderBlockStartStyle", "borderBlockStartColor"],
-      borderBlockStyle: ["borderBlockStartStyle", "borderBlockEndStyle"],
-      borderBlockWidth: ["borderBlockStartWidth", "borderBlockEndWidth"],
-      borderBottom: ["borderBottomWidth", "borderBottomStyle", "borderBottomColor"],
-      borderColor: ["borderTopColor", "borderRightColor", "borderBottomColor", "borderLeftColor"],
-      borderImage: ["borderImageSource", "borderImageSlice", "borderImageWidth", "borderImageOutset", "borderImageRepeat"],
-      borderInline: ["borderInlineWidth", "borderInlineStyle", "borderInlineColor"],
-      borderInlineColor: ["borderInlineStartColor", "borderInlineEndColor"],
-      borderInlineEnd: ["borderInlineEndWidth", "borderInlineEndStyle", "borderInlineEndColor"],
-      borderInlineStart: ["borderInlineStartWidth", "borderInlineStartStyle", "borderInlineStartColor"],
-      borderInlineStyle: ["borderInlineStartStyle", "borderInlineEndStyle"],
-      borderInlineWidth: ["borderInlineStartWidth", "borderInlineEndWidth"],
-      borderLeft: ["borderLeftWidth", "borderLeftStyle", "borderLeftColor"],
-      borderRadius: ["borderTopLeftRadius", "borderTopRightRadius", "borderBottomRightRadius", "borderBottomLeftRadius"],
-      borderRight: ["borderRightWidth", "borderRightStyle", "borderRightColor"],
-      borderStyle: ["borderTopStyle", "borderRightStyle", "borderBottomStyle", "borderLeftStyle"],
-      borderTop: ["borderTopWidth", "borderTopStyle", "borderTopColor"],
-      borderWidth: ["borderTopWidth", "borderRightWidth", "borderBottomWidth", "borderLeftWidth"],
-      columnRule: ["columnRuleWidth", "columnRuleStyle", "columnRuleColor"],
-      columns: ["columnWidth", "columnCount"],
-      container: ["contain", "content"],
-      containIntrinsicSize: ["containIntrinsicSizeInline", "containIntrinsicSizeBlock"],
-      cue: ["cueBefore", "cueAfter"],
-      flex: ["flexGrow", "flexShrink", "flexBasis"],
-      flexFlow: ["flexDirection", "flexWrap"],
-      font: [
-        "fontStyle",
-        "fontVariantCaps",
-        "fontVariantEastAsian",
-        "fontVariantLigatures",
-        "fontVariantNumeric",
-        "fontVariantPosition",
-        "fontWeight",
-        "fontStretch",
-        "fontSize",
-        "lineHeight",
-        "fontFamily"
-      ],
-      fontSynthesis: ["fontSynthesisWeight", "fontSynthesisStyle", "fontSynthesisSmallCaps"],
-      fontVariant: [
-        "fontVariantCaps",
-        "fontVariantEastAsian",
-        "fontVariantLigatures",
-        "fontVariantNumeric",
-        "fontVariantPosition"
-      ],
-      gap: ["columnGap", "rowGap"],
-      grid: [
-        "gridTemplateColumns",
-        "gridTemplateRows",
-        "gridTemplateAreas",
-        "gridAutoColumns",
-        "gridAutoRows",
-        "gridAutoFlow"
-      ],
-      gridArea: ["gridRowStart", "gridColumnStart", "gridRowEnd", "gridColumnEnd"],
-      gridColumn: ["gridColumnStart", "gridColumnEnd"],
-      gridGap: ["gridColumnGap", "gridRowGap"],
-      gridRow: ["gridRowStart", "gridRowEnd"],
-      gridTemplate: ["gridTemplateColumns", "gridTemplateRows", "gridTemplateAreas"],
-      inset: ["top", "right", "bottom", "left"],
-      insetBlock: ["insetBlockStart", "insetBlockEnd"],
-      insetInline: ["insetInlineStart", "insetInlineEnd"],
-      listStyle: ["listStyleType", "listStylePosition", "listStyleImage"],
-      margin: ["marginTop", "marginRight", "marginBottom", "marginLeft"],
-      marginBlock: ["marginBlockStart", "marginBlockEnd"],
-      marginInline: ["marginInlineStart", "marginInlineEnd"],
-      mask: ["maskImage", "maskMode", "maskRepeat", "maskPosition", "maskClip", "maskOrigin", "maskSize", "maskComposite"],
-      maskBorder: [
-        "maskBorderSource",
-        "maskBorderMode",
-        "maskBorderSlice",
-        "maskBorderWidth",
-        "maskBorderOutset",
-        "maskBorderRepeat"
-      ],
-      offset: ["offsetPosition", "offsetPath", "offsetDistance", "offsetRotate", "offsetAnchor"],
-      outline: ["outlineWidth", "outlineStyle", "outlineColor"],
-      overflow: ["overflowX", "overflowY"],
-      padding: ["paddingTop", "paddingRight", "paddingBottom", "paddingLeft"],
-      paddingBlock: ["paddingBlockStart", "paddingBlockEnd"],
-      paddingInline: ["paddingInlineStart", "paddingInlineEnd"],
-      pause: ["pauseBefore", "pauseAfter"],
-      placeContent: ["alignContent", "justifyContent"],
-      placeItems: ["alignItems", "justifyItems"],
-      placeSelf: ["alignSelf", "justifySelf"],
-      rest: ["restBefore", "restAfter"],
-      scrollMargin: ["scrollMarginTop", "scrollMarginRight", "scrollMarginBottom", "scrollMarginLeft"],
-      scrollMarginBlock: ["scrollMarginBlockStart", "scrollMarginBlockEnd"],
-      scrollMarginInline: ["scrollMarginInlineStart", "scrollMarginInlineEnd"],
-      scrollPadding: ["scrollPaddingTop", "scrollPaddingRight", "scrollPaddingBottom", "scrollPaddingLeft"],
-      scrollPaddingBlock: ["scrollPaddingBlockStart", "scrollPaddingBlockEnd"],
-      scrollPaddingInline: ["scrollPaddingInlineStart", "scrollPaddingInlineEnd"],
-      scrollSnapMargin: ["scrollSnapMarginTop", "scrollSnapMarginRight", "scrollSnapMarginBottom", "scrollSnapMarginLeft"],
-      scrollSnapMarginBlock: ["scrollSnapMarginBlockStart", "scrollSnapMarginBlockEnd"],
-      scrollSnapMarginInline: ["scrollSnapMarginInlineStart", "scrollSnapMarginInlineEnd"],
-      scrollTimeline: ["scrollTimelineSource", "scrollTimelineOrientation"],
-      textDecoration: ["textDecorationLine", "textDecorationStyle", "textDecorationColor"],
-      textEmphasis: ["textEmphasisStyle", "textEmphasisColor"],
-      transition: ["transitionProperty", "transitionDuration", "transitionTimingFunction", "transitionDelay"]
-    };
-  }
-});
-
-// src/rules/prefer-atomic-properties.ts
-var RULE_NAME17, rule17, prefer_atomic_properties_default;
-var init_prefer_atomic_properties = __esm({
-  "src/rules/prefer-atomic-properties.ts"() {
-    "use strict";
-    init_esm_shims();
-    init_utils();
-    init_helpers();
-    init_composite_properties();
-    init_nodes();
-    RULE_NAME17 = "prefer-atomic-properties";
-    rule17 = createRule({
-      name: RULE_NAME17,
-      meta: {
-        docs: {
-          description: "Encourage the use of atomic properties instead of composite properties in the codebase."
-        },
-        messages: {
-          atomic: "Use atomic properties instead of `{{composite}}`. Prefer: \n{{atomics}}"
-        },
-        type: "suggestion",
-        schema: [
-          {
-            type: "object",
-            properties: {
-              whitelist: {
-                type: "array",
-                items: {
-                  type: "string",
-                  minLength: 0
-                },
-                uniqueItems: true
-              }
-            },
-            additionalProperties: false
-          }
-        ]
-      },
-      defaultOptions: [
-        {
-          whitelist: []
-        }
-      ],
-      create(context) {
-        const whitelist = context.options[0]?.whitelist ?? [];
-        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 (compositePropertyCache.has(name2)) {
-            return compositePropertyCache.get(name2);
-          }
-          if (Object.hasOwn(compositeProperties, name2)) {
-            compositePropertyCache.set(name2, name2);
-            return name2;
-          }
-          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 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) => {
-          if (whitelist.includes(node.name)) return;
-          const atomics = compositeProperties[composite].map((name2) => `\`${name2}\``).join(",\n");
-          context.report({
-            node,
-            messageId: "atomic",
-            data: {
-              composite: node.name,
-              atomics
-            }
-          });
-        };
-        return {
-          JSXAttribute(node) {
-            if (!isJSXIdentifier(node.name)) return;
-            if (!isCachedPandaProp(node)) return;
-            const composite = resolveCompositeProperty(node.name.name);
-            if (!composite) return;
-            sendReport(node.name, composite);
-          },
-          Property(node) {
-            if (!isIdentifier(node.key)) return;
-            if (!isCachedPandaAttribute(node)) return;
-            if (isCachedRecipeVariant(node)) return;
-            const composite = resolveCompositeProperty(node.key.name);
-            if (!composite) return;
-            sendReport(node.key, composite);
-          }
-        };
-      }
-    });
-    prefer_atomic_properties_default = rule17;
-  }
-});
-
-// src/rules/prefer-composite-properties.ts
-var RULE_NAME18, rule18, prefer_composite_properties_default;
-var init_prefer_composite_properties = __esm({
-  "src/rules/prefer-composite-properties.ts"() {
-    "use strict";
-    init_esm_shims();
-    init_helpers();
-    init_utils();
-    init_composite_properties();
-    init_nodes();
-    RULE_NAME18 = "prefer-composite-properties";
-    rule18 = createRule({
-      name: RULE_NAME18,
-      meta: {
-        docs: {
-          description: "Encourage the use of composite properties instead of atomic properties in the codebase."
-        },
-        messages: {
-          composite: "Use composite property instead of `{{atomic}}`. Prefer: `{{composite}}`."
-        },
-        type: "suggestion",
-        schema: [
-          {
-            type: "object",
-            properties: {
-              whitelist: {
-                type: "array",
-                items: {
-                  type: "string",
-                  minLength: 0
-                },
-                uniqueItems: true
-              }
-            },
-            additionalProperties: false
-          }
-        ]
-      },
-      defaultOptions: [
-        {
-          whitelist: []
-        }
-      ],
-      create(context) {
-        const whitelist = context.options[0]?.whitelist ?? [];
-        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 (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) => {
-          if (whitelist.includes(node.name)) return;
-          context.report({
-            node,
-            messageId: "composite",
-            data: {
-              composite,
-              atomic: node.name
-            }
-          });
-        };
-        return {
-          JSXAttribute(node) {
-            if (!isJSXIdentifier(node.name)) return;
-            if (!isCachedPandaProp(node)) return;
-            const composite = resolveCompositeProperty(node.name.name);
-            if (!composite) return;
-            sendReport(node.name, composite);
-          },
-          Property(node) {
-            if (!isIdentifier(node.key)) return;
-            if (!isCachedPandaAttribute(node)) return;
-            if (isCachedRecipeVariant(node)) return;
-            const composite = resolveCompositeProperty(node.key.name);
-            if (!composite) return;
-            sendReport(node.key, composite);
-          }
-        };
-      }
-    });
-    prefer_composite_properties_default = rule18;
-  }
-});
-
-// src/rules/prefer-unified-property-style.ts
-var RULE_NAME19, rule19, prefer_unified_property_style_default;
-var init_prefer_unified_property_style = __esm({
-  "src/rules/prefer-unified-property-style.ts"() {
-    "use strict";
-    init_esm_shims();
-    init_helpers();
-    init_utils();
-    init_composite_properties();
-    init_nodes();
-    RULE_NAME19 = "prefer-unified-property-style";
-    rule19 = createRule({
-      name: RULE_NAME19,
-      meta: {
-        docs: {
-          description: "Discourage mixing atomic and composite forms of the same property in a style declaration. Atomic styles give more consistent results."
-        },
-        messages: {
-          unify: "You're mixing atomic {{atomicProperties}} with composite property `{{composite}}`. Prefer atomic styling to mixing atomic and composite properties. Remove `{{composite}}` and use one or more of {{atomics}} instead."
-        },
-        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 (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) {
-            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 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 = Array.from(atomicPropertiesSet).map((prop) => `\`${prop}\``).join(", ");
-          const atomics = compositeProperties[composite].map((name2) => `\`${name2}\``).join(", ");
-          context.report({
-            node,
-            messageId: "unify",
-            data: {
-              composite,
-              atomicProperties,
-              atomics
-            }
-          });
-        };
-        return {
-          JSXAttribute(node) {
-            if (!isJSXIdentifier(node.name)) return;
-            if (!isCachedPandaProp(node)) return;
-            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, composite, siblings);
-          },
-          Property(node) {
-            if (!isIdentifier(node.key)) return;
-            if (!isCachedPandaAttribute(node)) return;
-            if (isCachedRecipeVariant(node)) return;
-            const composite = resolveCompositeProperty(node.key.name);
-            if (!composite) return;
-            if (!isObjectExpression(node.parent)) return;
-            const siblings = node.parent.properties.filter((prop) => prop.type === "Property").map((prop) => isIdentifier(prop.key) ? prop.key.name : "");
-            sendReport(node.key, composite, siblings);
-          }
-        };
-      }
-    });
-    prefer_unified_property_style_default = rule19;
-  }
-});
-
-// src/rules/index.ts
-var rules;
-var init_rules = __esm({
-  "src/rules/index.ts"() {
-    "use strict";
-    init_esm_shims();
-    init_file_not_included();
-    init_no_config_function_in_source();
-    init_no_debug();
-    init_no_deprecated_tokens();
-    init_no_dynamic_styling();
-    init_no_escape_hatch();
-    init_no_hardcoded_color();
-    init_no_important();
-    init_no_invalid_nesting();
-    init_no_invalid_token_paths();
-    init_no_margin_properties();
-    init_no_physical_properties();
-    init_no_property_renaming();
-    init_no_unsafe_token_fn_usage();
-    init_prefer_longhand_properties();
-    init_prefer_shorthand_properties();
-    init_prefer_atomic_properties();
-    init_prefer_composite_properties();
-    init_prefer_unified_property_style();
-    rules = {
-      [RULE_NAME]: file_not_included_default,
-      [RULE_NAME2]: no_config_function_in_source_default,
-      [RULE_NAME3]: no_debug_default,
-      [RULE_NAME4]: no_deprecated_tokens_default,
-      [RULE_NAME5]: no_dynamic_styling_default,
-      [RULE_NAME6]: no_escape_hatch_default,
-      [RULE_NAME7]: no_hardcoded_color_default,
-      [RULE_NAME8]: no_important_default,
-      [RULE_NAME10]: no_invalid_token_paths_default,
-      [RULE_NAME9]: no_invalid_nesting_default,
-      [RULE_NAME11]: no_margin_properties_default,
-      [RULE_NAME12]: no_physical_properties_default,
-      [RULE_NAME13]: no_property_renaming_default,
-      [RULE_NAME14]: no_unsafe_token_fn_usage_default,
-      [RULE_NAME15]: prefer_longhand_properties_default,
-      [RULE_NAME16]: prefer_shorthand_properties_default,
-      [RULE_NAME17]: prefer_atomic_properties_default,
-      [RULE_NAME18]: prefer_composite_properties_default,
-      [RULE_NAME19]: prefer_unified_property_style_default
-    };
-  }
-});
-
-// src/configs/all.ts
-var errorRules, allRules, all_default;
-var init_all = __esm({
-  "src/configs/all.ts"() {
-    "use strict";
-    init_esm_shims();
-    init_rules();
-    init_file_not_included();
-    init_no_config_function_in_source();
-    init_no_invalid_token_paths();
-    errorRules = [RULE_NAME, RULE_NAME2, RULE_NAME10];
-    allRules = Object.fromEntries(
-      Object.entries(rules).map(([name2]) => {
-        return [`@pandacss/${name2}`, errorRules.includes(name2) ? "error" : "warn"];
-      })
-    );
-    all_default = {
-      parser: "@typescript-eslint/parser",
-      parserOptions: { sourceType: "module" },
-      plugins: ["@pandacss"],
-      rules: allRules
-    };
-  }
-});
-
-// src/configs/recommended.ts
-var recommended_default;
-var init_recommended = __esm({
-  "src/configs/recommended.ts"() {
-    "use strict";
-    init_esm_shims();
-    recommended_default = {
-      parser: "@typescript-eslint/parser",
-      parserOptions: { sourceType: "module" },
-      plugins: ["@pandacss"],
-      rules: {
-        "@pandacss/file-not-included": "error",
-        "@pandacss/no-config-function-in-source": "error",
-        "@pandacss/no-debug": "warn",
-        "@pandacss/no-dynamic-styling": "warn",
-        "@pandacss/no-hardcoded-color": "warn",
-        "@pandacss/no-invalid-nesting": "error",
-        "@pandacss/no-invalid-token-paths": "error",
-        "@pandacss/no-property-renaming": "warn",
-        "@pandacss/no-unsafe-token-fn-usage": "warn",
-        "@pandacss/no-deprecated-tokens": "warn"
-      }
-    };
-  }
-});
-
-// src/index.ts
-var require_index = __commonJS({
-  "src/index.ts"(exports, module) {
-    init_esm_shims();
-    init_package();
-    init_all();
-    init_recommended();
-    init_rules();
-    var plugin = {
-      meta: {
-        name,
-        version
-      },
-      rules,
-      configs: {
-        all: all_default,
-        recommended: recommended_default
-      }
-    };
-    module.exports = plugin;
-  }
-});
-export default require_index();