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

package/dist/index.js

@@ -1,2541 +1,155 @@
-"use strict";
-
-// ../node_modules/.pnpm/tsup@8.3.6_postcss@8.5.6_typescript@5.7.3/node_modules/tsup/assets/cjs_shims.js
-var getImportMetaUrl = () => typeof document === "undefined" ? new URL(`file:${__filename}`).href : document.currentScript && document.currentScript.src || new URL("main.js", document.baseURI).href;
-var importMetaUrl = /* @__PURE__ */ getImportMetaUrl();
-
-// package.json
-var name = "@pandacss/eslint-plugin";
-var version = "0.3.2";
-
-// src/utils/index.ts
-var import_utils = require("@typescript-eslint/utils");
-var import_synckit = require("synckit");
-var import_node_path = require("path");
-var import_node_url = require("url");
-
-// src/utils/cache.ts
-var import_scope_manager = require("@typescript-eslint/scope-manager");
-var cache = {
-  imports: null,
-  scopeAnalysis: null
-};
-var numRulesRunning = 0;
-var resetMicrotaskScheduled = false;
-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;
-}
-
-// src/utils/index.ts
-var _createRule = import_utils.ESLintUtils.RuleCreator(
-  (name2) => `https://github.com/chakra-ui/eslint-plugin-panda/blob/main/docs/rules/${name2}.md`
-);
-var 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;
-};
-var isBase = process.env.NODE_ENV !== "test" || importMetaUrl.includes("/dist/index");
-var distDir = (0, import_node_url.fileURLToPath)(new URL(isBase ? "./" : "../../dist", importMetaUrl));
-var _syncAction = (0, import_synckit.createSyncFn)((0, import_node_path.join)(distDir, "utils/worker.mjs"));
-var syncAction = (...args) => {
-  try {
-    return _syncAction(...args);
-  } catch (error) {
-    console.error("syncAction error:", error);
-    return void 0;
-  }
-};
-
-// src/utils/helpers.ts
-var import_scope_manager2 = require("@typescript-eslint/scope-manager");
-
-// src/utils/nodes.ts
-var import_ast_utils = require("@typescript-eslint/utils/ast-utils");
-var import_utils2 = require("@typescript-eslint/utils");
-var isIdentifier = (0, import_ast_utils.isNodeOfType)(import_utils2.AST_NODE_TYPES.Identifier);
-var isLiteral = (0, import_ast_utils.isNodeOfType)(import_utils2.AST_NODE_TYPES.Literal);
-var isTemplateLiteral = (0, import_ast_utils.isNodeOfType)(import_utils2.AST_NODE_TYPES.TemplateLiteral);
-var isArrayExpression = (0, import_ast_utils.isNodeOfType)(import_utils2.AST_NODE_TYPES.ArrayExpression);
-var isObjectExpression = (0, import_ast_utils.isNodeOfType)(import_utils2.AST_NODE_TYPES.ObjectExpression);
-var isMemberExpression = (0, import_ast_utils.isNodeOfType)(import_utils2.AST_NODE_TYPES.MemberExpression);
-var isVariableDeclarator = (0, import_ast_utils.isNodeOfType)(import_utils2.AST_NODE_TYPES.VariableDeclarator);
-var isVariableDeclaration = (0, import_ast_utils.isNodeOfType)(import_utils2.AST_NODE_TYPES.VariableDeclaration);
-var isJSXMemberExpression = (0, import_ast_utils.isNodeOfType)(import_utils2.AST_NODE_TYPES.JSXMemberExpression);
-var isJSXOpeningElement = (0, import_ast_utils.isNodeOfType)(import_utils2.AST_NODE_TYPES.JSXOpeningElement);
-var isJSXExpressionContainer = (0, import_ast_utils.isNodeOfType)(import_utils2.AST_NODE_TYPES.JSXExpressionContainer);
-var isJSXAttribute = (0, import_ast_utils.isNodeOfType)(import_utils2.AST_NODE_TYPES.JSXAttribute);
-var isJSXIdentifier = (0, import_ast_utils.isNodeOfType)(import_utils2.AST_NODE_TYPES.JSXIdentifier);
-var isCallExpression = (0, import_ast_utils.isNodeOfType)(import_utils2.AST_NODE_TYPES.CallExpression);
-var isImportDeclaration = (0, import_ast_utils.isNodeOfType)(import_utils2.AST_NODE_TYPES.ImportDeclaration);
-var isImportSpecifier = (0, import_ast_utils.isNodeOfType)(import_utils2.AST_NODE_TYPES.ImportSpecifier);
-var isProperty = (0, import_ast_utils.isNodeOfType)(import_utils2.AST_NODE_TYPES.Property);
-
-// src/utils/helpers.ts
-var getAncestor = (ofType, for_) => {
-  let current = for_.parent;
-  while (current) {
-    if (ofType(current)) return current;
-    current = current.parent;
-  }
-  return;
-};
-var getSyncOpts = (context) => {
+import {
+  FileInspector,
+  Linter,
+  ProjectCache,
+  bindRules,
+  byteToIndex,
+  collectStrings,
+  consistentPropertyStyleRuleName,
+  createConsistentPropertyStyleRule,
+  createExtractionDiagnosticsRule,
+  createFileNotIncludedRule,
+  createNoDebugRule,
+  createNoDeprecatedRule,
+  createNoImportantRule,
+  createNoInvalidNestingRule,
+  createNoInvalidTokenPathsRule,
+  createNoMarginPropertiesRule,
+  createNoPhysicalPropertiesRule,
+  createNoPrimitiveTokenRule,
+  createNoShorthandLonghandMixRule,
+  createPandaPlugin,
+  createPreferTextStyleRule,
+  createPreferTokenRule,
+  extractionDiagnosticsRuleName,
+  fileNotIncludedRuleName,
+  getContextFilename,
+  getContextSource,
+  getSourceText,
+  loadPandaProject,
+  noDebugRuleName,
+  noDeprecatedRuleName,
+  noImportantRuleName,
+  noInvalidNestingRuleName,
+  noInvalidTokenPathsRuleName,
+  noMarginPropertiesRuleName,
+  noPhysicalPropertiesRuleName,
+  noPrimitiveTokenRuleName,
+  noShorthandLonghandMixRuleName,
+  pluginMeta,
+  preferTextStyleRuleName,
+  preferTokenRuleName,
+  projectCacheKey,
+  reportDiagnostics,
+  reportPrimitiveTokenViolations,
+  reportTokenViolations,
+  resolvePandaSettings,
+  sourceCacheKey,
+  toEslintLoc
+} from "./chunk-QIP545JU.js";
+
+// src/core/range-index.ts
+var RangeIndex = class {
+  #items;
+  constructor(items) {
+    this.#items = [...items].sort((a, b) => a.span.start - b.span.start || a.span.end - b.span.end);
+  }
+  at(offset) {
+    return this.#items.find((item) => item.span.start <= offset && offset <= item.span.end);
+  }
+  enclosing(span) {
+    return this.#items.find((item) => item.span.start <= span.start && item.span.end >= span.end);
+  }
+  exact(span) {
+    return this.#items.find((item) => item.span.start === span.start && item.span.end === span.end);
+  }
+  all() {
+    return this.#items;
+  }
+};
+
+// src/configs.ts
+var PLUGIN_NAMESPACE = "@pandacss";
+var DEFAULT_FILES = ["**/*.{js,jsx,mjs,cjs,ts,tsx,mts,cts}"];
+var RECOMMENDED_RULES = {
+  [extractionDiagnosticsRuleName]: "warn",
+  [fileNotIncludedRuleName]: "error",
+  [noInvalidTokenPathsRuleName]: "error",
+  [noInvalidNestingRuleName]: "error",
+  [noDeprecatedRuleName]: "warn",
+  [noDebugRuleName]: "warn",
+  // Default to flagging hardcoded colors only (the old `no-hardcoded-color`);
+  // widen with `categories` to enforce other token categories.
+  [preferTokenRuleName]: ["warn", { categories: ["colors"] }]
+};
+async function recommended(options = {}) {
+  const { linter, project } = await loadPandaProject(options);
+  const rules = bindRules(linter, project);
+  const plugin = { meta: pluginMeta, rules };
   return {
-    currentFile: context.filename,
-    configPath: context.settings["@pandacss/configPath"]
+    files: options.files ?? DEFAULT_FILES,
+    plugins: { [PLUGIN_NAMESPACE]: plugin },
+    rules: Object.fromEntries(
+      Object.entries(RECOMMENDED_RULES).map(([id, severity]) => [`${PLUGIN_NAMESPACE}/${id}`, severity])
+    ),
+    ...options.configPath ? { settings: { panda: { configPath: options.configPath } } } : {}
   };
-};
-var 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;
-};
-var hasPkgImport = (context) => {
-  const imports = _getImports(context);
-  return imports.some(({ mod }) => mod === "@pandacss/dev");
-};
-var isPandaConfigFunction = (context, name2) => {
-  const imports = _getImports(context);
-  return imports.some(({ alias, mod }) => alias === name2 && mod === "@pandacss/dev");
-};
-var _getImports = (context) => {
-  const specifiers = getImportSpecifiers(context);
-  const imports = specifiers.map(({ specifier, mod }) => ({
-    name: specifier.imported.name,
-    alias: specifier.local.name,
-    mod
-  }));
-  return imports;
-};
-var 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;
-};
-var isValidStyledProp = (node, context) => {
-  return isJSXIdentifier(node) && isValidProperty(node.name, context);
-};
-var 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);
-};
-var 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 = (0, import_scope_manager2.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;
-  }
-};
-var 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;
-};
-var isValidFile = (context) => {
-  return syncAction("isValidFile", getSyncOpts(context));
-};
-var isValidProperty = (name2, context, calleName) => {
-  return syncAction("isValidProperty", getSyncOpts(context), name2, calleName);
-};
-var isPandaImport = (node, context) => {
-  const imports = getImports(context);
-  return imports.some((imp) => imp.mod === node.source.value);
-};
-var 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;
-};
-var 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;
-};
-var 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;
-};
-var 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;
-};
-var 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);
-};
-var resolveLonghand = (name2, context) => {
-  return syncAction("resolveLongHand", getSyncOpts(context), name2);
-};
-var resolveShorthands = (name2, context) => {
-  return syncAction("resolveShorthands", getSyncOpts(context), name2);
-};
-var isColorAttribute = (attr, context) => {
-  return syncAction("isColorAttribute", getSyncOpts(context), attr);
-};
-var isColorToken = (value, context) => {
-  if (!value) return;
-  return syncAction("isColorToken", getSyncOpts(context), value);
-};
-var 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);
-};
-var invalidTokensCache = /* @__PURE__ */ new Map();
-var 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;
-};
-var deprecatedTokensCache = /* @__PURE__ */ new Map();
-var 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;
-};
-var getTokenImport = (context) => {
-  const imports = _getImports(context);
-  return imports.find((imp) => imp.name === "token");
-};
-var 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;
-  }
-};
-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;
 }
-
-// src/rules/file-not-included.ts
-var import_utils4 = require("@typescript-eslint/utils");
-var RULE_NAME = "file-not-included";
-var rule = createRule({
-  name: RULE_NAME,
-  meta: {
-    docs: {
-      description: "Disallow the use of Panda CSS in files that are not included in the specified Panda 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;
-      }
-    };
-  }
-});
-var file_not_included_default = rule;
-
-// src/rules/no-config-function-in-source.ts
-var import_utils6 = require("@typescript-eslint/utils");
-var RULE_NAME2 = "no-config-function-in-source";
-var CONFIG_FUNCTIONS = /* @__PURE__ */ new Set([
-  "defineConfig",
-  "defineRecipe",
-  "defineSlotRecipe",
-  "defineParts",
-  "definePattern",
-  "definePreset",
-  "defineKeyframes",
-  "defineGlobalStyles",
-  "defineUtility",
-  "defineTextStyles",
-  "defineLayerStyles",
-  "defineStyles",
-  "defineTokens",
-  "defineSemanticTokens"
-]);
-var rule2 = createRule({
-  name: RULE_NAME2,
-  meta: {
-    docs: {
-      description: "Prohibit the use of config functions outside the Panda config 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;
-              }
-            }
-          ]
-        });
-      }
-    };
-  }
-});
-var no_config_function_in_source_default = rule2;
-
-// src/rules/no-debug.ts
-var import_utils8 = require("@typescript-eslint/utils");
-var RULE_NAME3 = "no-debug";
-var 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])
-            }
-          ]
-        });
-      }
-    };
-  }
-});
-var no_debug_default = rule3;
-
-// src/rules/no-deprecated-tokens.ts
-var import_utils10 = require("@typescript-eslint/utils");
-var import_ast_utils2 = require("@typescript-eslint/utils/ast-utils");
-var RULE_NAME4 = "no-deprecated-tokens";
-var 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) || !(0, import_ast_utils2.isNodeOfTypes)([import_utils10.AST_NODE_TYPES.Literal, import_utils10.AST_NODE_TYPES.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);
-            }
-          });
-        });
-      }
-    };
-  }
-});
-var no_deprecated_tokens_default = rule4;
-
-// src/rules/no-dynamic-styling.ts
-var import_utils11 = require("@typescript-eslint/utils");
-var RULE_NAME5 = "no-dynamic-styling";
-var 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"
-        });
-      }
-    };
-  }
-});
-var no_dynamic_styling_default = rule5;
-
-// src/rules/no-escape-hatch.ts
-var import_shared = require("@pandacss/shared");
-var import_utils14 = require("@typescript-eslint/utils");
-var RULE_NAME6 = "no-escape-hatch";
-var 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 (0, import_shared.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), (0, import_shared.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);
-        }
-      }
-    };
-  }
-});
-var no_escape_hatch_default = rule6;
-
-// src/rules/no-hardcoded-color.ts
-var import_utils16 = require("@typescript-eslint/utils");
-var RULE_NAME7 = "no-hardcoded-color";
-var 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);
-        }
-      }
-    };
-  }
-});
-var no_hardcoded_color_default = rule7;
-
-// src/rules/no-important.ts
-var import_shared2 = require("@pandacss/shared");
-var import_utils18 = require("@typescript-eslint/utils");
-var exclamationRegex = /\s*!$/;
-var importantRegex = /\s*!important\s*$/;
-var RULE_NAME8 = "no-important";
-var 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 = (0, import_shared2.getArbitraryValue)(value);
-      return exclamationRegex.test(arbitraryValue) || importantRegex.test(arbitraryValue);
-    };
-    const removeImportantKeyword = (input) => {
-      if (importantRegex.test(input)) {
-        return { fixed: input.replace(importantRegex, "").trimEnd(), keyword: "!important" };
-      } else if (exclamationRegex.test(input)) {
-        return { fixed: input.replace(exclamationRegex, "").trimEnd(), keyword: "!" };
-      } else {
-        return { fixed: input, keyword: null };
-      }
-    };
-    const handleNodeValue = (node, value) => {
-      if (!hasImportantKeyword(value)) return;
-      const { fixed, 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);
-        }
-      }
-    };
-  }
-});
-var no_important_default = rule8;
-
-// src/rules/no-invalid-nesting.ts
-var import_utils20 = require("@typescript-eslint/utils");
-var RULE_NAME9 = "no-invalid-nesting";
-var 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"
-          });
-        }
-      }
-    };
-  }
-});
-var no_invalid_nesting_default = rule9;
-
-// src/rules/no-invalid-token-paths.ts
-var import_utils22 = require("@typescript-eslint/utils");
-var import_ast_utils3 = require("@typescript-eslint/utils/ast-utils");
-var RULE_NAME10 = "no-invalid-token-paths";
-var 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) || !(0, import_ast_utils3.isNodeOfTypes)([import_utils22.AST_NODE_TYPES.Literal, import_utils22.AST_NODE_TYPES.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);
-            }
-          });
-        });
-      }
-    };
-  }
-});
-var no_invalid_token_paths_default = rule10;
-
-// src/rules/no-margin-properties.ts
-var RULE_NAME11 = "no-margin-properties";
-var 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);
-      }
-    };
-  }
-});
-var no_margin_properties_default = rule11;
-
-// src/utils/physical-properties.ts
-var 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"
-};
-var physicalPropertyValues = {
-  // text-align physical values mapped to logical values
-  textAlign: {
-    left: "start",
-    right: "end"
-  }
-};
-
-// src/rules/no-physical-properties.ts
-var RULE_NAME12 = "no-physical-properties";
-var MESSAGES = {
-  physical: "Use logical property instead of {{physical}}. Prefer `{{logical}}`.",
-  physicalValue: "Use logical value instead of {{physical}}. Prefer `{{logical}}`.",
-  replace: "Replace `{{physical}}` with `{{logical}}`."
-};
-var PropertyCache = class {
-  longhandCache = /* @__PURE__ */ new Map();
-  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;
-  }
-};
-var 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;
-};
-var 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)
-      }
-    ]
-  });
-};
-var 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;
-        }
-      }
-    ]
-  });
-};
-var 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);
-        }
-      }
-    };
-  }
-});
-var no_physical_properties_default = rule12;
-
-// src/rules/no-property-renaming.ts
-var RULE_NAME13 = "no-property-renaming";
-var 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);
-      }
-    };
-  }
-});
-var no_property_renaming_default = rule13;
-
-// src/rules/no-unsafe-token-fn-usage.ts
-var import_utils27 = require("@typescript-eslint/utils");
-var import_shared3 = require("@pandacss/shared");
-var RULE_NAME14 = "no-unsafe-token-fn-usage";
-var 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 = (0, import_shared3.getArbitraryValue)(value.value?.toString() ?? "");
-        sendReport(node, tokenWrap(val));
-      } else if (isTemplateLiteral(value) && value.expressions.length === 0) {
-        const val = (0, import_shared3.getArbitraryValue)(value.quasis[0].value.raw);
-        sendReport(node, tokenWrap(val));
-      }
-    };
-    const handleLiteral = (node) => {
-      if (!isLiteral(node)) return;
-      const value = (0, import_shared3.getArbitraryValue)(node.value?.toString() ?? "");
-      if (isCompositeValue(value)) return;
-      sendReport(node, value);
-    };
-    const handleTemplateLiteral = (node) => {
-      if (!isTemplateLiteral(node) || node.expressions.length > 0) return;
-      const value = (0, import_shared3.getArbitraryValue)(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);
-        }
-      }
-    };
-  }
-});
-var no_unsafe_token_fn_usage_default = rule14;
-
-// src/rules/prefer-longhand-properties.ts
-var RULE_NAME15 = "prefer-longhand-properties";
-var 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);
-      }
-    };
-  }
-});
-var prefer_longhand_properties_default = rule15;
-
-// src/rules/prefer-shorthand-properties.ts
-var RULE_NAME16 = "prefer-shorthand-properties";
-var 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);
-      }
-    };
-  }
-});
-var prefer_shorthand_properties_default = rule16;
-
-// src/utils/composite-properties.ts
-var 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 = "prefer-atomic-properties";
-var 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);
-      }
-    };
-  }
-});
-var prefer_atomic_properties_default = rule17;
-
-// src/rules/prefer-composite-properties.ts
-var RULE_NAME18 = "prefer-composite-properties";
-var 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);
-      }
-    };
-  }
-});
-var prefer_composite_properties_default = rule18;
-
-// src/rules/prefer-unified-property-style.ts
-var RULE_NAME19 = "prefer-unified-property-style";
-var 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);
-      }
-    };
-  }
-});
-var prefer_unified_property_style_default = rule19;
-
-// src/rules/index.ts
-var 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 = [RULE_NAME, RULE_NAME2, RULE_NAME10];
-var allRules = Object.fromEntries(
-  Object.entries(rules).map(([name2]) => {
-    return [`@pandacss/${name2}`, errorRules.includes(name2) ? "error" : "warn"];
-  })
-);
-var all_default = {
-  parser: "@typescript-eslint/parser",
-  parserOptions: { sourceType: "module" },
-  plugins: ["@pandacss"],
-  rules: allRules
-};
-
-// src/configs/recommended.ts
-var 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"
-  }
-};
+var configs = { recommended };
 
 // src/index.ts
-var plugin = {
-  meta: {
-    name,
-    version
-  },
-  rules,
-  configs: {
-    all: all_default,
-    recommended: recommended_default
-  }
+var index_default = { meta: pluginMeta, configs };
+export {
+  FileInspector as Inspector,
+  Linter,
+  PLUGIN_NAMESPACE,
+  ProjectCache,
+  RangeIndex,
+  bindRules,
+  byteToIndex,
+  collectStrings,
+  configs,
+  consistentPropertyStyleRuleName,
+  createConsistentPropertyStyleRule,
+  createExtractionDiagnosticsRule,
+  createFileNotIncludedRule,
+  createNoDebugRule,
+  createNoDeprecatedRule,
+  createNoImportantRule,
+  createNoInvalidNestingRule,
+  createNoInvalidTokenPathsRule,
+  createNoMarginPropertiesRule,
+  createNoPhysicalPropertiesRule,
+  createNoPrimitiveTokenRule,
+  createNoShorthandLonghandMixRule,
+  createPandaPlugin,
+  createPreferTextStyleRule,
+  createPreferTokenRule,
+  index_default as default,
+  extractionDiagnosticsRuleName,
+  fileNotIncludedRuleName,
+  getContextFilename,
+  getContextSource,
+  getSourceText,
+  loadPandaProject,
+  noDebugRuleName,
+  noDeprecatedRuleName,
+  noImportantRuleName,
+  noInvalidNestingRuleName,
+  noInvalidTokenPathsRuleName,
+  noMarginPropertiesRuleName,
+  noPhysicalPropertiesRuleName,
+  noPrimitiveTokenRuleName,
+  noShorthandLonghandMixRuleName,
+  pluginMeta,
+  preferTextStyleRuleName,
+  preferTokenRuleName,
+  projectCacheKey,
+  recommended,
+  reportDiagnostics,
+  reportPrimitiveTokenViolations,
+  reportTokenViolations,
+  resolvePandaSettings,
+  sourceCacheKey,
+  toEslintLoc
 };
-module.exports = plugin;