@pragmatiks/lint 0.3.4 → 0.5.0

package/dist/eslint-config/next/index.js

@@ -0,0 +1,2610 @@
+import css from '@eslint/css';
+import reactX from 'eslint-plugin-react-x';
+import { readFileSync, existsSync } from 'fs';
+import path2 from 'path';
+import { fileURLToPath } from 'url';
+import { defineConfig, globalIgnores } from 'eslint/config';
+import sonarjs from 'eslint-plugin-sonarjs';
+import unicorn from 'eslint-plugin-unicorn';
+import tseslint from 'typescript-eslint';
+import { createRequire } from 'module';
+import { lexer, property, generate, toPlainObject, parse } from '@eslint/css-tree';
+
+// src/eslint-config/next/index.ts
+
+// src/eslint-config/options.ts
+var COMPLEXITY_OPTS = 10;
+var MAX_LINES_PER_FUNCTION_OPTS = {
+  max: 50,
+  skipBlankLines: true,
+  skipComments: true
+};
+var MAX_STATEMENTS_OPTS = 15;
+var MAX_DEPTH_OPTS = 4;
+var MAX_PARAMS_OPTS = 4;
+var PREVENT_ABBREVIATIONS_OPTS = {
+  allowList: {
+    id: true,
+    url: true,
+    uri: true,
+    api: true,
+    cli: true,
+    sdk: true,
+    os: true,
+    io: true,
+    ip: true,
+    tls: true,
+    ssl: true,
+    jwt: true,
+    json: true,
+    yaml: true,
+    html: true,
+    css: true,
+    dom: true,
+    ast: true,
+    gpu: true,
+    cpu: true,
+    ram: true,
+    vm: true,
+    props: true,
+    ref: true,
+    e: true
+  }
+};
+var FILENAME_CASE_OPTIONS = {
+  cases: {
+    kebabCase: true,
+    pascalCase: true,
+    camelCase: true
+  }
+};
+var NO_USELESS_UNDEFINED_OPTIONS = { checkArguments: false };
+
+// src/eslint-config/index.ts
+var PRAGMATIKS_LINT_FILES = ["**/*.{js,jsx,mjs,cjs,ts,tsx,mts,cts}"];
+function findPackageRoot(start) {
+  let current = start;
+  for (; ; ) {
+    if (existsSync(path2.join(current, "package.json"))) {
+      return current;
+    }
+    const parent = path2.dirname(current);
+    if (parent === current) {
+      throw new Error(`package.json not found above ${start}`);
+    }
+    current = parent;
+  }
+}
+function semgrepRulesDirectory() {
+  const here = path2.dirname(fileURLToPath(import.meta.url));
+  return path2.join(findPackageRoot(here), "src", "semgrep-rules");
+}
+function recommendedOrThrow(plugin, peer) {
+  const recommended = plugin.configs?.recommended;
+  if (!recommended) {
+    throw new Error(
+      `@pragmatiks/lint: ${peer.name} has no recommended flat-config preset (peer dependency major mismatch). To fix it, install ${peer.name} ${peer.range}.`
+    );
+  }
+  return { ...recommended, files: PRAGMATIKS_LINT_FILES };
+}
+function pragmatiksConfig() {
+  return defineConfig([
+    {
+      files: PRAGMATIKS_LINT_FILES,
+      languageOptions: {
+        parser: tseslint.parser,
+        parserOptions: {
+          ecmaVersion: "latest",
+          sourceType: "module"
+        }
+      },
+      settings: {
+        pragmatiksLint: {
+          semgrepRulesDirectory: semgrepRulesDirectory()
+        }
+      }
+    },
+    recommendedOrThrow(sonarjs, {
+      name: "eslint-plugin-sonarjs",
+      range: "^4.0.0"
+    }),
+    recommendedOrThrow(unicorn, {
+      name: "eslint-plugin-unicorn",
+      range: "^64.0.0"
+    }),
+    {
+      files: PRAGMATIKS_LINT_FILES,
+      rules: {
+        complexity: ["error", COMPLEXITY_OPTS],
+        "max-lines-per-function": ["error", MAX_LINES_PER_FUNCTION_OPTS],
+        "max-statements": ["error", MAX_STATEMENTS_OPTS],
+        "max-depth": ["error", MAX_DEPTH_OPTS],
+        "max-params": ["error", MAX_PARAMS_OPTS],
+        "unicorn/prevent-abbreviations": ["error", PREVENT_ABBREVIATIONS_OPTS]
+      }
+    },
+    globalIgnores(["dist/**", "node_modules/**", ".next/**", ".turbo/**"])
+  ]);
+}
+var CSS_WIDE_KEYWORDS = new Set(
+  lexer.cssWideKeywords
+);
+var TOP_CONTEXT = {
+  selectors: [],
+  layer: void 0,
+  inKeyframes: false,
+  inTheme: false,
+  block: void 0
+};
+var FOCUS_VARIANTS = /* @__PURE__ */ new Set(["focus", "focus-visible", "focus-within"]);
+var stylesheetDeclarations = /* @__PURE__ */ new WeakMap();
+function parseValue(text) {
+  let parsed;
+  try {
+    parsed = toPlainObject(
+      parse(text, { context: "value", parseCustomProperty: true })
+    );
+  } catch {
+    return { type: "Value", children: [{ type: "Raw", value: text }] };
+  }
+  if (parsed.type === "Value") {
+    return parsed;
+  }
+  return { type: "Value", children: [parsed] };
+}
+function normalizeProperty(property) {
+  return property.startsWith("--") ? property : property.toLowerCase();
+}
+function buildDeclaration(node, context) {
+  const text = node.value.type === "Raw" ? node.value.value.trim() : generate(node.value);
+  return {
+    property: normalizeProperty(node.property),
+    value: parseValue(text),
+    text,
+    important: Boolean(node.important),
+    ...context,
+    node
+  };
+}
+function layerName(node) {
+  if (!node.prelude) {
+    return "";
+  }
+  if (node.prelude.type === "Raw") {
+    return node.prelude.value.trim();
+  }
+  const [first] = node.prelude.children;
+  return first?.type === "Layer" ? first.name : generate(node.prelude);
+}
+function focusVariant(node) {
+  if (node.name.toLowerCase() !== "variant" || !node.prelude) {
+    return void 0;
+  }
+  const variant = generate(node.prelude).trim();
+  return FOCUS_VARIANTS.has(variant) ? variant : void 0;
+}
+function atruleContext(node, context) {
+  const name = node.name.toLowerCase();
+  if (name === "layer") {
+    const nested = layerName(node);
+    return {
+      ...context,
+      layer: context.layer === void 0 ? nested : `${context.layer}.${nested}`
+    };
+  }
+  if (name.endsWith("keyframes")) {
+    return { ...context, inKeyframes: true };
+  }
+  if (name === "theme") {
+    return { ...context, inTheme: true };
+  }
+  const variant = focusVariant(node);
+  if (variant === void 0) {
+    return context;
+  }
+  return {
+    ...context,
+    selectors: [...context.selectors, `&:${variant}`],
+    block: node
+  };
+}
+function collectDeclarations(nodes, context, output) {
+  for (const node of nodes) {
+    if (node.type === "Declaration") {
+      output.push(buildDeclaration(node, context));
+    } else if (node.type === "Rule") {
+      const selectors = [...context.selectors, generate(node.prelude)];
+      collectDeclarations(
+        node.block.children,
+        { ...context, selectors, block: node },
+        output
+      );
+    } else if (node.type === "Atrule" && node.block) {
+      collectDeclarations(
+        node.block.children,
+        atruleContext(node, context),
+        output
+      );
+    }
+  }
+  return output;
+}
+function collectStylesheetDeclarations(stylesheet) {
+  const cached = stylesheetDeclarations.get(stylesheet);
+  if (cached) {
+    return cached;
+  }
+  const declarations = collectDeclarations(
+    stylesheet.children,
+    TOP_CONTEXT,
+    []
+  );
+  stylesheetDeclarations.set(stylesheet, declarations);
+  return declarations;
+}
+function parseStylesheetDeclarations(css2) {
+  const stylesheet = toPlainObject(
+    parse(css2, { parseCustomProperty: true })
+  );
+  return collectStylesheetDeclarations(stylesheet);
+}
+function parseStyleLeaf(leaf) {
+  const { property, text } = leaf;
+  if (text === void 0) {
+    return void 0;
+  }
+  return {
+    property: normalizeProperty(property),
+    value: parseValue(text),
+    text,
+    important: false,
+    ...TOP_CONTEXT,
+    node: void 0
+  };
+}
+function listValueNodes(node) {
+  return [
+    node,
+    ...listCssChildren(node).flatMap((child) => listValueNodes(child))
+  ];
+}
+function listCssChildren(node) {
+  return "children" in node && Array.isArray(node.children) ? node.children : [];
+}
+function splitOnCommas(nodes) {
+  const segments = [[]];
+  for (const node of nodes) {
+    if (node.type === "Operator" && node.value === ",") {
+      segments.push([]);
+    } else {
+      segments.at(-1)?.push(node);
+    }
+  }
+  return segments;
+}
+function isVariableReference(node) {
+  return node?.type === "Function" && node.name.toLowerCase() === "var";
+}
+function firstIdentifierArgument(node) {
+  const [first] = node?.type === "Function" ? node.children : [];
+  return first?.type === "Identifier" ? first.name : void 0;
+}
+function referencedVariable(node) {
+  return isVariableReference(node) ? firstIdentifierArgument(node) : void 0;
+}
+
+// src/eslint-config/next/frontend/design-system.ts
+var DEFAULT_THEME_OPTION = 4;
+var CACHE_LIMIT = 1e4;
+var SUPPORTED_TAILWIND_RANGE = "~4.1.17";
+var VERSION_RECOVERY = `pin tailwindcss, @tailwindcss/postcss and @tailwindcss/node to the same ${SUPPORTED_TAILWIND_RANGE} version`;
+var CANARY_EXPECTATIONS = [
+  { token: "z-60", property: "z-index", value: "60" },
+  { token: "h-screen", property: "height", value: "100vh" },
+  { token: "transition-all", property: "transition-property", value: "all" },
+  { token: "bg-[#fff]", property: "background-color", value: "#fff" },
+  {
+    token: "focus-visible:outline-hidden",
+    property: "outline-style",
+    value: "none"
+  }
+];
+function loadManifest(directory) {
+  try {
+    return JSON.parse(
+      readFileSync(path2.join(directory, "package.json"), "utf8")
+    );
+  } catch {
+    return void 0;
+  }
+}
+function findPackageManifest(start, name) {
+  let current = start;
+  for (; ; ) {
+    const manifest = loadManifest(current);
+    if (manifest?.name === name) {
+      return manifest;
+    }
+    const parent = path2.dirname(current);
+    if (parent === current) {
+      throw new Error(
+        `@pragmatiks/lint: no package.json of ${name} above ${start}. To fix it, reinstall ${name}.`
+      );
+    }
+    current = parent;
+  }
+}
+function resolvePackageEntry(fromFile, name) {
+  try {
+    return createRequire(fromFile).resolve(name);
+  } catch {
+    throw new Error(
+      `@pragmatiks/lint: ${name} cannot be resolved from ${path2.dirname(fromFile)}. To fix it, install ${name} at ${SUPPORTED_TAILWIND_RANGE} in the app root.`
+    );
+  }
+}
+function readPackageVersion(fromFile, name) {
+  const entry = resolvePackageEntry(fromFile, name);
+  const version = findPackageManifest(path2.dirname(entry), name).version;
+  if (!version) {
+    throw new Error(
+      `@pragmatiks/lint: the package.json of ${name} has no version. To fix it, reinstall ${name}.`
+    );
+  }
+  return version;
+}
+function buildCandidateValue(candidate) {
+  const value = candidate.value;
+  if (typeof value === "string") {
+    return { valueKind: "arbitrary", value };
+  }
+  if (!value?.kind) {
+    return { valueKind: "none", value: void 0 };
+  }
+  return {
+    valueKind: value.kind === "arbitrary" ? "arbitrary" : "named",
+    value: value.value
+  };
+}
+function buildArbitraryInputs(candidate, value) {
+  const inputs = [];
+  if (value.valueKind === "arbitrary" && value.value !== void 0) {
+    inputs.push(value.value);
+  }
+  if (candidate.modifier?.kind === "arbitrary") {
+    inputs.push(candidate.modifier.value);
+  }
+  return inputs;
+}
+function buildClassCandidate(designSystem, candidate) {
+  const value = buildCandidateValue(candidate);
+  return {
+    utility: candidate.kind === "arbitrary" ? candidate.property ?? "" : candidate.root ?? "",
+    arbitraryProperty: candidate.kind === "arbitrary",
+    variants: candidate.variants.map(
+      (variant) => designSystem.printVariant(variant)
+    ),
+    important: candidate.important,
+    ...value,
+    modifierKind: candidate.modifier?.kind ?? "none",
+    arbitraryInputs: buildArbitraryInputs(candidate, value)
+  };
+}
+function collectProperties(nodes, output) {
+  for (const node of nodes ?? []) {
+    if (node.kind === "declaration" && node.property) {
+      output.add(node.property);
+    }
+    collectProperties(node.nodes, output);
+  }
+  return output;
+}
+function memoize(compute) {
+  const cache = /* @__PURE__ */ new Map();
+  return (key) => {
+    const result = cache.has(key) ? cache.get(key) : compute(key);
+    cache.delete(key);
+    cache.set(key, result);
+    if (cache.size > CACHE_LIMIT) {
+      cache.delete(cache.keys().next().value);
+    }
+    return result;
+  };
+}
+function createDesignSystemView(tailwind) {
+  const keyframes = /* @__PURE__ */ new Map();
+  for (const block of tailwind.theme.getKeyframes()) {
+    if (block.params) {
+      keyframes.set(block.params, [
+        ...collectProperties(block.nodes, /* @__PURE__ */ new Set())
+      ]);
+    }
+  }
+  return {
+    declarationsOf: memoize((token) => {
+      const css2 = tailwind.candidatesToCss([token])[0];
+      return css2 ? parseStylesheetDeclarations(css2) : void 0;
+    }),
+    candidatesOf: memoize(
+      (token) => tailwind.parseCandidate(token).map((candidate) => buildClassCandidate(tailwind, candidate))
+    ),
+    keyframeProperties: (name) => keyframes.get(name),
+    isDefaultThemeVariable: (variableName) => (tailwind.theme.getOptions(variableName) & DEFAULT_THEME_OPTION) !== 0,
+    themeValue: (variableName) => tailwind.resolveThemeValue(variableName)
+  };
+}
+function assertMatchingVersions(rootDirectory) {
+  const projectManifest = path2.join(rootDirectory, "package.json");
+  const versions = {
+    tailwindcss: readPackageVersion(projectManifest, "tailwindcss"),
+    "@tailwindcss/postcss": readPackageVersion(
+      projectManifest,
+      "@tailwindcss/postcss"
+    ),
+    "@tailwindcss/node": readPackageVersion(
+      fileURLToPath(import.meta.url),
+      "@tailwindcss/node"
+    )
+  };
+  if (new Set(Object.values(versions)).size !== 1) {
+    throw new Error(
+      `@pragmatiks/lint: tailwindcss, @tailwindcss/postcss and @tailwindcss/node need one Tailwind version; found ${JSON.stringify(versions)}. To fix it, ${VERSION_RECOVERY}.`
+    );
+  }
+}
+function assertTailwindApi(designSystem) {
+  const [candidate] = designSystem.parseCandidate(
+    "focus-visible:outline-hidden"
+  );
+  const usable = typeof designSystem.theme.getOptions === "function" && typeof designSystem.theme.getKeyframes === "function" && typeof designSystem.printVariant === "function" && typeof designSystem.resolveThemeValue === "function" && Array.isArray(candidate?.variants) && typeof candidate.important === "boolean" && typeof candidate.root === "string";
+  if (!usable) {
+    throw new Error(
+      `@pragmatiks/lint: the canary found that the Tailwind design system API changed shape. To fix it, ${VERSION_RECOVERY}, the range @pragmatiks/lint supports.`
+    );
+  }
+}
+function assertCanary(view) {
+  for (const expected of CANARY_EXPECTATIONS) {
+    const found = view.declarationsOf(expected.token)?.some(
+      (declaration) => declaration.property === expected.property && declaration.text === expected.value
+    );
+    if (!found) {
+      throw new Error(
+        `@pragmatiks/lint: the canary found that ${expected.token} no longer compiles to ${expected.property}: ${expected.value}. To fix it, ${VERSION_RECOVERY}, the range @pragmatiks/lint supports.`
+      );
+    }
+  }
+}
+async function loadDesignSystem(source) {
+  assertMatchingVersions(source.rootDir);
+  const { __unstable__loadDesignSystem } = await import('@tailwindcss/node');
+  const stylesheetPath = path2.resolve(
+    source.rootDir,
+    source.tailwindStylesheet
+  );
+  const stylesheet = readFileSync(stylesheetPath, "utf8");
+  const loaded = await __unstable__loadDesignSystem(stylesheet, {
+    base: path2.dirname(stylesheetPath)
+  });
+  const designSystem = loaded;
+  assertTailwindApi(designSystem);
+  const view = createDesignSystemView(designSystem);
+  assertCanary(view);
+  return view;
+}
+
+// src/eslint-config/next/frontend/class-group-declarations.ts
+function compileClassGroup(group, view) {
+  return group.tokens.flatMap((token) => {
+    const declarations = view.declarationsOf(token);
+    return declarations ? [{ token, declarations }] : [];
+  });
+}
+
+// src/eslint-config/next/frontend/ast.ts
+var FUNCTION_TYPES = /* @__PURE__ */ new Set([
+  "ArrowFunctionExpression",
+  "FunctionExpression",
+  "FunctionDeclaration"
+]);
+function toRuleNode(node) {
+  return node;
+}
+function toAstNode(node) {
+  return node;
+}
+function childNode(node, name) {
+  const value = node?.[name];
+  return value && typeof value === "object" && "type" in value ? value : void 0;
+}
+function childNodes(node, name) {
+  const value = node?.[name];
+  return Array.isArray(value) ? value : [];
+}
+function childString(node, name) {
+  const value = node?.[name];
+  return typeof value === "string" ? value : void 0;
+}
+function hasCookedText(value) {
+  return typeof value === "object" && value !== null && "cooked" in value && typeof value.cooked === "string";
+}
+function cookedText(quasi) {
+  const value = quasi?.value;
+  return hasCookedText(value) ? value.cooked : "";
+}
+function keyName(property) {
+  const key = childNode(property, "key");
+  if (!property.computed && key?.type === "Identifier") {
+    return childString(key, "name");
+  }
+  return key?.type === "Literal" ? childString(key, "value") : void 0;
+}
+function attributeName(attribute) {
+  return childString(childNode(attribute, "name"), "name");
+}
+function attributeExpression(attribute) {
+  const value = childNode(attribute, "value");
+  return value?.type === "JSXExpressionContainer" ? childNode(value, "expression") : void 0;
+}
+function jsxElementName(opening) {
+  const name = childNode(opening, "name");
+  return name?.type === "JSXIdentifier" ? childString(name, "name") : void 0;
+}
+function findJsxAttribute(opening, name) {
+  return childNodes(opening, "attributes").find(
+    (attribute) => attribute.type === "JSXAttribute" && attributeName(attribute) === name
+  );
+}
+function jsxAttributeValue(attribute) {
+  return attributeExpression(attribute) ?? childNode(attribute, "value");
+}
+function staticText(value) {
+  if (value?.type === "Literal" && (typeof value.value === "string" || typeof value.value === "number")) {
+    return String(value.value);
+  }
+  if (value?.type === "TemplateLiteral" && childNodes(value, "expressions").length === 0) {
+    return cookedText(childNodes(value, "quasis")[0]);
+  }
+  return void 0;
+}
+function findVariable(scope, name) {
+  for (let current = scope; current; current = current.upper) {
+    const variable = current.set.get(name);
+    if (variable) {
+      return variable;
+    }
+  }
+  return void 0;
+}
+function containsNode(outer, inner) {
+  const [outerStart, outerEnd] = outer.range ?? [0, -1];
+  const [innerStart, innerEnd] = inner.range ?? [0, -1];
+  return innerStart >= outerStart && innerEnd <= outerEnd;
+}
+
+// src/eslint-config/next/frontend/collect.ts
+var MOTION_ATTRIBUTE = /^(?:initial|animate|exit|variants|while[A-Z]\w*)$/;
+var EVENT_ATTRIBUTE = /^on[A-Z]/;
+var CLASS_ATTRIBUTE = /class(?:name)?s?$/i;
+var EXPRESSION_WRAPPERS = /* @__PURE__ */ new Set([
+  "TSAsExpression",
+  "TSSatisfiesExpression",
+  "TSNonNullExpression",
+  "ParenthesizedExpression"
+]);
+var CLASS_SOURCE_BOUNDARIES = /* @__PURE__ */ new Set([
+  "CallExpression",
+  "TaggedTemplateExpression",
+  "JSXElement",
+  "JSXFragment",
+  ...FUNCTION_TYPES
+]);
+var SOURCE_PARENTS = /* @__PURE__ */ new Set([
+  "ImportDeclaration",
+  "ExportNamedDeclaration",
+  "ExportAllDeclaration",
+  "ImportExpression"
+]);
+var TEMPLATE_BOUNDARY = "\0";
+var models = /* @__PURE__ */ new WeakMap();
+function computeCssPropertyName(key) {
+  if (key.startsWith("--")) {
+    return key;
+  }
+  const kebab = key.replaceAll(
+    /[A-Z]/g,
+    (letter) => `-${letter.toLowerCase()}`
+  );
+  return kebab.startsWith("ms-") ? `-${kebab}` : kebab;
+}
+function isClassHelperKey(parent) {
+  const object = parent.parent;
+  const call = object?.parent;
+  return parent.type === "Property" && object?.type === "ObjectExpression" && call?.type === "CallExpression" && childNodes(call, "arguments").includes(object);
+}
+function isNonClassAttributeValue(node) {
+  for (let current = node.parent; current; current = current.parent) {
+    if (current.type === "JSXAttribute") {
+      return !CLASS_ATTRIBUTE.test(attributeName(current) ?? "");
+    }
+    if (CLASS_SOURCE_BOUNDARIES.has(current.type)) {
+      return false;
+    }
+  }
+  return false;
+}
+function isExcludedLiteral(node) {
+  const parent = node.parent;
+  if (!parent) {
+    return true;
+  }
+  return SOURCE_PARENTS.has(parent.type) && parent.source === node || parent.type === "ExpressionStatement" && typeof parent.directive === "string" || parent.key === node && !parent.computed && !isClassHelperKey(parent) || parent.type === "TSLiteralType" || isNonClassAttributeValue(node);
+}
+function enclosingElement(node) {
+  for (let current = node.parent; current; current = current.parent) {
+    if (current.type === "JSXAttribute") {
+      return current.parent;
+    }
+  }
+  return void 0;
+}
+function templateTokens(node) {
+  const text = childNodes(node, "quasis").map((quasi) => cookedText(quasi)).join(TEMPLATE_BOUNDARY);
+  return text.split(/\s+/).filter((token) => token !== "" && !token.includes(TEMPLATE_BOUNDARY));
+}
+function collectClassGroup(node, model) {
+  if (isExcludedLiteral(node)) {
+    return;
+  }
+  const tokens = node.type === "Literal" ? String(node.value).split(/\s+/).filter(Boolean) : templateTokens(node);
+  if (tokens.length > 0) {
+    model.classGroups.push({ node, tokens, element: enclosingElement(node) });
+  }
+}
+function unwrapExpression(node) {
+  let current = node;
+  while (current && EXPRESSION_WRAPPERS.has(current.type)) {
+    current = childNode(current, "expression");
+  }
+  return current;
+}
+function listBranches(node) {
+  const expression = unwrapExpression(node);
+  if (expression?.type === "ConditionalExpression") {
+    return [
+      ...listBranches(childNode(expression, "consequent")),
+      ...listBranches(childNode(expression, "alternate"))
+    ];
+  }
+  if (expression?.type === "LogicalExpression") {
+    return [
+      ...listBranches(childNode(expression, "left")),
+      ...listBranches(childNode(expression, "right"))
+    ];
+  }
+  return expression ? [expression] : [];
+}
+function listObjectKeys(expression) {
+  return listBranches(expression).filter((branch) => branch.type === "ObjectExpression").flatMap((object) => childNodes(object, "properties")).flatMap((property) => {
+    const key = property.type === "Property" ? keyName(property) : void 0;
+    return key === void 0 ? [] : [{ property, key }];
+  });
+}
+function listStaticTexts(value) {
+  return listBranches(value).flatMap((branch) => {
+    const text = staticText(branch);
+    return text === void 0 ? [] : [text];
+  });
+}
+function listKeyValues(keys, element) {
+  return keys.flatMap(({ property, key }) => {
+    const texts = listStaticTexts(childNode(property, "value"));
+    const values = texts.length > 0 ? texts : [void 0];
+    return values.map((text) => ({
+      node: property,
+      property: computeCssPropertyName(key),
+      text,
+      element
+    }));
+  });
+}
+function collectStyleLeaves(attribute, model) {
+  const keys = listObjectKeys(attributeExpression(attribute));
+  model.styleLeaves.push(...listKeyValues(keys, attribute.parent));
+}
+function listVariantGroups(entries) {
+  return entries.map(({ property, key }) => ({
+    keys: listObjectKeys(childNode(property, "value")),
+    variantLabel: key
+  }));
+}
+function collectMotionKeys(attribute, name, model) {
+  const keys = listObjectKeys(attributeExpression(attribute));
+  const groups = name === "variants" ? listVariantGroups(keys) : [{ keys, variantLabel: void 0 }];
+  const motionKeys = groups.flatMap(
+    (group) => listKeyValues(group.keys, attribute.parent).map((leaf) => ({
+      ...leaf,
+      attributeName: name,
+      variantLabel: group.variantLabel
+    }))
+  );
+  model.motionKeys.push(...motionKeys);
+}
+function isUseCallback(callee) {
+  if (callee?.type === "Identifier") {
+    return callee.name === "useCallback";
+  }
+  return callee?.type === "MemberExpression" && childString(childNode(callee, "property"), "name") === "useCallback";
+}
+function bodyExpression(body) {
+  if (body?.type !== "BlockStatement") {
+    return body;
+  }
+  const statements = childNodes(body, "body");
+  const [only] = statements;
+  return statements.length === 1 && only?.type === "ExpressionStatement" ? childNode(only, "expression") : void 0;
+}
+function delegateCallee(handler) {
+  const call = bodyExpression(childNode(handler, "body"));
+  const callee = call?.type === "CallExpression" ? childNode(call, "callee") : void 0;
+  return callee?.type === "Identifier" ? callee : void 0;
+}
+function definitionExpression(definition) {
+  if (definition?.type === "FunctionName") {
+    return toAstNode(definition.node);
+  }
+  return definition?.type === "Variable" && definition.parent.kind === "const" ? childNode(toAstNode(definition.node), "init") : void 0;
+}
+function resolveHandlerFunctions(expression, sourceCode, seen) {
+  if (!expression || seen.has(expression)) {
+    return [];
+  }
+  seen.add(expression);
+  if (FUNCTION_TYPES.has(expression.type)) {
+    const delegates = resolveHandlerFunctions(
+      delegateCallee(expression),
+      sourceCode,
+      seen
+    );
+    return [expression, ...delegates];
+  }
+  if (expression.type === "CallExpression" && isUseCallback(childNode(expression, "callee"))) {
+    return resolveHandlerFunctions(
+      childNodes(expression, "arguments")[0],
+      sourceCode,
+      seen
+    );
+  }
+  if (expression.type !== "Identifier") {
+    return [];
+  }
+  const scope = sourceCode.getScope(toRuleNode(expression));
+  const definition = findVariable(scope, String(expression.name))?.defs[0];
+  return resolveHandlerFunctions(
+    definitionExpression(definition),
+    sourceCode,
+    seen
+  );
+}
+function isOpaqueAttribute(node) {
+  if (node.type !== "JSXAttribute") {
+    return false;
+  }
+  const name = attributeName(node) ?? "";
+  return name === "style" || MOTION_ATTRIBUTE.test(name);
+}
+function collectAttribute(attribute, model, sourceCode) {
+  const name = attributeName(attribute) ?? "";
+  if (name === "style") {
+    collectStyleLeaves(attribute, model);
+    return;
+  }
+  if (MOTION_ATTRIBUTE.test(name)) {
+    collectMotionKeys(attribute, name, model);
+    return;
+  }
+  if (!EVENT_ATTRIBUTE.test(name) || !attribute.parent) {
+    return;
+  }
+  const handlerFunctions = resolveHandlerFunctions(
+    attributeExpression(attribute),
+    sourceCode,
+    /* @__PURE__ */ new Set()
+  );
+  if (handlerFunctions.length > 0) {
+    model.pendingHandlers.push({
+      element: attribute.parent,
+      attributeName: name,
+      attribute,
+      handlerFunctions
+    });
+  }
+}
+function collectStyleAssignment(node, model) {
+  const target = childNode(node, "left");
+  const object = childNode(target, "object");
+  const isStyle = target?.type === "MemberExpression" && object?.type === "MemberExpression" && !object.computed && childString(childNode(object, "property"), "name") === "style";
+  if (!isStyle || !target) {
+    return;
+  }
+  const property = childNode(target, "property");
+  const name = target.computed ? childString(property, "value") : childString(property, "name");
+  if (name !== void 0) {
+    model.styleAssignments.push({
+      node,
+      property: computeCssPropertyName(name)
+    });
+  }
+}
+function collectNode(node, model, sourceCode) {
+  if (node.type === "JSXAttribute") {
+    collectAttribute(node, model, sourceCode);
+  } else if (node.type === "Literal" && typeof node.value === "string" || node.type === "TemplateLiteral") {
+    collectClassGroup(node, model);
+  } else if (node.type === "AssignmentExpression") {
+    collectStyleAssignment(node, model);
+  }
+}
+function traverse(node, keys, visit) {
+  if (!visit(node)) {
+    return;
+  }
+  for (const key of keys[node.type] ?? []) {
+    const child = node[key];
+    const children = Array.isArray(child) ? child : [child];
+    for (const item of children) {
+      if (item && typeof item === "object" && "type" in item) {
+        traverse(item, keys, visit);
+      }
+    }
+  }
+}
+function selectContainedAssignments(functions, assignments) {
+  return assignments.filter(
+    (assignment) => functions.some((container) => containsNode(container, assignment.node))
+  );
+}
+function collectFrontendModel(sourceCode) {
+  const cached = models.get(sourceCode.ast);
+  if (cached) {
+    return cached;
+  }
+  const model = {
+    classGroups: [],
+    styleLeaves: [],
+    motionKeys: [],
+    styleAssignments: [],
+    pendingHandlers: []
+  };
+  traverse(toAstNode(sourceCode.ast), sourceCode.visitorKeys, (node) => {
+    collectNode(node, model, sourceCode);
+    return !isOpaqueAttribute(node);
+  });
+  const { pendingHandlers, ...collected } = model;
+  const handlers = pendingHandlers.map(({ handlerFunctions, ...handler }) => ({
+    ...handler,
+    styleAssignments: selectContainedAssignments(
+      handlerFunctions,
+      collected.styleAssignments
+    )
+  }));
+  const result = { ...collected, handlers };
+  models.set(sourceCode.ast, result);
+  return result;
+}
+var MOTION_MESSAGES = {
+  all: "{{source}} transitions all properties; list the properties it animates, such as transform, opacity or filter.",
+  implicitAll: "{{source}} has a transition layer without a property, which animates all properties; name the property.",
+  layout: "{{source}} animates the layout property {{property}}; animate transform, opacity or filter instead.",
+  unverifiable: "{{source}} animates a property that cannot be verified statically; name a known property."
+};
+var LAYOUT_PROPERTIES = /* @__PURE__ */ new Set([
+  "width",
+  "height",
+  "min-width",
+  "min-height",
+  "max-width",
+  "max-height",
+  "block-size",
+  "inline-size",
+  "min-block-size",
+  "min-inline-size",
+  "max-block-size",
+  "max-inline-size",
+  "aspect-ratio",
+  "contain-intrinsic-size",
+  "contain-intrinsic-width",
+  "contain-intrinsic-height",
+  "contain-intrinsic-block-size",
+  "contain-intrinsic-inline-size",
+  "inset",
+  "inset-block",
+  "inset-block-start",
+  "inset-block-end",
+  "inset-inline",
+  "inset-inline-start",
+  "inset-inline-end",
+  "top",
+  "right",
+  "bottom",
+  "left",
+  "margin",
+  "margin-top",
+  "margin-right",
+  "margin-bottom",
+  "margin-left",
+  "margin-block",
+  "margin-block-start",
+  "margin-block-end",
+  "margin-inline",
+  "margin-inline-start",
+  "margin-inline-end",
+  "margin-trim",
+  "padding",
+  "padding-top",
+  "padding-right",
+  "padding-bottom",
+  "padding-left",
+  "padding-block",
+  "padding-block-start",
+  "padding-block-end",
+  "padding-inline",
+  "padding-inline-start",
+  "padding-inline-end",
+  "border",
+  "border-width",
+  "border-top",
+  "border-right",
+  "border-bottom",
+  "border-left",
+  "border-top-width",
+  "border-right-width",
+  "border-bottom-width",
+  "border-left-width",
+  "border-block",
+  "border-block-width",
+  "border-block-start",
+  "border-block-start-width",
+  "border-block-end",
+  "border-block-end-width",
+  "border-inline",
+  "border-inline-width",
+  "border-inline-start",
+  "border-inline-start-width",
+  "border-inline-end",
+  "border-inline-end-width",
+  "border-spacing",
+  "gap",
+  "row-gap",
+  "column-gap",
+  "grid-gap",
+  "grid-row-gap",
+  "grid-column-gap",
+  "grid",
+  "grid-area",
+  "grid-auto-columns",
+  "grid-auto-flow",
+  "grid-auto-rows",
+  "grid-column",
+  "grid-column-start",
+  "grid-column-end",
+  "grid-row",
+  "grid-row-start",
+  "grid-row-end",
+  "grid-template",
+  "grid-template-areas",
+  "grid-template-columns",
+  "grid-template-rows",
+  "flex",
+  "flex-basis",
+  "flex-direction",
+  "flex-flow",
+  "flex-grow",
+  "flex-line-count",
+  "flex-shrink",
+  "flex-wrap",
+  "order",
+  "columns",
+  "column-count",
+  "column-fill",
+  "column-height",
+  "column-span",
+  "column-width",
+  "column-wrap",
+  "font",
+  "font-family",
+  "font-feature-settings",
+  "font-kerning",
+  "font-language-override",
+  "font-optical-sizing",
+  "font-size",
+  "font-size-adjust",
+  "font-stretch",
+  "font-style",
+  "font-synthesis",
+  "font-synthesis-position",
+  "font-synthesis-small-caps",
+  "font-synthesis-style",
+  "font-synthesis-weight",
+  "font-variant",
+  "font-variant-alternates",
+  "font-variant-caps",
+  "font-variant-east-asian",
+  "font-variant-emoji",
+  "font-variant-ligatures",
+  "font-variant-numeric",
+  "font-variant-position",
+  "font-variation-settings",
+  "font-weight",
+  "font-width",
+  "line-height",
+  "letter-spacing",
+  "word-spacing",
+  "text-indent",
+  "tab-size",
+  "vertical-align",
+  "scrollbar-width",
+  "zoom"
+]);
+var TRANSITION_KEYWORDS = /* @__PURE__ */ new Set([
+  "ease",
+  "ease-in",
+  "ease-out",
+  "ease-in-out",
+  "linear",
+  "step-start",
+  "step-end",
+  "normal",
+  "allow-discrete"
+]);
+var THEME_ANIMATION = /^--animate-/;
+function isLayoutProperty(property$1) {
+  return LAYOUT_PROPERTIES.has(property(property$1).basename);
+}
+function classifyPropertyName(name) {
+  const lower = name.toLowerCase();
+  if (name.startsWith("--") || lower === "none" || CSS_WIDE_KEYWORDS.has(lower)) {
+    return void 0;
+  }
+  if (lower === "all") {
+    return { kind: "all", property: lower };
+  }
+  if (lexer.checkPropertyName(lower) !== void 0) {
+    return { kind: "unverifiable", property: lower };
+  }
+  return isLayoutProperty(lower) ? { kind: "layout", property: lower } : void 0;
+}
+function classifyTransitionLayer(layer) {
+  const rest = layer.filter((node) => !isVariableReference(node));
+  const stripped = rest.length !== layer.length;
+  if (rest.length > 0 && lexer.matchProperty("transition", { type: "Value", children: rest }).error) {
+    return { kind: "unverifiable", property: void 0 };
+  }
+  const names = rest.flatMap(
+    (node) => node.type === "Identifier" && !TRANSITION_KEYWORDS.has(node.name.toLowerCase()) ? [node.name] : []
+  );
+  const [name] = names;
+  if (name === void 0) {
+    return stripped ? { kind: "unverifiable", property: void 0 } : { kind: "implicitAll", property: void 0 };
+  }
+  return classifyPropertyName(name);
+}
+function classifyPropertyItem(item) {
+  const [only, ...rest] = item;
+  if (rest.length > 0 || only?.type !== "Identifier") {
+    return { kind: "unverifiable", property: void 0 };
+  }
+  return classifyPropertyName(only.name);
+}
+function isCssWideKeywordValue(value) {
+  const [only, ...rest] = value.children;
+  return rest.length === 0 && only?.type === "Identifier" && CSS_WIDE_KEYWORDS.has(only.name.toLowerCase());
+}
+function isPresent(finding) {
+  return finding !== void 0;
+}
+function evaluateTransition(declaration) {
+  const basename = property(declaration.property).basename;
+  if (basename !== "transition" && basename !== "transition-property" || isCssWideKeywordValue(declaration.value)) {
+    return [];
+  }
+  const layers = splitOnCommas(declaration.value.children);
+  const classify = basename === "transition" ? classifyTransitionLayer : classifyPropertyItem;
+  return layers.map((layer) => classify(layer)).filter((finding) => isPresent(finding));
+}
+function evaluateKeyframeDeclaration(declaration) {
+  return declaration.inKeyframes && isLayoutProperty(declaration.property) ? [{ kind: "layout", property: declaration.property }] : [];
+}
+function resolveThemeAnimationValues(value, view) {
+  return value.children.flatMap((node) => {
+    const name = referencedVariable(node);
+    if (name === void 0 || !THEME_ANIMATION.test(name)) {
+      return [];
+    }
+    const resolved = view.themeValue(name);
+    return resolved === void 0 ? [] : [parseValue(resolved)];
+  });
+}
+function evaluateAnimation(declaration, view) {
+  const basename = property(declaration.property).basename;
+  if (basename !== "animation" && basename !== "animation-name") {
+    return [];
+  }
+  const values = [
+    declaration.value,
+    ...resolveThemeAnimationValues(declaration.value, view)
+  ];
+  const properties = values.flatMap((value) => value.children).flatMap((node) => {
+    const name = animationName(node);
+    return name === void 0 ? [] : view.keyframeProperties(name) ?? [];
+  });
+  return [...new Set(properties)].filter((property) => isLayoutProperty(property)).map((property) => ({ kind: "layout", property }));
+}
+function animationName(node) {
+  if (node.type === "Identifier") {
+    return node.name;
+  }
+  return node.type === "String" ? node.value : void 0;
+}
+function evaluateMotionKey(property) {
+  return isLayoutProperty(property) ? [{ kind: "layout", property }] : [];
+}
+function reportMotionFindings(report, node, source, findings) {
+  for (const finding of findings) {
+    report({
+      node,
+      messageId: finding.kind,
+      data: { source, property: finding.property ?? "" }
+    });
+  }
+}
+
+// src/eslint-config/next/frontend/report.ts
+function createUniqueReporter(context) {
+  const reported = /* @__PURE__ */ new Map();
+  return ({ node, messageId, data }) => {
+    const key = JSON.stringify([messageId, data ?? {}]);
+    const keys = reported.get(node) ?? /* @__PURE__ */ new Set();
+    if (keys.has(key)) {
+      return;
+    }
+    keys.add(key);
+    reported.set(node, keys);
+    context.report({ node: toRuleNode(node), messageId, data });
+  };
+}
+
+// src/eslint-config/next/frontend/rules/animated-properties.ts
+function evaluateDeclarationMotion(declaration, view) {
+  return declaration ? [
+    ...evaluateTransition(declaration),
+    ...evaluateAnimation(declaration, view)
+  ] : [];
+}
+function reportModelMotion(report, model, view) {
+  for (const group of model.classGroups) {
+    for (const { token, declarations } of compileClassGroup(group, view)) {
+      const findings = declarations.flatMap(
+        (declaration) => evaluateDeclarationMotion(declaration, view)
+      );
+      reportMotionFindings(report, group.node, token, findings);
+    }
+  }
+  for (const leaf of model.styleLeaves) {
+    const findings = evaluateDeclarationMotion(parseStyleLeaf(leaf), view);
+    reportMotionFindings(report, leaf.node, leaf.property, findings);
+  }
+  for (const key of model.motionKeys) {
+    const findings = evaluateMotionKey(key.property);
+    reportMotionFindings(report, key.node, key.property, findings);
+  }
+}
+function createAnimatedPropertiesRule(view) {
+  return {
+    meta: {
+      type: "problem",
+      docs: { description: "Animate paint properties only." },
+      messages: MOTION_MESSAGES,
+      schema: []
+    },
+    create(context) {
+      return {
+        "Program:exit"() {
+          const report = createUniqueReporter(context);
+          const model = collectFrontendModel(context.sourceCode);
+          reportModelMotion(report, model, view);
+        }
+      };
+    }
+  };
+}
+var DEFAULT_PALETTE_MESSAGE = "{{source}} uses {{variable}} from Tailwind's default palette; use a project color token.";
+var COLOR_FUNCTIONS = /* @__PURE__ */ new Set([
+  "rgb",
+  "rgba",
+  "hsl",
+  "hsla",
+  "hwb",
+  "lab",
+  "lch",
+  "oklab",
+  "oklch",
+  "color"
+]);
+var KEYWORD_COLORS = /* @__PURE__ */ new Set(["transparent", "currentcolor"]);
+var THEME_COLOR = /^--color-/;
+var THEME_FUNCTIONS = /* @__PURE__ */ new Set(["var", "theme", "--theme"]);
+function isKeywordColor(node) {
+  return node?.type === "Identifier" && KEYWORD_COLORS.has(node.name.toLowerCase());
+}
+function isNamedColor(node) {
+  return node.type === "Identifier" && !isKeywordColor(node) && lexer.matchType("named-color", node).error === null;
+}
+function functionArguments(node) {
+  return node.type === "Function" ? node.children.filter((child) => child.type !== "Operator") : [];
+}
+function hasTokenChannels(node) {
+  const name = node.type === "Function" ? node.name.toLowerCase() : "";
+  const [first, ...rest] = functionArguments(node);
+  if (first?.type === "Identifier" && first.name.toLowerCase() === "from") {
+    const [origin, ...channels2] = rest;
+    const skipped = name === "color" ? channels2.slice(1) : channels2;
+    return isVariableReference(origin) && skipped.every(
+      (channel) => channel.type === "Identifier" || isVariableReference(channel)
+    );
+  }
+  const channels = name === "color" && first?.type === "Identifier" ? rest : [first, ...rest];
+  return channels.every((channel) => isVariableReference(channel));
+}
+function hasTokenOperands(node) {
+  const [, ...operands] = splitOnCommas(
+    node.type === "Function" ? node.children : []
+  );
+  return operands.every(
+    (operand) => operand.every(
+      (part) => part.type === "Percentage" || isVariableReference(part) || isKeywordColor(part)
+    )
+  );
+}
+function containsLiteral(node) {
+  if (node.type === "Hash" || isNamedColor(node)) {
+    return true;
+  }
+  if (node.type !== "Function" && node.type !== "Value" && node.type !== "Parentheses") {
+    return false;
+  }
+  const name = node.type === "Function" ? node.name.toLowerCase() : "";
+  if (name === "var") {
+    return splitOnCommas(node.children).slice(1).some((fallback) => fallback.some((part) => containsLiteral(part)));
+  }
+  if (COLOR_FUNCTIONS.has(name)) {
+    return !hasTokenChannels(node);
+  }
+  if (name === "color-mix") {
+    return !hasTokenOperands(node);
+  }
+  return node.children.some((child) => containsLiteral(child));
+}
+function containsColorLiteral(text) {
+  return containsLiteral(parseValue(text));
+}
+function substituteVariableFallbacks(node) {
+  if (isVariableReference(node)) {
+    const comma = node.children.findIndex(
+      (child) => child.type === "Operator" && child.value === ","
+    );
+    return comma === -1 ? [node] : node.children.slice(comma + 1).flatMap((child) => substituteVariableFallbacks(child));
+  }
+  const children = listCssChildren(node);
+  if (children.length === 0) {
+    return [node];
+  }
+  const substituted = children.flatMap(
+    (child) => substituteVariableFallbacks(child)
+  );
+  return [{ ...node, children: substituted }];
+}
+function canSetColor(declaration) {
+  if (declaration.property.startsWith("--")) {
+    return true;
+  }
+  const [value = declaration.value] = substituteVariableFallbacks(
+    declaration.value
+  );
+  const match = lexer.matchProperty(declaration.property, value);
+  if (match.error !== null) {
+    return true;
+  }
+  return listValueNodes(value).some(
+    (node) => match.isType(node, "color")
+  );
+}
+function themeColorVariable(candidate) {
+  return `--color-${candidate.value ?? ""}`;
+}
+function projectThemeValue(candidate, view) {
+  const variable = themeColorVariable(candidate);
+  return candidate.valueKind === "named" && !view.isDefaultThemeVariable(variable) ? view.themeValue(variable) : void 0;
+}
+function isProjectThemeColor(candidate, view) {
+  return projectThemeValue(candidate, view) !== void 0;
+}
+function listAliasedPaletteColors(candidate, view) {
+  const value = projectThemeValue(candidate, view);
+  return value === void 0 ? [] : listDefaultPaletteColors(parseValue(value), view);
+}
+function listDefaultPaletteColors(value, view) {
+  return listValueNodes(value).flatMap((node) => {
+    const isThemeReference = node.type === "Function" && THEME_FUNCTIONS.has(node.name.toLowerCase());
+    const name = isThemeReference ? firstIdentifierArgument(node) : void 0;
+    const isDefaultColor = name !== void 0 && THEME_COLOR.test(name) && view.isDefaultThemeVariable(name);
+    return isDefaultColor ? [name] : [];
+  });
+}
+
+// src/eslint-config/next/frontend/rules/color-tokens.ts
+function hasColorLiteral(token, declarations, view) {
+  const inputs = view.candidatesOf(token).flatMap((candidate) => candidate.arbitraryInputs);
+  return inputs.some((input) => containsColorLiteral(input)) && declarations.some((declaration) => canSetColor(declaration));
+}
+function collectExemptPaletteColors(token, view) {
+  return new Set(
+    view.candidatesOf(token).flatMap((candidate) => listAliasedPaletteColors(candidate, view))
+  );
+}
+function checkClassGroup(report, group, view) {
+  for (const { token, declarations } of compileClassGroup(group, view)) {
+    if (hasColorLiteral(token, declarations, view)) {
+      report({
+        node: group.node,
+        messageId: "literal",
+        data: { source: token }
+      });
+    }
+    const exemptVariables = collectExemptPaletteColors(token, view);
+    for (const declaration of declarations) {
+      const paletteColors = listDefaultPaletteColors(declaration.value, view);
+      const variables = paletteColors.filter(
+        (variable) => !exemptVariables.has(variable)
+      );
+      for (const variable of variables) {
+        report({
+          node: group.node,
+          messageId: "defaultPalette",
+          data: { source: token, variable }
+        });
+      }
+    }
+  }
+}
+function checkStyleLeaf(report, leaf, view) {
+  const declaration = parseStyleLeaf(leaf);
+  if (!declaration) {
+    return;
+  }
+  const variables = listDefaultPaletteColors(declaration.value, view);
+  for (const variable of variables) {
+    report({
+      node: leaf.node,
+      messageId: "defaultPalette",
+      data: { source: leaf.property, variable }
+    });
+  }
+}
+function createColorTokensRule(view) {
+  return {
+    meta: {
+      type: "problem",
+      docs: { description: "Use project color tokens." },
+      messages: {
+        literal: "{{source}} writes a color literal; use a project color token such as bg-(--token).",
+        defaultPalette: DEFAULT_PALETTE_MESSAGE
+      },
+      schema: []
+    },
+    create(context) {
+      return {
+        "Program:exit"() {
+          const report = createUniqueReporter(context);
+          const model = collectFrontendModel(context.sourceCode);
+          for (const group of model.classGroups) {
+            checkClassGroup(report, group, view);
+          }
+          for (const leaf of model.styleLeaves) {
+            checkStyleLeaf(report, leaf, view);
+          }
+        }
+      };
+    }
+  };
+}
+
+// src/eslint-config/next/frontend/rules/css-animated-properties.ts
+function createCssAnimatedPropertiesRule(view) {
+  return {
+    meta: {
+      type: "problem",
+      docs: { description: "Animate paint properties only." },
+      messages: MOTION_MESSAGES,
+      schema: []
+    },
+    create(context) {
+      const report = (motionReport) => {
+        context.report(motionReport);
+      };
+      return {
+        StyleSheet(node) {
+          for (const declaration of collectStylesheetDeclarations(node)) {
+            const findings = [
+              ...evaluateTransition(declaration),
+              ...evaluateKeyframeDeclaration(declaration),
+              ...evaluateAnimation(declaration, view)
+            ];
+            reportMotionFindings(
+              report,
+              declaration.node ?? node,
+              declaration.property,
+              findings
+            );
+          }
+        }
+      };
+    }
+  };
+}
+
+// src/eslint-config/next/frontend/rules/css-color-tokens.ts
+function isThemeDefinition(declaration) {
+  return declaration.inTheme && declaration.property.startsWith("--");
+}
+function createCssColorTokensRule(view) {
+  return {
+    meta: {
+      type: "problem",
+      docs: { description: "Use project color tokens." },
+      messages: { defaultPalette: DEFAULT_PALETTE_MESSAGE },
+      schema: []
+    },
+    create(context) {
+      return {
+        StyleSheet(node) {
+          for (const declaration of collectStylesheetDeclarations(node)) {
+            if (isThemeDefinition(declaration)) {
+              continue;
+            }
+            const variables = new Set(
+              listDefaultPaletteColors(declaration.value, view)
+            );
+            for (const variable of variables) {
+              context.report({
+                node: declaration.node ?? node,
+                messageId: "defaultPalette",
+                data: { source: declaration.property, variable }
+              });
+            }
+          }
+        }
+      };
+    }
+  };
+}
+var FOCUS_SELECTOR = /(?<!\\):focus/;
+var SHADOW_VARIABLES = /* @__PURE__ */ new Set(["--tw-shadow", "--tw-inset-shadow"]);
+var OUTLINE_WIDTH_KEYWORDS = /* @__PURE__ */ new Set(["thin", "medium", "thick"]);
+var EARLY_LAYERS = /* @__PURE__ */ new Set(["theme", "base", "components"]);
+var RING_SHADOW_VARIABLES = ["--tw-ring-offset-shadow", "--tw-ring-shadow"];
+var UNPAIRED_OFFSET_LABEL = "a ring offset color only alongside focus-visible:ring-offset-<n> (required when above 0)";
+var ROLE_LIMITS = {
+  "outline-hidden": {
+    minimum: 1,
+    maximum: 1,
+    label: "focus-visible:outline-hidden"
+  },
+  "ring-width": {
+    minimum: 1,
+    maximum: 1,
+    label: "focus-visible:ring or focus-visible:ring-<n>"
+  },
+  "ring-color": { minimum: 0, maximum: 1, label: "one ring color" },
+  "offset-width": { minimum: 0, maximum: 1, label: "one ring offset" },
+  "zero-offset-width": { minimum: 0, maximum: 1, label: "one ring offset" },
+  "offset-color": { minimum: 0, maximum: 1, label: "one ring offset color" }
+};
+var RING_FAMILIES = [
+  {
+    utility: "ring-offset",
+    widthVariable: "--tw-ring-offset-width",
+    widthRole: offsetWidthRole,
+    colorVariable: "--tw-ring-offset-color",
+    colorRole: "offset-color"
+  },
+  {
+    utility: "ring",
+    widthVariable: "--tw-ring-shadow",
+    widthRole: ringWidthRole,
+    colorVariable: "--tw-ring-color",
+    colorRole: "ring-color"
+  }
+];
+function isFocusSelector(selector) {
+  return FOCUS_SELECTOR.test(selector);
+}
+function isFocusIndicatorProperty(property$1) {
+  const name = property(property$1).basename;
+  return name.startsWith("outline") || name.startsWith("--tw-ring-") || name.startsWith("--tw-inset-ring-") || name === "forced-color-adjust" || name === "all";
+}
+function isBoxShadowProperty(property$1) {
+  return property(property$1).basename === "box-shadow";
+}
+function composesRing(declaration) {
+  const variables = new Set(
+    listValueNodes(declaration.value).flatMap((node) => {
+      const name = referencedVariable(node);
+      return name === void 0 ? [] : [name];
+    })
+  );
+  return RING_SHADOW_VARIABLES.every((variable) => variables.has(variable));
+}
+function isShadowValue(declaration) {
+  const text = declaration.text.trim().toLowerCase();
+  if (text === "none" || CSS_WIDE_KEYWORDS.has(text)) {
+    return false;
+  }
+  return text.includes("var(") || lexer.matchProperty("box-shadow", declaration.value).error === null;
+}
+function isShadowVariableReset(declaration) {
+  return SHADOW_VARIABLES.has(declaration.property) && !isShadowValue(declaration);
+}
+function isScopedClassDeclaration(declaration) {
+  return declaration.selectors.some((selector) => isFocusSelector(selector)) || isFocusIndicatorProperty(declaration.property) || declaration.property === "--tw-outline-style" || isBoxShadowProperty(declaration.property) && !composesRing(declaration) || isShadowVariableReset(declaration);
+}
+function isFocusScopedToken(token, view) {
+  const declarations = view.declarationsOf(token);
+  if (!declarations) {
+    return false;
+  }
+  return declarations.some((declaration) => isScopedClassDeclaration(declaration)) || view.candidatesOf(token).some(
+    (candidate) => candidate.arbitraryProperty && SHADOW_VARIABLES.has(candidate.utility)
+  );
+}
+function plainVariableOfNode(node) {
+  const name = node?.type === "Function" && node.children.length === 1 ? referencedVariable(node) : void 0;
+  return name?.startsWith("--") ? name : void 0;
+}
+function plainVariableOfValue(value) {
+  const [only, ...rest] = value?.children ?? [];
+  return rest.length === 0 ? plainVariableOfNode(only) : void 0;
+}
+function isTokenColor(declarations, property, view) {
+  const variable = plainVariableOfValue(
+    declarations.find((declaration) => declaration.property === property)?.value
+  );
+  return variable !== void 0 && !view.isDefaultThemeVariable(variable);
+}
+function isWholeNumberAtLeast(value, minimum) {
+  return value !== void 0 && /^\d+$/.test(value) && Number(value) >= minimum;
+}
+function ringWidthRole(candidate) {
+  const isRingWidth = candidate.valueKind === "none" || candidate.valueKind === "named" && isWholeNumberAtLeast(candidate.value, 1);
+  return isRingWidth ? "ring-width" : void 0;
+}
+function offsetWidthRole(candidate) {
+  if (candidate.valueKind !== "named" || !isWholeNumberAtLeast(candidate.value, 0)) {
+    return void 0;
+  }
+  return Number(candidate.value) === 0 ? "zero-offset-width" : "offset-width";
+}
+function ringRole(token, view) {
+  const declarations = view.declarationsOf(token) ?? [];
+  const setsVariable = (variable) => declarations.some((declaration) => declaration.property === variable);
+  const family = RING_FAMILIES.find(
+    (ringFamily) => setsVariable(ringFamily.widthVariable) || setsVariable(ringFamily.colorVariable)
+  );
+  const candidate = view.candidatesOf(token).find((parse2) => parse2.utility === family?.utility);
+  if (!family || !candidate) {
+    return void 0;
+  }
+  if (setsVariable(family.widthVariable)) {
+    return family.widthRole(candidate);
+  }
+  const isColor = candidate.modifierKind === "none" && (isTokenColor(declarations, family.colorVariable, view) || isProjectThemeColor(candidate, view));
+  return isColor ? family.colorRole : void 0;
+}
+function p1Role(token, view) {
+  const candidates = view.candidatesOf(token);
+  const wellFormed = candidates.every(
+    (candidate) => !candidate.important && candidate.variants.length === 1 && candidate.variants[0] === "focus-visible"
+  );
+  if (!wellFormed || candidates.length === 0) {
+    return void 0;
+  }
+  const outlineHidden = candidates.every(
+    (candidate) => candidate.utility === "outline-hidden" && candidate.valueKind === "none" || candidate.utility === "outline" && candidate.valueKind === "named" && candidate.value === "hidden"
+  );
+  if (outlineHidden) {
+    return "outline-hidden";
+  }
+  return ringRole(token, view);
+}
+function listOutOfRangeLabels(counts) {
+  const offsetWidths = counts.get("offset-width") ?? 0;
+  const zeroOffsetWidths = counts.get("zero-offset-width") ?? 0;
+  const offsetColors = counts.get("offset-color") ?? 0;
+  const labels = new Set(
+    Object.entries(ROLE_LIMITS).filter(([role, limit]) => {
+      const count = counts.get(role) ?? 0;
+      return count < limit.minimum || count > limit.maximum;
+    }).map(([, limit]) => limit.label)
+  );
+  if (offsetWidths + zeroOffsetWidths > 1) {
+    labels.add(ROLE_LIMITS["offset-width"].label);
+  }
+  if (offsetColors < offsetWidths || offsetColors > offsetWidths + zeroOffsetWidths) {
+    labels.add(UNPAIRED_OFFSET_LABEL);
+  }
+  return [...labels];
+}
+function evaluateFocusGroup(tokens, view) {
+  const scoped = tokens.filter((token) => isFocusScopedToken(token, view));
+  if (scoped.length === 0) {
+    return { scoped, offending: [], outOfRange: [] };
+  }
+  const counts = /* @__PURE__ */ new Map();
+  const offending = [];
+  for (const token of scoped) {
+    const role = p1Role(token, view);
+    if (role === void 0) {
+      offending.push(token);
+    } else {
+      counts.set(role, (counts.get(role) ?? 0) + 1);
+    }
+  }
+  return { scoped, offending, outOfRange: listOutOfRangeLabels(counts) };
+}
+function isFocusScopedCssDeclaration(declaration) {
+  if (isFocusIndicatorProperty(declaration.property) || isShadowVariableReset(declaration)) {
+    return true;
+  }
+  if (!isBoxShadowProperty(declaration.property)) {
+    return false;
+  }
+  if (declaration.important) {
+    return true;
+  }
+  const firstLayer = declaration.layer?.split(".")[0];
+  const beatsUtilities = firstLayer === void 0 || !EARLY_LAYERS.has(firstLayer) || declaration.inKeyframes;
+  return beatsUtilities && !composesRing(declaration);
+}
+function endsWithFocusVisible(selector) {
+  const last = listCssChildren(selector).at(-1);
+  return last?.type === "PseudoClassSelector" && last.name === "focus-visible";
+}
+function isNonZeroWidth(width) {
+  if (!width || lexer.matchType("line-width", width).error !== null) {
+    return false;
+  }
+  if (width.type === "Dimension") {
+    return Number(width.value) > 0;
+  }
+  return width.type === "Identifier" && OUTLINE_WIDTH_KEYWORDS.has(width.name);
+}
+function isC1Outline(value) {
+  const [width, style, color, ...rest] = value.children;
+  const solid = style?.type === "Identifier" && style.name === "solid";
+  return rest.length === 0 && solid && isNonZeroWidth(width) && plainVariableOfNode(color) !== void 0;
+}
+function isC1Declarations(declarations) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const { property } of declarations) {
+    counts.set(property, (counts.get(property) ?? 0) + 1);
+  }
+  const outlines = declarations.filter(
+    (declaration) => declaration.property === "outline"
+  );
+  const otherProperties = [...counts.keys()].filter(
+    (property) => property !== "outline" && property !== "outline-offset"
+  );
+  return counts.get("outline") === 1 && (counts.get("outline-offset") ?? 0) <= 1 && otherProperties.length === 0 && declarations.every((declaration) => !declaration.important) && outlines.every((declaration) => isC1Outline(declaration.value));
+}
+function allSelectorsEndWithFocusVisible(block) {
+  if (block.type === "Atrule") {
+    return focusVariant(block) === "focus-visible";
+  }
+  return block.prelude.type === "SelectorList" && block.prelude.children.every((selector) => endsWithFocusVisible(selector));
+}
+function matchesC1(block, declarations) {
+  return allSelectorsEndWithFocusVisible(block) && isC1Declarations(declarations);
+}
+
+// src/eslint-config/next/frontend/rules/css-focus-styling.ts
+function groupFocusBlocks(declarations) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const declaration of declarations) {
+    const block = declaration.block;
+    if (!block || !declaration.selectors.some((selector) => isFocusSelector(selector))) {
+      continue;
+    }
+    const group = groups.get(block) ?? [];
+    group.push(declaration);
+    groups.set(block, group);
+  }
+  return groups;
+}
+var cssFocusStylingRule = {
+  meta: {
+    type: "problem",
+    docs: { description: "Allow only the C1 focus pattern." },
+    messages: {
+      focusRule: "A focus rule must be exactly C1: every selector ends in :focus-visible (or the rule is an @variant focus-visible block), and the only declarations are outline: <non-zero width> solid var(--token) and an optional outline-offset, without !important.",
+      focusDeclaration: "{{property}} outside a C1 focus rule can hide or override the focus indicator; move focus styling into a C1 rule, and put a decorative box-shadow in @layer components or use filter: drop-shadow()."
+    },
+    schema: []
+  },
+  create(context) {
+    return {
+      StyleSheet(node) {
+        const declarations = collectStylesheetDeclarations(node);
+        const focusBlocks = groupFocusBlocks(declarations);
+        for (const [block, blockDeclarations] of focusBlocks) {
+          if (!matchesC1(block, blockDeclarations)) {
+            context.report({ node: block, messageId: "focusRule" });
+          }
+        }
+        const grouped = new Set([...focusBlocks.values()].flat());
+        for (const declaration of declarations) {
+          if (declaration.node && !grouped.has(declaration) && isFocusScopedCssDeclaration(declaration)) {
+            context.report({
+              node: declaration.node,
+              messageId: "focusDeclaration",
+              data: { property: declaration.property }
+            });
+          }
+        }
+      }
+    };
+  }
+};
+
+// src/eslint-config/next/frontend/rules/css-no-apply.ts
+var cssNoApplyRule = {
+  meta: {
+    type: "problem",
+    docs: { description: "Disallow @apply." },
+    messages: {
+      apply: "Write the classes in markup or plain declarations here; @apply hides them from the lint rules."
+    },
+    schema: []
+  },
+  create(context) {
+    return {
+      Atrule(node) {
+        if (node.name.toLowerCase() === "apply") {
+          context.report({ node, messageId: "apply" });
+        }
+      }
+    };
+  }
+};
+
+// src/eslint-config/next/frontend/rules/css-parsed-fully.ts
+var cssParsedFullyRule = {
+  meta: {
+    type: "problem",
+    docs: { description: "Require blocks to parse fully." },
+    messages: {
+      unparsed: "This part of the block did not parse, so no rule checks it; rewrite it as plain declarations and nested rules, wrapping declarations that sit between nested rules in & { \u2026 } so they keep their order.",
+      swallowed: "The declarations before this nested rule did not parse, so no rule checks them; wrap them in & { \u2026 } where they stand, or move @keyframes into an @theme block of their own."
+    },
+    schema: []
+  },
+  create(context) {
+    return {
+      Block(node) {
+        for (const child of node.children) {
+          if (child.type === "Raw") {
+            context.report({ node: child, messageId: "unparsed" });
+          }
+        }
+      },
+      Rule(node) {
+        if (node.prelude.type === "Raw" && /[:;]/.test(node.prelude.value)) {
+          context.report({ node: node.prelude, messageId: "swallowed" });
+        }
+      }
+    };
+  }
+};
+
+// src/eslint-config/next/frontend/concepts/viewport.ts
+var VH_UNIT_MESSAGE = "{{source}} uses vh, which ignores mobile browser chrome; use dvh, svh or lvh, such as h-dvh or min-h-svh.";
+function usesVhUnit(declaration) {
+  return listValueNodes(declaration.value).some(
+    (node) => node.type === "Dimension" && node.unit.toLowerCase() === "vh"
+  );
+}
+
+// src/eslint-config/next/frontend/css-declaration-rule.ts
+function createCssDeclarationRule(options) {
+  return {
+    meta: {
+      type: "problem",
+      docs: { description: options.description },
+      messages: { [options.messageId]: options.message },
+      schema: []
+    },
+    create(context) {
+      return {
+        StyleSheet(node) {
+          for (const declaration of collectStylesheetDeclarations(node)) {
+            if (options.matches(declaration)) {
+              context.report({
+                node: declaration.node ?? node,
+                messageId: options.messageId,
+                data: { source: options.describe(declaration) }
+              });
+            }
+          }
+        }
+      };
+    }
+  };
+}
+
+// src/eslint-config/next/frontend/rules/css-viewport-units.ts
+var cssViewportUnitsRule = createCssDeclarationRule({
+  description: "Disallow vh units.",
+  messageId: "vhUnit",
+  message: VH_UNIT_MESSAGE,
+  matches: usesVhUnit,
+  describe: (declaration) => declaration.property
+});
+
+// src/eslint-config/next/frontend/concepts/z-index.ts
+var Z_INDEX_CAP = 50;
+var Z_INDEX_MESSAGE = `z-index must be at most ${String(Z_INDEX_CAP)}, negative, auto, or a var() whose theme value or fallback is; {{source}} is not. To fix it, use the scale up to ${String(Z_INDEX_CAP)} or a named layer such as z-(--layer).`;
+var MAX_VARIABLE_DEPTH = 4;
+function calcArguments(node) {
+  return node.type === "Function" && node.name.toLowerCase() === "calc" ? node.children : [];
+}
+function computeProduct(node) {
+  const [left, operator, right, ...rest] = calcArguments(node);
+  const isMultiplication = operator?.type === "Operator" && operator.value === "*";
+  if (rest.length > 0 || !isMultiplication || left?.type !== "Number" || right?.type !== "Number") {
+    return void 0;
+  }
+  return Number(left.value) * Number(right.value);
+}
+function resolveVariable(node, view) {
+  const name = firstIdentifierArgument(node);
+  const themeValue = name === void 0 ? void 0 : view.themeValue(name);
+  if (themeValue !== void 0) {
+    return parseValue(themeValue);
+  }
+  const fallback = listCssChildren(node).at(2);
+  return fallback?.type === "Value" ? fallback : void 0;
+}
+function isAllowedValue(value, view, depth) {
+  const [node, ...rest] = value.children;
+  if (rest.length > 0 || !node) {
+    return false;
+  }
+  if (node.type === "Number") {
+    return Number(node.value) <= Z_INDEX_CAP;
+  }
+  if (node.type === "Identifier") {
+    return node.name.toLowerCase() === "auto";
+  }
+  if (isVariableReference(node)) {
+    const resolved = resolveVariable(node, view);
+    return resolved === void 0 || depth > 0 && isAllowedValue(resolved, view, depth - 1);
+  }
+  const product = computeProduct(node);
+  return product !== void 0 && product <= Z_INDEX_CAP;
+}
+function exceedsZIndexCap(declaration, view) {
+  return declaration.property === "z-index" && !isAllowedValue(declaration.value, view, MAX_VARIABLE_DEPTH);
+}
+
+// src/eslint-config/next/frontend/rules/css-z-index.ts
+function createCssZIndexRule(view) {
+  return createCssDeclarationRule({
+    description: "Cap z-index values.",
+    messageId: "exceeds",
+    message: Z_INDEX_MESSAGE,
+    matches: (declaration) => exceedsZIndexCap(declaration, view),
+    describe: (declaration) => declaration.text
+  });
+}
+
+// src/eslint-config/next/frontend/rules/focus-styling.ts
+var FOCUS_HANDLER_ATTRIBUTES = /* @__PURE__ */ new Set([
+  "onFocus",
+  "onBlur",
+  "onFocusCapture",
+  "onBlurCapture"
+]);
+var P1_DESCRIPTION = "focus-visible:outline-hidden focus-visible:ring-2 (plus an optional project ring color, ring-offset-<n> and project offset color)";
+function describeVerdict(verdict) {
+  const parts = [];
+  if (verdict.offending.length > 0) {
+    parts.push(`not P1: ${verdict.offending.join(" ")}`);
+  }
+  if (verdict.outOfRange.length > 0) {
+    parts.push(`missing or repeated: ${verdict.outOfRange.join(", ")}`);
+  }
+  return parts.join("; ");
+}
+function isStylingFocusHandler(handler) {
+  return FOCUS_HANDLER_ATTRIBUTES.has(handler.attributeName) && handler.styleAssignments.length > 0;
+}
+function listStyleKeys(model) {
+  return [...model.styleLeaves, ...model.motionKeys];
+}
+function resetsShadowVariable(key) {
+  const declaration = parseStyleLeaf(key);
+  return declaration !== void 0 && isShadowVariableReset(declaration);
+}
+function listWhileFocusLabels(element) {
+  const attribute = element && findJsxAttribute(element, "whileFocus");
+  const value = attribute && jsxAttributeValue(attribute);
+  return listBranches(value).flatMap(
+    (branch) => branch.type === "ArrayExpression" ? childNodes(branch, "elements").flatMap((item) => listStaticTexts(item)) : listStaticTexts(branch)
+  );
+}
+function isWhileFocusKey(key) {
+  if (!("attributeName" in key) || key.property === "transition") {
+    return false;
+  }
+  return key.attributeName === "whileFocus" || key.variantLabel !== void 0 && listWhileFocusLabels(key.element).includes(key.variantLabel);
+}
+function isIndicatorKey(key) {
+  return isFocusIndicatorProperty(key.property) || resetsShadowVariable(key) || isWhileFocusKey(key);
+}
+function evaluateClassGroups(model, view) {
+  return model.classGroups.map((group) => ({
+    node: group.node,
+    verdict: evaluateFocusGroup(group.tokens, view)
+  }));
+}
+function selectFocusScopedNodes(groups) {
+  return new Set(
+    groups.filter((group) => group.verdict.scoped.length > 0).map((group) => group.node)
+  );
+}
+function collectFocusStyledElements(model, scopedNodes) {
+  const elements = /* @__PURE__ */ new Set();
+  for (const group of model.classGroups) {
+    if (group.element && scopedNodes.has(group.node)) {
+      elements.add(group.element);
+    }
+  }
+  for (const key of listStyleKeys(model)) {
+    if (key.element && isIndicatorKey(key)) {
+      elements.add(key.element);
+    }
+  }
+  for (const handler of model.handlers) {
+    if (isStylingFocusHandler(handler)) {
+      elements.add(handler.element);
+    }
+  }
+  return elements;
+}
+function isScopedHandler(handler, focusStyled) {
+  const writesShadow = handler.styleAssignments.some(
+    (assignment) => isBoxShadowProperty(assignment.property)
+  );
+  return isStylingFocusHandler(handler) || focusStyled.has(handler.element) && writesShadow;
+}
+function selectScopedHandlers(model, focusStyled) {
+  const covered = /* @__PURE__ */ new Set();
+  return model.handlers.filter((handler) => {
+    if (!isScopedHandler(handler, focusStyled) || handler.styleAssignments.every((assignment) => covered.has(assignment))) {
+      return false;
+    }
+    for (const assignment of handler.styleAssignments) {
+      covered.add(assignment);
+    }
+    return true;
+  });
+}
+function reportClassGroups(report, groups) {
+  for (const { node, verdict } of groups) {
+    if (verdict.offending.length > 0 || verdict.outOfRange.length > 0) {
+      report({
+        node,
+        messageId: "classGroup",
+        data: { problems: describeVerdict(verdict) }
+      });
+    }
+  }
+}
+function reportStyleKeys(report, model, focusStyled) {
+  for (const key of listStyleKeys(model)) {
+    const isOnFocusStyledElement = key.element !== void 0 && focusStyled.has(key.element);
+    if (isIndicatorKey(key) || isBoxShadowProperty(key.property) && isOnFocusStyledElement) {
+      report({
+        node: key.node,
+        messageId: isWhileFocusKey(key) ? "whileFocus" : "inlineStyle",
+        data: { property: key.property }
+      });
+    }
+  }
+}
+function reportHandlers(report, handlers) {
+  for (const handler of handlers) {
+    report({
+      node: handler.attribute,
+      messageId: "handler",
+      data: { attribute: handler.attributeName }
+    });
+  }
+}
+function reportAssignments(report, model, reportedHandlers) {
+  const covered = new Set(
+    reportedHandlers.flatMap((handler) => handler.styleAssignments)
+  );
+  for (const assignment of model.styleAssignments) {
+    if (isFocusIndicatorProperty(assignment.property) && !covered.has(assignment)) {
+      report({
+        node: assignment.node,
+        messageId: "assignment",
+        data: { property: assignment.property }
+      });
+    }
+  }
+}
+function createFocusStylingRule(view) {
+  return {
+    meta: {
+      type: "problem",
+      docs: { description: "Allow only the P1 focus pattern." },
+      messages: {
+        classGroup: `Focus styling in this class string must be exactly ${P1_DESCRIPTION}; {{problems}}.`,
+        inlineStyle: `Inline {{property}} changes the focus indicator; use ${P1_DESCRIPTION}.`,
+        whileFocus: `whileFocus styles the focused state with {{property}}; focus styling must be exactly ${P1_DESCRIPTION}.`,
+        handler: `This {{attribute}} handler styles the focus indicator imperatively; use ${P1_DESCRIPTION}.`,
+        assignment: `.style writes to {{property}} change the focus indicator; use ${P1_DESCRIPTION}.`
+      },
+      schema: []
+    },
+    create(context) {
+      return {
+        "Program:exit"() {
+          const report = createUniqueReporter(context);
+          const model = collectFrontendModel(context.sourceCode);
+          const groups = evaluateClassGroups(model, view);
+          const scopedNodes = selectFocusScopedNodes(groups);
+          const focusStyled = collectFocusStyledElements(model, scopedNodes);
+          const scopedHandlers = selectScopedHandlers(model, focusStyled);
+          reportClassGroups(report, groups);
+          reportStyleKeys(report, model, focusStyled);
+          reportHandlers(report, scopedHandlers);
+          reportAssignments(report, model, scopedHandlers);
+        }
+      };
+    }
+  };
+}
+
+// src/eslint-config/next/frontend/rules/form-control-has-label.ts
+var CONTROLS = /* @__PURE__ */ new Set(["input", "textarea", "select"]);
+var LABELABLE_ELEMENTS = /* @__PURE__ */ new Set([
+  "button",
+  "input",
+  "meter",
+  "output",
+  "progress",
+  "select",
+  "textarea"
+]);
+var EXEMPT_INPUT_TYPES = /* @__PURE__ */ new Set([
+  "hidden",
+  "submit",
+  "reset",
+  "button",
+  "image"
+]);
+var LABEL_ATTRIBUTES = ["aria-label", "aria-labelledby"];
+var SOURCE_KEYED_TYPES = /* @__PURE__ */ new Set([
+  "MemberExpression",
+  "ChainExpression",
+  "TemplateLiteral"
+]);
+function attributeText(opening, name) {
+  const attribute = findJsxAttribute(opening, name);
+  return attribute ? staticText(jsxAttributeValue(attribute)) : void 0;
+}
+function isStaticallyAbsent(value) {
+  return value === void 0 || value.type === "Literal" && value.value === null || value.type === "Identifier" && value.name === "undefined" || staticText(value) === "";
+}
+function hasAriaName(opening) {
+  return LABEL_ATTRIBUTES.some((name) => {
+    const attribute = findJsxAttribute(opening, name);
+    return attribute !== void 0 && !isStaticallyAbsent(jsxAttributeValue(attribute));
+  });
+}
+function isExemptControl(opening, name) {
+  const typeValue = attributeText(opening, "type");
+  const spread = childNodes(opening, "attributes").some(
+    (attribute) => attribute.type === "JSXSpreadAttribute"
+  );
+  return spread || name === "input" && typeValue !== void 0 && EXEMPT_INPUT_TYPES.has(typeValue);
+}
+function isLabelable(opening) {
+  const name = jsxElementName(opening) ?? "";
+  return LABELABLE_ELEMENTS.has(name) && !(name === "input" && attributeText(opening, "type") === "hidden");
+}
+function declarationKey(variable) {
+  const range = variable?.identifiers[0]?.range;
+  return range ? `variable:${String(range[0])}` : void 0;
+}
+function variableKey(identifier, sourceCode) {
+  const scope = sourceCode.getScope(toRuleNode(identifier));
+  return declarationKey(findVariable(scope, String(identifier.name)));
+}
+function isValueReference(reference) {
+  return !("isValueReference" in reference) || reference.isValueReference === true;
+}
+function listContainedReferences(scope, expression) {
+  const ownReferences = scope.references.filter(
+    (reference) => isValueReference(reference) && containsNode(expression, toAstNode(reference.identifier))
+  );
+  const nestedReferences = scope.childScopes.filter((child) => containsNode(expression, toAstNode(child.block))).flatMap((child) => listContainedReferences(child, expression));
+  return [...ownReferences, ...nestedReferences];
+}
+function referenceKey(reference) {
+  return declarationKey(reference.resolved) ?? `global:${reference.identifier.name}`;
+}
+function sourceKey(expression, sourceCode) {
+  const node = toRuleNode(expression);
+  const references = listContainedReferences(
+    sourceCode.getScope(node),
+    expression
+  );
+  const variables = references.map((reference) => referenceKey(reference));
+  return `source:${sourceCode.getText(node)}@${variables.join(",")}`;
+}
+function idKey(attribute, sourceCode) {
+  const value = attribute ? jsxAttributeValue(attribute) : void 0;
+  const text = staticText(value);
+  if (text !== void 0) {
+    return text === "" ? void 0 : `string:${text}`;
+  }
+  if (value?.type === "Identifier") {
+    return variableKey(value, sourceCode);
+  }
+  return value && SOURCE_KEYED_TYPES.has(value.type) ? sourceKey(value, sourceCode) : void 0;
+}
+function functionName(node) {
+  const parent = node.parent;
+  const ownName = childString(childNode(node, "id"), "name");
+  if (node.type === "FunctionDeclaration") {
+    return ownName;
+  }
+  if (parent?.type !== "VariableDeclarator" || parent.init !== node) {
+    return void 0;
+  }
+  return ownName ?? childString(childNode(parent, "id"), "name");
+}
+function enclosingComponent(node) {
+  let outermostFunction;
+  let current = node;
+  while (current.parent) {
+    if (FUNCTION_TYPES.has(current.type)) {
+      if (/^[A-Z]/.test(functionName(current) ?? "")) {
+        return current;
+      }
+      outermostFunction = current;
+    }
+    current = current.parent;
+  }
+  return outermostFunction ?? current;
+}
+function isLabelElement(node) {
+  const opening = childNode(node, "openingElement");
+  return node.type === "JSXElement" && opening !== void 0 && jsxElementName(opening) === "label";
+}
+function enclosingLabel(opening) {
+  let current = opening.parent?.parent;
+  while (current && !isLabelElement(current)) {
+    current = current.parent;
+  }
+  return current;
+}
+function areMutuallyExclusive(first, second) {
+  let current = first.parent;
+  while (current && !(current.type === "ConditionalExpression" && containsNode(current, second))) {
+    current = current.parent;
+  }
+  const consequent = childNode(current, "consequent");
+  const alternate = childNode(current, "alternate");
+  if (!consequent || !alternate) {
+    return false;
+  }
+  return containsNode(consequent, first) && containsNode(alternate, second) || containsNode(alternate, first) && containsNode(consequent, second);
+}
+function hasWrappingLabel(opening, controlKey, openings, sourceCode) {
+  const label = enclosingLabel(opening);
+  const labelOpening = childNode(label, "openingElement");
+  if (!label || !labelOpening) {
+    return false;
+  }
+  const htmlFor = findJsxAttribute(labelOpening, "htmlFor");
+  if (htmlFor !== void 0) {
+    return controlKey !== void 0 && idKey(htmlFor, sourceCode) === controlKey;
+  }
+  const firstLabelable = openings.find(
+    (candidate) => containsNode(label, candidate) && isLabelable(candidate) && !areMutuallyExclusive(candidate, opening)
+  );
+  return firstLabelable === opening;
+}
+function buildLabelTarget(opening, sourceCode) {
+  if (jsxElementName(opening) !== "label") {
+    return void 0;
+  }
+  const key = idKey(findJsxAttribute(opening, "htmlFor"), sourceCode);
+  return key === void 0 ? void 0 : { component: enclosingComponent(opening), key };
+}
+function needsLabel(opening) {
+  const name = jsxElementName(opening) ?? "";
+  return CONTROLS.has(name) && !isExemptControl(opening, name) && !hasAriaName(opening);
+}
+var formControlHasLabelRule = {
+  meta: {
+    type: "problem",
+    docs: { description: "Require a label on form controls." },
+    messages: {
+      unlabelled: "Give this <{{element}}> a <label>, a matching <label htmlFor>, or an aria-label or aria-labelledby; a placeholder is not a label."
+    },
+    schema: []
+  },
+  create(context) {
+    const sourceCode = context.sourceCode;
+    const controls = [];
+    const labels = [];
+    const openings = [];
+    return {
+      JSXOpeningElement(node) {
+        const opening = toAstNode(node);
+        openings.push(opening);
+        const label = buildLabelTarget(opening, sourceCode);
+        if (label) {
+          labels.push(label);
+        }
+        if (needsLabel(opening)) {
+          controls.push(opening);
+        }
+      },
+      "Program:exit"() {
+        for (const control of controls) {
+          const key = idKey(findJsxAttribute(control, "id"), sourceCode);
+          const component = enclosingComponent(control);
+          const sibling = key !== void 0 && labels.some(
+            (label) => label.key === key && label.component === component
+          );
+          if (!sibling && !hasWrappingLabel(control, key, openings, sourceCode)) {
+            context.report({
+              node: toRuleNode(control),
+              messageId: "unlabelled",
+              data: { element: jsxElementName(control) ?? "" }
+            });
+          }
+        }
+      }
+    };
+  }
+};
+
+// src/eslint-config/next/frontend/rules/no-embedded-style.ts
+var noEmbeddedStyleRule = {
+  meta: {
+    type: "problem",
+    docs: { description: "Disallow JSX <style> elements." },
+    messages: {
+      embedded: "Move this CSS into a project stylesheet, where the CSS rules check it."
+    },
+    schema: []
+  },
+  create(context) {
+    return {
+      JSXOpeningElement(node) {
+        if (jsxElementName(toAstNode(node)) === "style") {
+          context.report({ node, messageId: "embedded" });
+        }
+      }
+    };
+  }
+};
+
+// src/eslint-config/next/frontend/declaration-rule.ts
+function checkClassGroup2(report, group, view, options) {
+  for (const { token, declarations } of compileClassGroup(group, view)) {
+    if (declarations.some((declaration) => options.matches(declaration))) {
+      report({
+        node: group.node,
+        messageId: options.messageId,
+        data: { source: token }
+      });
+    }
+  }
+}
+function checkStyleLeaf2(report, leaf, options) {
+  const declaration = parseStyleLeaf(leaf);
+  if (declaration && options.matches(declaration)) {
+    report({
+      node: leaf.node,
+      messageId: options.messageId,
+      data: { source: declaration.text }
+    });
+  }
+}
+function createDeclarationRule(view, options) {
+  return {
+    meta: {
+      type: "problem",
+      docs: { description: options.description },
+      messages: { [options.messageId]: options.message },
+      schema: []
+    },
+    create(context) {
+      return {
+        "Program:exit"() {
+          const report = createUniqueReporter(context);
+          const model = collectFrontendModel(context.sourceCode);
+          for (const group of model.classGroups) {
+            checkClassGroup2(report, group, view, options);
+          }
+          for (const leaf of model.styleLeaves) {
+            checkStyleLeaf2(report, leaf, options);
+          }
+        }
+      };
+    }
+  };
+}
+
+// src/eslint-config/next/frontend/rules/viewport-units.ts
+function createViewportUnitsRule(view) {
+  return createDeclarationRule(view, {
+    description: "Disallow vh units.",
+    messageId: "vhUnit",
+    message: VH_UNIT_MESSAGE,
+    matches: usesVhUnit
+  });
+}
+
+// src/eslint-config/next/frontend/rules/z-index.ts
+function createZIndexRule(view) {
+  return createDeclarationRule(view, {
+    description: "Cap z-index values.",
+    messageId: "exceeds",
+    message: Z_INDEX_MESSAGE,
+    matches: (declaration) => exceedsZIndexCap(declaration, view)
+  });
+}
+
+// src/eslint-config/next/frontend/plugin.ts
+function createFrontendRules(view) {
+  return {
+    javascript: {
+      "form-control-has-label": formControlHasLabelRule,
+      "focus-styling": createFocusStylingRule(view),
+      "animated-properties": createAnimatedPropertiesRule(view),
+      "viewport-units": createViewportUnitsRule(view),
+      "z-index": createZIndexRule(view),
+      "color-tokens": createColorTokensRule(view),
+      "no-embedded-style": noEmbeddedStyleRule
+    },
+    css: {
+      "css-focus-styling": cssFocusStylingRule,
+      "css-animated-properties": createCssAnimatedPropertiesRule(view),
+      "css-viewport-units": cssViewportUnitsRule,
+      "css-z-index": createCssZIndexRule(view),
+      "css-color-tokens": createCssColorTokensRule(view),
+      "css-no-apply": cssNoApplyRule,
+      "css-parsed-fully": cssParsedFullyRule
+    }
+  };
+}
+function createFrontendPlugin(rules) {
+  return {
+    meta: { name: "@pragmatiks/lint/eslint-config/next" },
+    rules: { ...rules.javascript, ...rules.css }
+  };
+}
+
+// src/eslint-config/next/index.ts
+var ACCESSIBILITY_PLUGIN = "jsx-a11y";
+var LABEL_RULE = "jsx-a11y/control-has-associated-label";
+var TYPED_FILES = ["**/*.{ts,tsx,mts}"];
+var THREE_DOTS_PATTERN = String.raw`/[A-Za-z]\.\.\./`;
+var ELLIPSIS_MESSAGE = "Write the ellipsis glyph \u2026 instead of three dots.";
+var ZOOM_MESSAGE = "Never disable zoom in the viewport export.";
+var FORWARD_REF_MESSAGE = "Pass ref as a prop; React 19 does not need forwardRef.";
+var URL_ATTRIBUTE = String.raw`JSXAttribute[name.name=/^(href|src|action)$/]`;
+var ELLIPSIS_EXEMPT_LITERAL = [
+  `${URL_ATTRIBUTE} Literal`,
+  "ImportDeclaration > Literal",
+  "ExportNamedDeclaration > Literal",
+  "ExportAllDeclaration > Literal",
+  "ImportExpression > Literal"
+].join(", ");
+var PRESET_RECOVERY = "To fix it, pass [...nextVitals, ...nextTs] from eslint-config-next";
+var ICON_FAMILY = "@phosphor-icons/react";
+var ICON_PACKAGES = [
+  "lucide-react",
+  "react-icons",
+  "react-icons/*",
+  "@heroicons/*",
+  "@tabler/icons-react",
+  "@radix-ui/react-icons",
+  "react-feather",
+  "@fortawesome/*",
+  "@mui/icons-material",
+  "@mui/icons-material/*"
+];
+var RESTRICTED_SYNTAX = [
+  {
+    selector: `JSXText[value=${THREE_DOTS_PATTERN}]`,
+    message: ELLIPSIS_MESSAGE
+  },
+  {
+    selector: `Literal[value=${THREE_DOTS_PATTERN}]:not(${ELLIPSIS_EXEMPT_LITERAL})`,
+    message: ELLIPSIS_MESSAGE
+  },
+  {
+    selector: `TemplateElement[value.cooked=${THREE_DOTS_PATTERN}]:not(${URL_ATTRIBUTE} TemplateElement)`,
+    message: ELLIPSIS_MESSAGE
+  },
+  {
+    selector: `JSXAttribute[name.name="onPaste"] CallExpression[callee.property.name="preventDefault"]`,
+    message: "Never block pasting into inputs."
+  },
+  {
+    selector: `Property:matches([key.name="userScalable"], [key.value="userScalable"])[value.value=false]`,
+    message: ZOOM_MESSAGE
+  },
+  {
+    selector: `Property:matches([key.name="maximumScale"], [key.value="maximumScale"])[value.value=1]`,
+    message: ZOOM_MESSAGE
+  },
+  {
+    selector: `JSXOpeningElement[name.name="link"] JSXAttribute[name.name="href"] Literal[value=/fonts.(googleapis|gstatic).com/]`,
+    message: "Load fonts through next/font, not a <link> to Google Fonts."
+  },
+  {
+    selector: `JSXText[value=/lorem ipsum|John Doe/i]`,
+    message: "Replace placeholder content with real copy."
+  }
+];
+var RESTRICTED_IMPORTS = {
+  paths: [
+    {
+      name: "react",
+      importNames: ["forwardRef"],
+      message: FORWARD_REF_MESSAGE
+    }
+  ],
+  patterns: [
+    {
+      group: ICON_PACKAGES,
+      message: `Use ${ICON_FAMILY}, the project's one icon family.`
+    }
+  ]
+};
+var RESTRICTED_PROPERTIES = {
+  object: "React",
+  property: "forwardRef",
+  message: FORWARD_REF_MESSAGE
+};
+function isIgnoreOnly(config) {
+  return Object.keys(config).every(
+    (key) => key === "ignores" || key === "name"
+  );
+}
+function findAccessibilityConfig(nextConfigs) {
+  const matches = nextConfigs.filter(
+    (config) => config.plugins?.[ACCESSIBILITY_PLUGIN] !== void 0
+  );
+  const [only] = matches;
+  if (matches.length !== 1 || !only?.files) {
+    throw new Error(
+      `@pragmatiks/lint: pragmatiksNextConfig expects exactly one Next config object that registers ${ACCESSIBILITY_PLUGIN} with files; found ${String(matches.length)}. ${PRESET_RECOVERY}.`
+    );
+  }
+  return only;
+}
+function scopeNextConfigs(nextConfigs, files) {
+  return nextConfigs.map(
+    (config) => config.files || isIgnoreOnly(config) ? config : { ...config, files }
+  );
+}
+function buildLabelOptions(labelOptions) {
+  const [first, ...rest] = labelOptions;
+  const options = first ?? {};
+  return [
+    {
+      ...options,
+      ignoreElements: [...options.ignoreElements ?? [], "select"]
+    },
+    ...rest
+  ];
+}
+function buildAccessibilityRules(accessibilityConfig) {
+  const plugin = accessibilityConfig.plugins?.[ACCESSIBILITY_PLUGIN];
+  const recommended = plugin?.flatConfigs?.recommended?.rules;
+  const labelEntry = recommended?.[LABEL_RULE];
+  if (!recommended || !Array.isArray(labelEntry)) {
+    throw new Error(
+      `@pragmatiks/lint: ${ACCESSIBILITY_PLUGIN} has no flat recommended preset with ${LABEL_RULE} options. ${PRESET_RECOVERY}.`
+    );
+  }
+  const [, ...labelOptions] = labelEntry;
+  return {
+    ...recommended,
+    [LABEL_RULE]: ["error", ...buildLabelOptions(labelOptions)],
+    "jsx-a11y/no-autofocus": ["error", { ignoreNonDOM: true }]
+  };
+}
+function buildRuleEntries(ruleIds) {
+  return Object.fromEntries(
+    ruleIds.map((ruleId) => [`pragmatiks/${ruleId}`, "error"])
+  );
+}
+function buildFrontendConfig(accessibilityConfig, plugin, rules) {
+  return {
+    name: "pragmatiks/next/frontend",
+    files: accessibilityConfig.files,
+    plugins: { pragmatiks: plugin },
+    rules: {
+      ...buildAccessibilityRules(accessibilityConfig),
+      ...buildRuleEntries(Object.keys(rules.javascript)),
+      "no-restricted-syntax": ["error", ...RESTRICTED_SYNTAX],
+      "no-restricted-imports": ["error", RESTRICTED_IMPORTS],
+      "no-restricted-properties": ["error", RESTRICTED_PROPERTIES],
+      "no-alert": "error",
+      "unicorn/filename-case": ["error", FILENAME_CASE_OPTIONS],
+      "unicorn/no-useless-undefined": ["error", NO_USELESS_UNDEFINED_OPTIONS]
+    }
+  };
+}
+function buildTypedConfig(rootDirectory) {
+  return {
+    name: "pragmatiks/next/typed",
+    files: TYPED_FILES,
+    plugins: { "react-x": reactX },
+    languageOptions: {
+      parserOptions: { projectService: true, tsconfigRootDir: rootDirectory }
+    },
+    rules: { "react-x/no-leaked-conditional-rendering": "error" }
+  };
+}
+function buildCssConfig(plugin, rules) {
+  return {
+    name: "pragmatiks/next/css",
+    files: ["**/*.css"],
+    plugins: { css, pragmatiks: plugin },
+    language: "css/css",
+    languageOptions: { tolerant: true },
+    rules: buildRuleEntries(Object.keys(rules.css))
+  };
+}
+async function pragmatiksNextConfig(nextConfigs, options) {
+  const accessibilityConfig = findAccessibilityConfig(nextConfigs);
+  const view = await loadDesignSystem(options);
+  const rules = createFrontendRules(view);
+  const plugin = createFrontendPlugin(rules);
+  return [
+    ...scopeNextConfigs(nextConfigs, accessibilityConfig.files),
+    ...pragmatiksConfig(),
+    buildFrontendConfig(accessibilityConfig, plugin, rules),
+    buildTypedConfig(options.rootDir),
+    buildCssConfig(plugin, rules)
+  ];
+}
+
+export { pragmatiksNextConfig };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map