@elmeragroup/internal 0.1.1-canary.1

package/dist/oxlint.mjs

@@ -0,0 +1,2029 @@
+
+import { defineRule, eslintCompatPlugin } from "@oxlint/plugins";
+//#region ../oxlint-plugin/filename-normalizer.js
+/**
+* @param {string} filename
+*/
+function normalizeFilename(filename) {
+	return filename.replaceAll("\\", "/");
+}
+//#endregion
+//#region ../oxlint-plugin/rules/enforce-variant-standard.js
+/**
+* Component entry: src/components/<name>/<name>.tsx
+* @param {string} filename
+*/
+function isComponentEntry(filename) {
+	return /(?:^|\/)src\/components\/([^/]+)\/\1\.tsx$/.test(normalizeFilename(filename));
+}
+/**
+* Colocated recipe module: src/components/<name>/<name>-variants.ts
+* @param {string} filename
+*/
+function isVariantsModule(filename) {
+	return /(?:^|\/)src\/components\/([^/]+)\/\1-variants\.ts$/.test(normalizeFilename(filename));
+}
+/**
+* @param {import("estree").Node | null | undefined} callee
+*/
+function isTvCall(callee) {
+	return callee?.type === "Identifier" && callee.name === "tv";
+}
+/**
+* @param {import("estree").ObjectExpression} obj
+* @param {string} name
+*/
+function getObjectProp(obj, name) {
+	for (const prop of obj.properties) {
+		if (prop.type !== "Property" || prop.computed) continue;
+		if ((prop.key.type === "Identifier" ? prop.key.name : prop.key.type === "Literal" ? String(prop.key.value) : null) === name) return prop.value;
+	}
+}
+/**
+* A recipe has axes when `variants` is present and not an empty object.
+* Identifiers and spreads count as axes; we cannot see through them.
+*
+* @param {import("estree").ObjectExpression} obj
+*/
+function recipeHasAxes(obj) {
+	const variants = getObjectProp(obj, "variants");
+	if (!variants) return false;
+	if (variants.type !== "ObjectExpression") return true;
+	return variants.properties.length > 0;
+}
+var enforce_variant_standard_default = defineRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Enforce tv recipe structure: named recipe, variants/defaultVariants on recipes with axes, VariantProps typing" },
+		messages: {
+			unnamedRecipe: "tv() recipes must be assigned to a named const (e.g. buttonVariants).",
+			inlineObject: "tv() must receive an inline object.",
+			missingDefaultVariants: "tv() recipe '{{name}}' must declare defaultVariants when it has a variants axis.",
+			missingVariantProps: "Component files that define a tv() recipe with axes must type props with VariantProps<typeof recipe>."
+		},
+		schema: []
+	},
+	defaultOptions: [],
+	createOnce(context) {
+		let shouldCheck = false;
+		let requireVariantProps = false;
+		/** @type {import("estree").CallExpression[]} */
+		const tvCalls = [];
+		return {
+			Program() {
+				const filename = context.filename;
+				shouldCheck = isComponentEntry(filename) || isVariantsModule(filename);
+				requireVariantProps = isComponentEntry(filename);
+				tvCalls.length = 0;
+			},
+			CallExpression(node) {
+				if (!shouldCheck || !isTvCall(node.callee)) return;
+				tvCalls.push(node);
+			},
+			"Program:exit"() {
+				if (!shouldCheck || tvCalls.length === 0) return;
+				for (const node of tvCalls) {
+					const parent = node.parent;
+					const named = parent?.type === "VariableDeclarator" && parent.id.type === "Identifier" ? parent.id.name : null;
+					if (!named) {
+						context.report({
+							node,
+							messageId: "unnamedRecipe"
+						});
+						continue;
+					}
+					const firstArg = node.arguments[0];
+					if (firstArg?.type !== "ObjectExpression") {
+						context.report({
+							node,
+							messageId: "inlineObject"
+						});
+						continue;
+					}
+					if (recipeHasAxes(firstArg) && !getObjectProp(firstArg, "defaultVariants")) context.report({
+						node,
+						messageId: "missingDefaultVariants",
+						data: { name: named }
+					});
+				}
+				const anyHasAxes = tvCalls.some((call) => {
+					const arg = call.arguments[0];
+					return arg?.type === "ObjectExpression" && recipeHasAxes(arg);
+				});
+				if (requireVariantProps && anyHasAxes && !context.sourceCode.getText().includes("VariantProps")) context.report({
+					loc: tvCalls[0]?.loc,
+					messageId: "missingVariantProps"
+				});
+			}
+		};
+	}
+});
+//#endregion
+//#region ../oxlint-plugin/rules/facade-reexport-grammar.js
+/**
+* Facades are `src/<name>.ts(x)` and `src/react-aria/<name>.ts(x)`.
+* The generated root barrel may use `export *` and is excluded.
+* @param {string} filename
+*/
+function isEntryFacadeFile(filename) {
+	const posix = normalizeFilename(filename);
+	if (posix.endsWith("/src/index.ts") || posix.endsWith("/src/index.tsx")) return false;
+	if (/\/src\/[a-z0-9-]+\.tsx?$/.test(posix)) return true;
+	return /\/src\/react-aria\/[a-z0-9-]+\.tsx?$/.test(posix);
+}
+var facade_reexport_grammar_default = defineRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Require src/<name>.ts and src/react-aria/<name>.ts facades to be explicit named re-exports only" },
+		messages: { grammar: "Entry facades must be explicit named re-exports only: no export *, no local declarations, no directives." },
+		schema: []
+	},
+	defaultOptions: [],
+	createOnce(context) {
+		return { Program(program) {
+			if (!isEntryFacadeFile(context.filename)) return;
+			for (const statement of program.body) {
+				if (statement.type === "ExportNamedDeclaration") {
+					if (statement.declaration != null || statement.source == null) context.report({
+						node: statement,
+						messageId: "grammar"
+					});
+					continue;
+				}
+				context.report({
+					node: statement,
+					messageId: "grammar"
+				});
+			}
+		} };
+	}
+});
+//#endregion
+//#region ../oxlint-plugin/rules/no-field-part-jsx.js
+const BANNED_PARTS = /* @__PURE__ */ new Set([
+	"Label",
+	"Description",
+	"Error",
+	"Root",
+	"Set",
+	"Legend"
+]);
+const LABELED_COMPOSITES = [
+	"/src/components/text-field/text-field.tsx",
+	"/src/components/number-field/number-field.tsx",
+	"/src/components/textarea-field/textarea-field.tsx",
+	"/src/components/phone-number-field/phone-number-field.tsx",
+	"/src/components/checkbox/checkbox.tsx",
+	"/src/components/radio-group/radio-group.tsx"
+];
+/**
+* @param {string} filename
+*/
+function isLabeledComposite(filename) {
+	const normalized = normalizeFilename(filename);
+	return LABELED_COMPOSITES.some((suffix) => normalized.endsWith(suffix));
+}
+/**
+* @param {import("estree").Node | null | undefined} nameNode
+* @returns {string | null}
+*/
+function fieldPartName(nameNode) {
+	if (nameNode?.type !== "JSXMemberExpression") return null;
+	const object = nameNode.object;
+	const property = nameNode.property;
+	if (object?.type !== "JSXIdentifier" || object.name !== "Field") return null;
+	if (property?.type !== "JSXIdentifier") return null;
+	return property.name;
+}
+var no_field_part_jsx_default = defineRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Forbid Field.Label/Description/Error/Root/Set/Legend JSX in labeled composites that must go through FieldFrame" },
+		messages: { fieldPart: "Labeled composites render <Field.{{part}}> through FieldFrame. Do not reopen that markup here." },
+		schema: []
+	},
+	defaultOptions: [],
+	createOnce(context) {
+		let skipFile = true;
+		return {
+			Program() {
+				skipFile = !isLabeledComposite(context.filename);
+			},
+			JSXOpeningElement(node) {
+				if (skipFile) return;
+				const part = fieldPartName(node.name);
+				if (part === null || !BANNED_PARTS.has(part)) return;
+				context.report({
+					node,
+					messageId: "fieldPart",
+					data: { part }
+				});
+			}
+		};
+	}
+});
+//#endregion
+//#region ../oxlint-plugin/extract-strings.js
+/**
+* Collect string literals from an ESTree node (class names, tv/cn args).
+* Lifted from kumo lint helpers (MIT, Copyright (c) 2026 Cloudflare, Inc.).
+*
+* @param {import("estree").Node | null | undefined} node
+* @returns {string[]}
+*/
+function extractStrings(node) {
+	if (!node) return [];
+	const out = [];
+	switch (node.type) {
+		case "Literal":
+			if (typeof node.value === "string") out.push(node.value);
+			break;
+		case "TemplateLiteral":
+			for (const q of node.quasis) if (typeof q.value.cooked === "string") out.push(q.value.cooked);
+			break;
+		case "BinaryExpression":
+			if (node.operator === "+") {
+				out.push(...extractStrings(node.left));
+				out.push(...extractStrings(node.right));
+			}
+			break;
+		case "ArrayExpression":
+			for (const el of node.elements) if (el) out.push(...extractStrings(el));
+			break;
+		case "ObjectExpression":
+			for (const prop of node.properties) if (prop.type === "Property") {
+				out.push(...extractStrings(prop.key));
+				out.push(...extractStrings(prop.value));
+			}
+			break;
+		case "CallExpression":
+			for (const arg of node.arguments) {
+				if (arg.type === "SpreadElement") continue;
+				out.push(...extractStrings(arg));
+			}
+			break;
+		case "ConditionalExpression":
+			out.push(...extractStrings(node.consequent));
+			out.push(...extractStrings(node.alternate));
+			out.push(...extractStrings(node.test));
+			break;
+		case "UnaryExpression":
+			out.push(...extractStrings(node.argument));
+			break;
+		case "LogicalExpression":
+			out.push(...extractStrings(node.left));
+			out.push(...extractStrings(node.right));
+			break;
+		case "JSXText":
+			out.push(node.value);
+			break;
+		case "JSXExpressionContainer": out.push(...extractStrings(node.expression));
+	}
+	return out;
+}
+/**
+* @param {import("estree").Node | null | undefined} callee
+* @param {string} name
+*/
+function isNamedCall(callee, name) {
+	return callee?.type === "Identifier" && callee.name === name;
+}
+//#endregion
+//#region ../oxlint-plugin/rules/no-hardcoded-density-metrics.js
+const CONTROL_VAR_RE = /--control-(?:h|px-icon|px|gap)-|--control-(?:text|leading)\b/;
+const KEYWORD_BOX = /* @__PURE__ */ new Set([
+	"auto",
+	"full",
+	"min",
+	"max",
+	"fit",
+	"screen",
+	"svh",
+	"lvh",
+	"dvh",
+	"svw",
+	"lvw",
+	"dvw",
+	"px",
+	"lh",
+	"none",
+	"svmin",
+	"lvmin",
+	"dvmin",
+	"svmax",
+	"lvmax",
+	"dvmax"
+]);
+const ICON_GLYPH_SIZES = /* @__PURE__ */ new Set(["3", "4"]);
+const TYPE_SCALE = /* @__PURE__ */ new Set([
+	"xs",
+	"sm",
+	"base",
+	"lg",
+	"xl",
+	"2xl",
+	"3xl",
+	"4xl",
+	"5xl",
+	"6xl",
+	"7xl",
+	"8xl",
+	"9xl"
+]);
+const MD_LG_KEYS = /* @__PURE__ */ new Set([
+	"md",
+	"lg",
+	"default"
+]);
+const BUTTON_SIZE_KEYS = /* @__PURE__ */ new Set([
+	"default",
+	"xs",
+	"sm",
+	"md",
+	"lg",
+	"icon",
+	"icon-xxs",
+	"icon-xs",
+	"icon-sm",
+	"icon-inline",
+	"icon-lg"
+]);
+/**
+* @param {import("estree").ObjectExpression} obj
+* @param {string} name
+* @returns {import("estree").Node | null}
+*/
+function objectPropValue(obj, name) {
+	for (const prop of obj.properties) {
+		if (prop.type !== "Property") continue;
+		if ((prop.key.type === "Identifier" ? prop.key.name : prop.key.type === "Literal" ? prop.key.value : null) === name) return prop.value;
+	}
+	return null;
+}
+/**
+* @param {import("estree").Property} prop
+* @returns {string | null}
+*/
+function propertyName(prop) {
+	if (prop.computed && prop.key.type !== "Literal") return null;
+	if (prop.key.type === "Identifier") return prop.key.name;
+	if (prop.key.type === "Literal" && typeof prop.key.value === "string") return prop.key.value;
+	return null;
+}
+/**
+* @param {string} str
+* @param {number} start
+*/
+function matchingBracket(str, start) {
+	if (str[start] !== "[") return -1;
+	let depth = 0;
+	for (let i = start; i < str.length; i++) {
+		const ch = str[i];
+		if (ch === "[") depth += 1;
+		else if (ch === "]") {
+			depth -= 1;
+			if (depth === 0) return i;
+		}
+	}
+	return -1;
+}
+/**
+* Strip Tailwind variant prefixes, including arbitrary and data variants.
+* @param {string} className
+*/
+function stripVariantPrefixes(className) {
+	let rest = className;
+	while (rest.length > 0) {
+		if (rest.startsWith("[")) {
+			const end = matchingBracket(rest, 0);
+			if (end !== -1 && rest[end + 1] === ":") {
+				rest = rest.slice(end + 2);
+				continue;
+			}
+			break;
+		}
+		if (rest.startsWith("*:") || rest.startsWith("**:")) {
+			rest = rest.slice(rest.indexOf(":") + 1);
+			continue;
+		}
+		const nameMatch = /^[a-zA-Z@][\w-]*(?:\/[\w-]+)?/.exec(rest);
+		if (!nameMatch) break;
+		let i = nameMatch[0].length;
+		if (rest[i] === "[") {
+			const end = matchingBracket(rest, i);
+			if (end === -1) break;
+			i = end + 1;
+		}
+		if (rest[i] === ":") {
+			rest = rest.slice(i + 1);
+			continue;
+		}
+		break;
+	}
+	return rest;
+}
+/**
+* @param {string} className
+*/
+function isDescendantTargeted(className) {
+	return /\[[^\]]*&/.test(className);
+}
+/**
+* @param {string} utility
+*/
+function stripImportant(utility) {
+	let next = utility;
+	if (next.startsWith("!")) next = next.slice(1);
+	if (next.endsWith("!")) next = next.slice(0, -1);
+	return next;
+}
+/**
+* @param {string} utility
+*/
+function readsDensityVariable(utility) {
+	return CONTROL_VAR_RE.test(utility);
+}
+/**
+* @param {string} sizeKey
+*/
+function isMdLgRung(sizeKey) {
+	return MD_LG_KEYS.has(sizeKey);
+}
+/**
+* @param {string} value
+*/
+function isKeywordBox(value) {
+	return KEYWORD_BOX.has(value);
+}
+/**
+* @param {string} utility
+* @param {string} prefix
+* @returns {string | null}
+*/
+function valueAfter(utility, prefix) {
+	if (!utility.startsWith(prefix)) return null;
+	return utility.slice(prefix.length);
+}
+/**
+* @param {string} utility
+* @returns {string | null}
+*/
+function boxFamily(utility) {
+	const height = valueAfter(utility, "h-");
+	if (height !== null) {
+		if (!height || isKeywordBox(height)) return null;
+		return "height";
+	}
+	const square = valueAfter(utility, "size-");
+	if (square !== null) {
+		if (!square || isKeywordBox(square) || ICON_GLYPH_SIZES.has(square)) return null;
+		return "height";
+	}
+	const gapX = valueAfter(utility, "gap-x-");
+	if (gapX !== null) return gapX && !isKeywordBox(gapX) ? "gap" : null;
+	if (valueAfter(utility, "gap-y-") !== null) return null;
+	const gap = valueAfter(utility, "gap-");
+	if (gap !== null) return gap && !isKeywordBox(gap) ? "gap" : null;
+	const px = valueAfter(utility, "px-");
+	if (px !== null) return px && !isKeywordBox(px) ? "inline padding" : null;
+	const pl = valueAfter(utility, "pl-");
+	if (pl !== null) return pl && !isKeywordBox(pl) ? "icon-edge padding" : null;
+	const pr = valueAfter(utility, "pr-");
+	if (pr !== null) return pr && !isKeywordBox(pr) ? "icon-edge padding" : null;
+	const ps = valueAfter(utility, "ps-");
+	if (ps !== null) return ps && !isKeywordBox(ps) ? "icon-edge padding" : null;
+	const pe = valueAfter(utility, "pe-");
+	if (pe !== null) return pe && !isKeywordBox(pe) ? "icon-edge padding" : null;
+	return null;
+}
+/**
+* @param {string} utility
+* @returns {string | null}
+*/
+function typeFamily(utility) {
+	if (utility.startsWith("[font-size:") || utility.startsWith("[line-height:")) return "type";
+	if (utility.startsWith("leading-")) return "type";
+	const text = valueAfter(utility, "text-");
+	if (text === null) return null;
+	const scale = text.split("/")[0];
+	if (scale && (TYPE_SCALE.has(scale) || scale.startsWith("[") || scale.startsWith("("))) return "type";
+	return null;
+}
+/**
+* @param {string} className
+*/
+function isControlBoxHeightClass(className) {
+	if (isDescendantTargeted(className)) return false;
+	const utility = stripImportant(stripVariantPrefixes(className));
+	if (!utility) return false;
+	if (utility.includes("--control-h-")) return true;
+	const height = valueAfter(utility, "h-");
+	if (height !== null) return Boolean(height) && !isKeywordBox(height);
+	const square = valueAfter(utility, "size-");
+	if (square === null) return false;
+	if (ICON_GLYPH_SIZES.has(square) || isKeywordBox(square)) return false;
+	return Boolean(square);
+}
+/**
+* @param {string} utility
+*/
+function isOpticalArbitrary(utility) {
+	return /^(?:h|w|size|min-h|min-w|px|pl|pr|ps|pe|gap(?:-[xy])?)-\[\d+(?:\.\d+)?px\]$/.test(utility);
+}
+/**
+* @param {string} className
+*/
+function isDataSizeToken(className) {
+	return /(?:^|:)data-\[size=/.test(className) && !className.includes("has-data-[size=");
+}
+/**
+* @param {string} className
+* @param {boolean} checkType
+* @returns {string | null}
+*/
+function densityOwnedFamily(className, checkType) {
+	if (isDescendantTargeted(className)) return null;
+	const utility = stripImportant(stripVariantPrefixes(className));
+	if (!utility) return null;
+	if (readsDensityVariable(utility)) return null;
+	if (/\(--[\w-]+\)/.test(utility) || /var\(--/.test(utility)) return null;
+	if (/^(?:h|w|size|min-h|min-w|px|pl|pr|ps|pe|gap(?:-[xy])?)-\[/.test(utility)) return null;
+	if (isOpticalArbitrary(utility)) return null;
+	const box = boxFamily(utility);
+	if (box) return box;
+	if (!checkType) return null;
+	return typeFamily(utility);
+}
+/**
+* @param {string} str
+* @returns {string[]}
+*/
+function classTokens$1(str) {
+	return str.split(/\s+/).filter(Boolean);
+}
+/**
+* Class tokens from a tv/cn/record arm, excluding `data-[size=…]` tokens
+* which are reported from the literal/template visitors instead.
+*
+* @param {import("estree").Node | null | undefined} node
+* @returns {string[]}
+*/
+function recipeTokens(node) {
+	return extractStrings(node).flatMap(classTokens$1).filter((token) => !isDataSizeToken(token));
+}
+/**
+* @param {import("estree").Node | null | undefined} node
+* @param {string} name
+*/
+function isInsideNamedCall(node, name) {
+	for (let current = node?.parent; current; current = current.parent) if (current.type === "CallExpression" && isNamedCall(current.callee, name)) return true;
+	return false;
+}
+/**
+* @param {string[]} tokens
+*/
+function tokensHaveControlHeightPin(tokens) {
+	return tokens.some((token) => token.includes("--control-h-"));
+}
+/**
+* @param {string[]} tokens
+*/
+function tokensHaveControlVar(tokens) {
+	return tokens.some((token) => CONTROL_VAR_RE.test(token));
+}
+/**
+* @param {string[]} tokens
+*/
+function checkTypeForTokens(tokens) {
+	return tokens.some((token) => /--control-h-(?:md|lg)\b/.test(token) || /--control-text\b/.test(token));
+}
+/**
+* @param {import("estree").ObjectExpression} obj
+* @returns {Array<{ key: string; value: import("estree").Node }> | null}
+*/
+function recordArms(obj) {
+	/** @type {Array<{ key: string; value: import("estree").Node }>} */
+	const arms = [];
+	for (const prop of obj.properties) {
+		if (prop.type !== "Property") return null;
+		const key = propertyName(prop);
+		if (key === null) return null;
+		arms.push({
+			key,
+			value: prop.value
+		});
+	}
+	return arms;
+}
+/**
+* @param {import("estree").ObjectExpression} obj
+*/
+function isButtonSizeKeyedRecord(obj) {
+	const arms = recordArms(obj);
+	if (arms === null || arms.length === 0) return false;
+	return arms.every((arm) => BUTTON_SIZE_KEYS.has(arm.key));
+}
+var no_hardcoded_density_metrics_default = defineRule({
+	meta: {
+		type: "suggestion",
+		docs: { description: "Warn when control-box recipes, data-[size] class strings, cn() strings, tv slots, or Button-size-keyed records hardcode density-owned metrics instead of reading --control-* variables" },
+		messages: { hardcodedMetric: "Hardcoded density-owned {{family}} `{{utility}}`. Read the matching `--control-*` variable instead." },
+		schema: []
+	},
+	defaultOptions: [],
+	createOnce(context) {
+		let fileHasControlH = false;
+		/**
+		* @param {import("estree").Node} node
+		* @param {string[]} tokens
+		* @param {boolean} checkType
+		*/
+		function reportTokens(node, tokens, checkType) {
+			for (const token of tokens) {
+				const family = densityOwnedFamily(token, checkType);
+				if (!family) continue;
+				context.report({
+					node,
+					messageId: "hardcodedMetric",
+					data: {
+						family,
+						utility: token
+					}
+				});
+			}
+		}
+		/**
+		* @param {import("estree").Node} node
+		* @param {string} value
+		*/
+		function reportDataSizeLiterals(node, value) {
+			reportTokens(node, classTokens$1(value).filter(isDataSizeToken), false);
+		}
+		/**
+		* @param {import("estree").CallExpression} node
+		*/
+		function reportCnLiterals(node) {
+			if (isInsideNamedCall(node, "tv")) return;
+			const tokens = recipeTokens(node);
+			if (!fileHasControlH && !tokensHaveControlHeightPin(tokens)) return;
+			reportTokens(node, tokens, checkTypeForTokens(tokens));
+		}
+		/**
+		* @param {import("estree").ObjectExpression} recipe
+		*/
+		function reportTvSlots(recipe) {
+			const slots = objectPropValue(recipe, "slots");
+			if (slots?.type !== "ObjectExpression") return;
+			for (const prop of slots.properties) {
+				if (prop.type !== "Property") continue;
+				const tokens = recipeTokens(prop.value);
+				if (!fileHasControlH && !tokensHaveControlHeightPin(tokens) && !tokensHaveControlVar(tokens)) continue;
+				reportTokens(prop.value, tokens, checkTypeForTokens(tokens));
+			}
+		}
+		/**
+		* @param {import("estree").ObjectExpression} node
+		*/
+		function reportSizeKeyedRecord(node) {
+			if (isInsideNamedCall(node, "tv")) return;
+			if (!isButtonSizeKeyedRecord(node)) return;
+			const arms = recordArms(node);
+			if (arms === null) return;
+			const groups = arms.map((arm) => ({
+				key: arm.key,
+				node: arm.value,
+				tokens: recipeTokens(arm.value)
+			}));
+			const allTokens = groups.flatMap((group) => group.tokens);
+			if (!fileHasControlH && !tokensHaveControlHeightPin(allTokens) && !allTokens.some(isControlBoxHeightClass)) return;
+			for (const group of groups) reportTokens(group.node, group.tokens, isMdLgRung(group.key));
+		}
+		return {
+			Program() {
+				fileHasControlH = context.sourceCode.getText().includes("--control-h-");
+			},
+			Literal(node) {
+				if (typeof node.value === "string") reportDataSizeLiterals(node, node.value);
+			},
+			TemplateLiteral(node) {
+				for (const quasi of node.quasis) if (typeof quasi.value.cooked === "string") reportDataSizeLiterals(quasi, quasi.value.cooked);
+			},
+			ObjectExpression(node) {
+				reportSizeKeyedRecord(node);
+			},
+			CallExpression(node) {
+				if (isNamedCall(node.callee, "cn")) {
+					reportCnLiterals(node);
+					return;
+				}
+				if (!isNamedCall(node.callee, "tv")) return;
+				if (node.arguments.length === 0) return;
+				const recipe = node.arguments[0];
+				if (recipe.type !== "ObjectExpression") return;
+				const variants = objectPropValue(recipe, "variants");
+				const size = variants?.type === "ObjectExpression" ? objectPropValue(variants, "size") : null;
+				if (size?.type === "ObjectExpression") for (const prop of size.properties) {
+					if (prop.type !== "Property") continue;
+					const sizeKey = propertyName(prop);
+					if (sizeKey === null) continue;
+					const tokens = recipeTokens(prop.value);
+					if (!tokens.some(isControlBoxHeightClass)) continue;
+					const checkType = isMdLgRung(sizeKey);
+					reportTokens(prop.value, tokens, checkType);
+				}
+				else {
+					/** @type {Array<{ node: import("estree").Node; tokens: string[] }>} */
+					const groups = [];
+					const base = objectPropValue(recipe, "base");
+					if (base) groups.push({
+						node: base,
+						tokens: recipeTokens(base)
+					});
+					const box = variants?.type === "ObjectExpression" ? objectPropValue(variants, "box") : null;
+					if (box?.type === "ObjectExpression") for (const arm of box.properties) {
+						if (arm.type !== "Property") continue;
+						groups.push({
+							node: arm.value,
+							tokens: recipeTokens(arm.value)
+						});
+					}
+					if (groups.some((group) => group.tokens.some(isControlBoxHeightClass))) for (const group of groups) reportTokens(group.node, group.tokens, false);
+				}
+				reportTvSlots(recipe);
+			}
+		};
+	}
+});
+//#endregion
+//#region ../oxlint-plugin/rules/no-internal-dynamic-import.js
+var no_internal_dynamic_import_default = defineRule({
+	createOnce(context) {
+		return { 
+		/** @param {import("estree").ImportExpression} node */
+ImportExpression(node) {
+			context.report({
+				loc: node.loc,
+				messageId: "noDynamicImport"
+			});
+		} };
+	},
+	meta: {
+		type: "problem",
+		docs: { description: "Disallow dynamic import() in library source; apps own code splitting" },
+		schema: [],
+		messages: { noDynamicImport: "The library never lazy-loads internally. Dynamic import() is forbidden in packages/ui/src." }
+	}
+});
+//#endregion
+//#region ../oxlint-plugin/rules/no-local-focus-ring.js
+const ALLOWED_UTILS_SUFFIX = "/src/styles/utils.ts";
+const FOCUS_RING_RE = /(?:^|[\s"'`[])(?:[\w-[\]]+:)*(?:focus(?:-visible|-within)?|has-focus|in-focus|data-\[focus(?:-visible)?\]):(?:[\w-[\]]+:)*ring(?:-|\b)/;
+const OUTLINE_SUPPRESSION_RE = /(?:^|[\s"'`])(?:[\w-[\]./*]+?:)*outline-(?:none|hidden)(?:\s|"|'|`|$)/;
+const FOCUS_WITHIN_BORDER_RE = /(?:^|[\s"'`])(?:[\w-[\]./*]+?:)*(?:group-|peer-)?focus-within(?:\/[\w-]+)?:(?:[\w-[\]./*]+?:)*border(?:-|\b)/;
+/**
+* @param {string} filename
+*/
+function isFocusRingUtils(filename) {
+	return normalizeFilename(filename).endsWith(ALLOWED_UTILS_SUFFIX);
+}
+/**
+* @param {import("estree").Node | null | undefined} node
+*/
+function isFocusVisibleIdentifier(node) {
+	return node?.type === "Identifier" && node.name === "isFocusVisible";
+}
+/**
+* @param {string} str
+*/
+function hasBareRingClass(str) {
+	return /(?:^|[\s"'`])(?:[\w-]+:)*ring(?:-\S+)?/.test(str);
+}
+var no_local_focus_ring_default = defineRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Forbid focus-state ring classes, outline-(none|hidden), and focus-within border colours outside packages/ui/src/styles/utils.ts" },
+		messages: { localFocusRing: "Focus-state rings must come from the package-private focusRing recipe in src/styles/utils.ts." },
+		schema: []
+	},
+	defaultOptions: [],
+	createOnce(context) {
+		/**
+		* @param {import("estree").Node} node
+		* @param {string[]} collected
+		*/
+		function reportFocusRingStrings(node, collected) {
+			for (const value of collected) if (FOCUS_RING_RE.test(value) || OUTLINE_SUPPRESSION_RE.test(value) || FOCUS_WITHIN_BORDER_RE.test(value)) {
+				context.report({
+					node,
+					messageId: "localFocusRing"
+				});
+				return;
+			}
+		}
+		/**
+		* @param {import("estree").Node} node
+		*/
+		function reportRacFocusVisibleRing(node) {
+			if (extractStrings(node).some(hasBareRingClass)) context.report({
+				node,
+				messageId: "localFocusRing"
+			});
+		}
+		let skipFile = false;
+		return {
+			Program() {
+				skipFile = isFocusRingUtils(context.filename);
+			},
+			Literal(node) {
+				if (skipFile) return;
+				if (typeof node.value === "string") reportFocusRingStrings(node, [node.value]);
+			},
+			TemplateLiteral(node) {
+				if (skipFile) return;
+				reportFocusRingStrings(node, extractStrings(node));
+			},
+			ConditionalExpression(node) {
+				if (skipFile) return;
+				if (isFocusVisibleIdentifier(node.test)) reportRacFocusVisibleRing(node);
+			},
+			LogicalExpression(node) {
+				if (skipFile) return;
+				if (isFocusVisibleIdentifier(node.left) || isFocusVisibleIdentifier(node.right)) reportRacFocusVisibleRing(node);
+			}
+		};
+	}
+});
+//#endregion
+//#region ../oxlint-plugin/rules/no-primitive-colors.js
+const RULE_NAME$1 = "no-primitive-colors";
+const LITERAL_RULE = "color-literal";
+const ROLE_TOKENS = /* @__PURE__ */ new Set([
+	"background",
+	"foreground",
+	"card",
+	"card-foreground",
+	"card-soft",
+	"card-soft-foreground",
+	"popover",
+	"popover-foreground",
+	"muted",
+	"muted-foreground",
+	"accent",
+	"accent-foreground",
+	"feature",
+	"feature-bright",
+	"feature-foreground",
+	"primary",
+	"primary-foreground",
+	"primary-soft",
+	"primary-soft-foreground",
+	"secondary",
+	"secondary-foreground",
+	"secondary-soft",
+	"secondary-soft-foreground",
+	"brand",
+	"brand-foreground",
+	"error",
+	"error-foreground",
+	"error-soft",
+	"error-soft-foreground",
+	"info",
+	"info-foreground",
+	"info-soft",
+	"info-soft-foreground",
+	"success",
+	"success-foreground",
+	"success-soft",
+	"success-soft-foreground",
+	"warning",
+	"warning-foreground",
+	"warning-soft",
+	"warning-soft-foreground",
+	"border",
+	"input",
+	"ring",
+	"sidebar",
+	"sidebar-foreground",
+	"sidebar-accent",
+	"sidebar-accent-foreground",
+	"sidebar-border",
+	"sidebar-ring",
+	"sidebar-brand",
+	"sidebar-brand-foreground",
+	"right-panel",
+	"right-panel-foreground",
+	"chart-1",
+	"chart-2",
+	"chart-3",
+	"chart-4",
+	"chart-5",
+	"chart-6",
+	"chart-7",
+	"chart-8",
+	"sh-identifier",
+	"sh-keyword",
+	"sh-string",
+	"sh-class",
+	"sh-property",
+	"sh-entity",
+	"sh-jsxliterals",
+	"sh-sign",
+	"sh-comment"
+]);
+const TAILWIND_COLOR_FAMILIES = /* @__PURE__ */ new Set([
+	"red",
+	"orange",
+	"amber",
+	"yellow",
+	"lime",
+	"green",
+	"emerald",
+	"teal",
+	"cyan",
+	"sky",
+	"blue",
+	"indigo",
+	"violet",
+	"purple",
+	"fuchsia",
+	"pink",
+	"slate",
+	"gray",
+	"zinc",
+	"neutral",
+	"stone",
+	"black",
+	"white"
+]);
+const NON_COLOR_UTILITIES = /* @__PURE__ */ new Set([
+	"xs",
+	"sm",
+	"base",
+	"lg",
+	"xl",
+	"2xl",
+	"3xl",
+	"4xl",
+	"left",
+	"center",
+	"right",
+	"justify",
+	"wrap",
+	"nowrap",
+	"balance",
+	"pretty",
+	"ellipsis",
+	"clip",
+	"transparent",
+	"current",
+	"inherit",
+	"none",
+	"auto",
+	"color",
+	"0",
+	"2",
+	"4",
+	"8",
+	"t",
+	"r",
+	"b",
+	"l",
+	"x",
+	"y",
+	"solid",
+	"dashed",
+	"dotted",
+	"double",
+	"hidden",
+	"collapse",
+	"separate",
+	"1",
+	"inset",
+	"inner"
+]);
+const NON_COLOR_PATTERNS = [
+	/^linear-to-[trbl]{1,2}$/,
+	/^[trblxy]-\d+$/,
+	/^offset-\d+$/,
+	/^\d+$/,
+	/^clip-.+$/
+];
+const TOKEN_RE = /(?:^|[^a-zA-Z0-9-])(((?:[a-z-]+:)*)?(?:bg|border|text|ring(?:-offset)?|fill|stroke|placeholder|caret|accent|decoration|divide|outline|from|via|to)-([a-z][a-z0-9-]*)(?:-\d{2,3})?(?:\/[0-9]{1,3})?)/gim;
+const ARBITRARY_COLOR_RE = /\[(?:#[0-9a-fA-F]{3,8}(?:\/[\d.]+)?|(?:oklch|oklab|lab|lch|rgb|rgba|hsl|hsla|hwb)\()/i;
+const ALLOWED_EXACT_CLASSES = [
+	"bg-black/10",
+	"outline-black/10",
+	"bg-[repeating-linear-gradient(45deg,transparent,transparent_8px,rgb(0_0_0/0.02)_8px,rgb(0_0_0/0.02)_16px)]"
+];
+/**
+* @param {string} tokenName
+*/
+function isNonColorUtility(tokenName) {
+	if (NON_COLOR_UTILITIES.has(tokenName)) return true;
+	return NON_COLOR_PATTERNS.some((pattern) => pattern.test(tokenName));
+}
+/**
+* @param {string} token
+*/
+function isAllowedExactClass(token) {
+	return ALLOWED_EXACT_CLASSES.includes(token);
+}
+/**
+* Whole class tokens only. Variant prefixes are part of the
+* token, so `hover:bg-black/10` is not the documented `bg-black/10` literal.
+*
+* @param {string} str
+*/
+function stripAllowedClasses(str) {
+	return str.split(/\s+/).filter((token) => token.length > 0 && !isAllowedExactClass(token)).join(" ");
+}
+/**
+* @param {string} str
+*/
+function findPrimitiveColor(str) {
+	TOKEN_RE.lastIndex = 0;
+	let match;
+	while (match = TOKEN_RE.exec(str)) {
+		const fullToken = match[1];
+		const colorFamily = match[3];
+		if (!fullToken || !colorFamily) continue;
+		const tokenName = colorFamily.replace(/\/\d+$/, "");
+		if (isNonColorUtility(tokenName)) continue;
+		if (ROLE_TOKENS.has(tokenName)) continue;
+		const primitiveFamily = tokenName.replace(/-\d+$/, "");
+		if (TAILWIND_COLOR_FAMILIES.has(primitiveFamily) || TAILWIND_COLOR_FAMILIES.has(tokenName)) return fullToken;
+	}
+	return null;
+}
+/**
+* @param {string} str
+*/
+function hasForbiddenColorLiteral(str) {
+	return ARBITRARY_COLOR_RE.test(str);
+}
+var no_primitive_colors_default = defineRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Disallow raw palette classes and color literals; use role tokens" },
+		messages: {
+			[RULE_NAME$1]: "Avoid raw palette classes (e.g. `bg-white`, `text-slate-500`). Style with role tokens only.",
+			[LITERAL_RULE]: "Avoid hex/oklch/rgb color literals in class strings. Style with role tokens only."
+		},
+		schema: []
+	},
+	defaultOptions: [],
+	createOnce(context) {
+		/**
+		* @param {import("estree").Node} node
+		* @param {string[]} collected
+		*/
+		function reportColorIssues(node, collected) {
+			for (const raw of collected) {
+				const value = stripAllowedClasses(raw);
+				if (findPrimitiveColor(value)) {
+					context.report({
+						node,
+						messageId: RULE_NAME$1
+					});
+					return;
+				}
+				if (hasForbiddenColorLiteral(value)) {
+					context.report({
+						node,
+						messageId: LITERAL_RULE
+					});
+					return;
+				}
+			}
+		}
+		return {
+			JSXAttribute(node) {
+				const name = node.name.type === "JSXIdentifier" ? node.name.name : void 0;
+				if (name !== "className" && name !== "class") return;
+				if (node.value) reportColorIssues(node, extractStrings(node.value));
+			},
+			CallExpression(node) {
+				if (!isNamedCall(node.callee, "tv") && !isNamedCall(node.callee, "cn")) return;
+				reportColorIssues(node, extractStrings(node));
+			},
+			Literal(node) {
+				if (typeof node.value === "string") reportColorIssues(node, [node.value]);
+			},
+			TemplateLiteral(node) {
+				reportColorIssues(node, extractStrings(node));
+			}
+		};
+	}
+});
+//#endregion
+//#region ../oxlint-plugin/forbidden-rac-packages.js
+/**
+* React Aria packages restricted to the quarantine directory, including
+* their `@react-aria/*` and `@react-stately/*` dependencies.
+*
+* Package-owned policy used by `elmera/no-rac-outside-quarantine`.
+*
+* @type {readonly string[]}
+*/
+const FORBIDDEN_RAC_PACKAGES = Object.freeze([
+	"react-aria-components",
+	"react-aria",
+	"@internationalized/date",
+	"@react-aria",
+	"@react-stately"
+]);
+/**
+* @param {string} specifier
+* @returns {boolean}
+*/
+function isForbiddenRacSpecifier(specifier) {
+	for (const name of FORBIDDEN_RAC_PACKAGES) if (specifier === name || specifier.startsWith(`${name}/`)) return true;
+	return false;
+}
+//#endregion
+//#region ../oxlint-plugin/rules/no-rac-outside-quarantine.js
+/**
+* @param {string} filename
+*/
+function isReactAriaQuarantine(filename) {
+	return normalizeFilename(filename).includes("/src/react-aria/");
+}
+/**
+* @param {import("estree").Node | null | undefined} source
+* @returns {string | null}
+*/
+function specifierFromSource(source) {
+	if (source?.type === "Literal" && typeof source.value === "string") return source.value;
+	return null;
+}
+var no_rac_outside_quarantine_default = defineRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Forbid react-aria-components, react-aria, @internationalized/date, and the scoped @react-aria/* / @react-stately/* packages outside src/react-aria/**" },
+		messages: { quarantined: "`{{specifier}}` may only be imported from packages/ui/src/react-aria/** (quarantine)." },
+		schema: []
+	},
+	defaultOptions: [],
+	createOnce(context) {
+		let skipFile = false;
+		/**
+		* @param {import("estree").Node} node
+		* @param {string | null} specifier
+		*/
+		function reportIfForbidden(node, specifier) {
+			if (skipFile || specifier === null || !isForbiddenRacSpecifier(specifier)) return;
+			context.report({
+				node,
+				messageId: "quarantined",
+				data: { specifier }
+			});
+		}
+		return {
+			Program() {
+				skipFile = isReactAriaQuarantine(context.filename);
+			},
+			ImportDeclaration(node) {
+				reportIfForbidden(node, specifierFromSource(node.source));
+			},
+			ExportNamedDeclaration(node) {
+				reportIfForbidden(node, specifierFromSource(node.source));
+			},
+			ExportAllDeclaration(node) {
+				reportIfForbidden(node, specifierFromSource(node.source));
+			},
+			ImportExpression(node) {
+				reportIfForbidden(node, specifierFromSource(node.source));
+			}
+		};
+	}
+});
+//#endregion
+//#region ../oxlint-plugin/rules/no-raw-class-map.js
+/**
+* Exact utilities that are legal class tokens without a hyphenated suffix.
+* `z-*` is omitted on purpose: `overlayLayer = "z-50"` is the one-owner keep.
+*/
+const EXACT_UTILITIES = /* @__PURE__ */ new Set([
+	"flex",
+	"grid",
+	"block",
+	"inline",
+	"inline-block",
+	"inline-flex",
+	"inline-grid",
+	"inline-table",
+	"contents",
+	"hidden",
+	"visible",
+	"invisible",
+	"collapse",
+	"isolate",
+	"relative",
+	"absolute",
+	"sticky",
+	"fixed",
+	"static",
+	"grow",
+	"shrink",
+	"truncate",
+	"underline",
+	"overline",
+	"line-through",
+	"no-underline",
+	"italic",
+	"not-italic",
+	"uppercase",
+	"lowercase",
+	"capitalize",
+	"normal-case",
+	"border",
+	"rounded",
+	"shadow",
+	"ring",
+	"outline",
+	"blur",
+	"group",
+	"peer",
+	"container",
+	"table",
+	"table-cell",
+	"table-row",
+	"table-column",
+	"list-item",
+	"flow-root",
+	"antialiased",
+	"subpixel-antialiased",
+	"sr-only",
+	"not-sr-only",
+	"tabular-nums",
+	"select-none",
+	"select-text",
+	"select-all",
+	"select-auto",
+	"pointer-events-none",
+	"pointer-events-auto",
+	"appearance-none",
+	"resize",
+	"resize-none",
+	"resize-x",
+	"resize-y",
+	"not-prose",
+	"prose"
+]);
+/**
+* Hyphenated (or bracket/paren) Tailwind prefixes. Single-letter prefixes keep the
+* hyphen so `p-` does not match `px-`/`previous`.
+*/
+const UTILITY_PREFIXES = [
+	"text-",
+	"bg-",
+	"border-",
+	"flex-",
+	"grid-",
+	"gap-",
+	"p-",
+	"px-",
+	"py-",
+	"pt-",
+	"pr-",
+	"pb-",
+	"pl-",
+	"ps-",
+	"pe-",
+	"m-",
+	"mx-",
+	"my-",
+	"mt-",
+	"mr-",
+	"mb-",
+	"ml-",
+	"ms-",
+	"me-",
+	"size-",
+	"h-",
+	"w-",
+	"min-h-",
+	"min-w-",
+	"max-h-",
+	"max-w-",
+	"rounded-",
+	"font-",
+	"items-",
+	"justify-",
+	"self-",
+	"content-",
+	"place-",
+	"shadow-",
+	"ring-",
+	"outline-",
+	"opacity-",
+	"scale-",
+	"blur-",
+	"rotate-",
+	"translate-",
+	"skew-",
+	"origin-",
+	"duration-",
+	"ease-",
+	"delay-",
+	"transition-",
+	"animate-",
+	"slide-",
+	"fade-",
+	"zoom-",
+	"spin-",
+	"cursor-",
+	"pointer-events-",
+	"select-",
+	"overflow-",
+	"overscroll-",
+	"whitespace-",
+	"break-",
+	"leading-",
+	"tracking-",
+	"indent-",
+	"align-",
+	"list-",
+	"decoration-",
+	"underline-offset-",
+	"line-clamp-",
+	"from-",
+	"via-",
+	"to-",
+	"divide-",
+	"space-",
+	"basis-",
+	"grow-",
+	"shrink-",
+	"col-",
+	"row-",
+	"order-",
+	"inset-",
+	"top-",
+	"right-",
+	"bottom-",
+	"left-",
+	"start-",
+	"end-",
+	"object-",
+	"aspect-",
+	"fill-",
+	"stroke-",
+	"accent-",
+	"caret-",
+	"scroll-",
+	"snap-",
+	"touch-",
+	"will-change-",
+	"backdrop-",
+	"drop-shadow-",
+	"brightness-",
+	"contrast-",
+	"saturate-",
+	"hue-rotate-",
+	"grayscale-",
+	"invert-",
+	"sepia-",
+	"mix-blend-",
+	"filter-",
+	"transform-",
+	"caption-",
+	"hyphens-",
+	"columns-",
+	"float-",
+	"clear-",
+	"box-",
+	"isolation-",
+	"hit-area-",
+	"auto-rows-",
+	"auto-cols-",
+	"@container"
+];
+/**
+* @param {string} filename
+*/
+function isTestFile$1(filename) {
+	return filename.endsWith(".test.ts") || filename.endsWith(".test.tsx") || filename.endsWith(".browser.test.tsx") || filename.endsWith(".test-d.tsx");
+}
+/**
+* @param {string} filename
+*/
+function isSkippedPath(filename) {
+	const normalized = normalizeFilename(filename);
+	if (isTestFile$1(normalized)) return true;
+	if (normalized.includes("/intl/")) return true;
+	if (normalized.includes("/generated/")) return true;
+	return false;
+}
+/**
+* @param {import("estree").Node | null | undefined} node
+*/
+function unwrap(node) {
+	let current = node;
+	while (current) {
+		if (current.type === "TSAsExpression" || current.type === "TSSatisfiesExpression" || current.type === "TSTypeAssertion" || current.type === "ParenthesizedExpression" || current.type === "ChainExpression") {
+			current = current.expression;
+			continue;
+		}
+		break;
+	}
+	return current;
+}
+/**
+* @param {string} str
+*/
+function classTokens(str) {
+	return str.split(/\s+/).filter(Boolean);
+}
+/**
+* Last `:` outside brackets, then strip important/negative modifiers.
+* @param {string} token
+*/
+function utilityOf(token) {
+	let depth = 0;
+	let lastColon = -1;
+	for (let i = 0; i < token.length; i += 1) {
+		const ch = token[i];
+		if (ch === "[") depth += 1;
+		else if (ch === "]") depth = Math.max(0, depth - 1);
+		else if (ch === ":" && depth === 0) lastColon = i;
+	}
+	let utility = lastColon === -1 ? token : token.slice(lastColon + 1);
+	if (utility.startsWith("!")) utility = utility.slice(1);
+	if (utility.endsWith("!")) utility = utility.slice(0, -1);
+	if (utility.startsWith("-") && utility.length > 1 && /[a-z@]/i.test(utility[1])) utility = utility.slice(1);
+	return utility;
+}
+/**
+* @param {string} token
+*/
+function isArbitraryProperty(token) {
+	return token.startsWith("[") && token.endsWith("]") && (token.startsWith("[--") || token.includes(":"));
+}
+/**
+* @param {string} token
+*/
+function isPrefixedOrArbitraryUtility(token) {
+	if (!token) return false;
+	if (isArbitraryProperty(token)) return true;
+	if (token.startsWith("group/") || token.startsWith("peer/")) return true;
+	return UTILITY_PREFIXES.some((prefix) => token.startsWith(prefix));
+}
+/**
+* @param {string} token
+*/
+function isTailwindUtility(token) {
+	if (!token) return false;
+	if (isPrefixedOrArbitraryUtility(token)) return true;
+	return EXACT_UTILITIES.has(token);
+}
+/**
+* @param {string} raw
+*/
+function isTailwindToken(raw) {
+	return isTailwindUtility(utilityOf(raw));
+}
+/**
+* A string looks like a class list when it has a hyphenated/arbitrary utility, or when
+* every token is a utility (`"flex isolate"`). Exact-only hits such as the English word
+* `block` in a comment are not enough.
+*
+* @param {string} str
+*/
+function looksLikeClassString(str) {
+	const tokens = classTokens(str);
+	if (tokens.length === 0) return false;
+	const hits = tokens.filter(isTailwindToken);
+	if (hits.length === 0) return false;
+	if (hits.some((token) => isPrefixedOrArbitraryUtility(utilityOf(token)))) return true;
+	return hits.length === tokens.length;
+}
+/**
+* @param {string} name
+*/
+function looksLikeClassIdentifier(name) {
+	return /(?:Class(?:es|Name)?|classNames)$/.test(name);
+}
+/**
+* @param {import("estree").Node | null | undefined} node
+* @param {string[]} out
+*/
+function collectValueStrings(node, out) {
+	const current = unwrap(node);
+	if (!current) return;
+	switch (current.type) {
+		case "Literal":
+			if (typeof current.value === "string") out.push(current.value);
+			break;
+		case "TemplateLiteral":
+			out.push(...extractStrings(current));
+			break;
+		case "ObjectExpression":
+			for (const prop of current.properties) if (prop.type === "Property") collectValueStrings(prop.value, out);
+			break;
+		case "ArrayExpression": for (const el of current.elements) if (el) collectValueStrings(el, out);
+	}
+}
+/**
+* @param {import("estree").ObjectExpression} node
+*/
+function objectLooksLikeClassMap(node) {
+	/** @type {string[]} */
+	const values = [];
+	collectValueStrings(node, values);
+	return values.some(looksLikeClassString);
+}
+/**
+* @param {import("estree").TemplateLiteral} node
+*/
+function templateLooksLikeClassString(node) {
+	if (looksLikeClassString(node.quasis.map((quasi) => quasi.value.cooked ?? "").join(" "))) return true;
+	if (node.expressions.length === 0) return false;
+	if (!node.expressions.every((expr) => expr.type === "Identifier")) return false;
+	return node.expressions.some((expr) => expr.type === "Identifier" && looksLikeClassIdentifier(expr.name));
+}
+var no_raw_class_map_default = defineRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Forbid raw Tailwind class maps and hand-spelled class constants. Maps with an axis or two-plus slots are tv() recipes; a single axis-less string is cn(). Any call-expression initializer is accepted. EXACT_UTILITIES and UTILITY_PREFIXES are the heuristic boundary for 'looks like Tailwind'. Skips tests, *.test-d.tsx, intl dictionaries, and generated files" },
+		messages: { rawClassMap: "Class maps with an axis or two or more slots are `tv()` recipes; a single axis-less class string is `cn(\"…\")`. Resolved string constants are legal when they are `cn(…)` or a recipe call, never spelled by hand." },
+		schema: []
+	},
+	defaultOptions: [],
+	createOnce(context) {
+		let skipFile = false;
+		/**
+		* @param {import("estree").Node} node
+		*/
+		function report(node) {
+			context.report({
+				node,
+				messageId: "rawClassMap"
+			});
+		}
+		return {
+			Program() {
+				skipFile = isSkippedPath(context.filename);
+			},
+			VariableDeclarator(node) {
+				if (skipFile || !node.init) return;
+				const init = unwrap(node.init);
+				if (!init) return;
+				if (init.type === "CallExpression") return;
+				if (init.type === "ObjectExpression") {
+					if (objectLooksLikeClassMap(init)) report(init);
+					return;
+				}
+				if (init.type === "Literal" && typeof init.value === "string") {
+					if (looksLikeClassString(init.value)) report(init);
+					return;
+				}
+				if (init.type === "TemplateLiteral" && templateLooksLikeClassString(init)) report(init);
+			}
+		};
+	}
+});
+//#endregion
+//#region ../oxlint-plugin/rules/no-tailwind-dark-variant.js
+const RULE_NAME = "no-tailwind-dark-variant";
+/**
+* @param {string} str
+*/
+function hasDarkVariant(str) {
+	return /\bdark:[a-z]+[-\w]*/.test(str);
+}
+/**
+* @param {import("estree").Node} node
+*/
+function isInsideJsxAttribute(node) {
+	let current = node.parent;
+	while (current) {
+		if (current.type === "JSXAttribute") return true;
+		current = current.parent;
+	}
+	return false;
+}
+var no_tailwind_dark_variant_default = defineRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Disallow Tailwind dark: variant usage in library source" },
+		messages: { [RULE_NAME]: "Avoid Tailwind's dark: variant. The dark axis is token-reserved behind [data-theme=\"dark\"]." },
+		schema: []
+	},
+	defaultOptions: [],
+	createOnce(context) {
+		/**
+		* @param {import("estree").Node} node
+		* @param {string[]} collected
+		*/
+		function reportIfDark(node, collected) {
+			for (const s of collected) if (hasDarkVariant(s)) {
+				context.report({
+					node,
+					messageId: RULE_NAME
+				});
+				return;
+			}
+		}
+		return {
+			JSXAttribute(node) {
+				const name = node.name.type === "JSXIdentifier" ? node.name.name : void 0;
+				if (name !== "className" && name !== "class") return;
+				if (node.value) reportIfDark(node, extractStrings(node.value));
+			},
+			Literal(node) {
+				if (typeof node.value !== "string" || !hasDarkVariant(node.value) || isInsideJsxAttribute(node)) return;
+				context.report({
+					node,
+					messageId: RULE_NAME
+				});
+			},
+			TemplateLiteral(node) {
+				if (isInsideJsxAttribute(node)) return;
+				if (extractStrings(node).some(hasDarkVariant)) context.report({
+					node,
+					messageId: RULE_NAME
+				});
+			}
+		};
+	}
+});
+//#endregion
+//#region ../oxlint-plugin/rules/require-icon-button-label.js
+const ICON_SIZE_PREFIX = "icon";
+const TEXT_CONTENT_NAMES = /* @__PURE__ */ new Set([
+	"Span",
+	"Text",
+	"ItemTitle",
+	"Title"
+]);
+/**
+* Statically known string from a JSX attribute value or child expression.
+* Identifiers and interpolated templates stay unknown.
+*
+* @param {import("estree").Node | null | undefined} node
+* @returns {string | null}
+*/
+function getStaticString(node) {
+	if (!node) return null;
+	if (node.type === "Literal") return typeof node.value === "string" ? node.value : null;
+	if (node.type === "TemplateLiteral") {
+		if (node.expressions.length !== 0) return null;
+		const cooked = node.quasis[0]?.value.cooked;
+		return typeof cooked === "string" ? cooked : null;
+	}
+	if (node.type === "JSXExpressionContainer") return getStaticString(node.expression);
+	return null;
+}
+/**
+* Known nonempty strings count. Known empty/whitespace, bare, null, and false do not.
+* Unresolved expressions stay permissive.
+*
+* @param {import("estree").JSXOpeningElement} node
+*/
+function hasUsableAriaLabel(node) {
+	return node.attributes.some((attr) => {
+		if (attr.type !== "JSXAttribute" || attr.name.name !== "aria-label") return false;
+		if (!attr.value) return false;
+		const staticString = getStaticString(attr.value);
+		if (staticString !== null) return staticString.trim().length > 0;
+		if ((attr.value.type === "JSXExpressionContainer" ? attr.value.expression : attr.value).type === "Literal") return false;
+		return true;
+	});
+}
+function hasSlot(node) {
+	return node.attributes.some((attr) => attr.type === "JSXAttribute" && attr.name.name === "slot");
+}
+/**
+* Size/variant may also use an identifier's name as a heuristic (size={icon}).
+* That heuristic is not a known runtime string.
+*
+* @param {import("estree").JSXAttribute} attr
+* @returns {string | null}
+*/
+function getSizeOrVariantValue(attr) {
+	const staticValue = getStaticString(attr.value);
+	if (staticValue !== null) return staticValue;
+	if (attr.value?.type === "JSXExpressionContainer" && attr.value.expression.type === "Identifier") return attr.value.expression.name;
+	return null;
+}
+function isIconVariant(node) {
+	return node.attributes.some((attr) => {
+		if (attr.type !== "JSXAttribute" || attr.name.name !== "variant") return false;
+		return getSizeOrVariantValue(attr) === "icon";
+	});
+}
+function isIconSize(node) {
+	return node.attributes.some((attr) => {
+		if (attr.type !== "JSXAttribute" || attr.name.name !== "size") return false;
+		const value = getSizeOrVariantValue(attr);
+		if (!value) return false;
+		return value.startsWith(ICON_SIZE_PREFIX);
+	});
+}
+function getElementName(nameNode) {
+	if (nameNode.type === "JSXIdentifier") return nameNode.name;
+	if (nameNode.type === "JSXMemberExpression") return nameNode.property.name;
+	return null;
+}
+function hasTextContent(node) {
+	if (!node.children || node.children.length === 0) return false;
+	return node.children.some((child) => {
+		if (child.type === "JSXText") return child.value.trim().length > 0;
+		if (child.type === "JSXExpressionContainer") {
+			const expr = child.expression;
+			if (expr.type === "CallExpression") return true;
+			const staticString = getStaticString(expr);
+			if (staticString !== null) return staticString.trim().length > 0;
+			if (expr.type === "TemplateLiteral") return true;
+		}
+		if (child.type === "JSXElement") {
+			const name = getElementName(child.openingElement.name);
+			if (name && TEXT_CONTENT_NAMES.has(name)) return true;
+			if (hasTextContent(child)) return true;
+		}
+		if (child.type === "JSXFragment") return hasTextContent(child);
+		return false;
+	});
+}
+var require_icon_button_label_default = defineRule({
+	createOnce(context) {
+		return { 
+		/** @param {import("estree").JSXOpeningElement} node */
+JSXOpeningElement(node) {
+			const name = getElementName(node.name);
+			if (name === null || !name.endsWith("Button")) return;
+			if (!isIconVariant(node) && !isIconSize(node)) return;
+			if (hasUsableAriaLabel(node)) return;
+			if (hasSlot(node)) return;
+			const parent = node.parent.type === "JSXElement" ? node.parent : null;
+			if (parent && hasTextContent(parent)) return;
+			context.report({
+				loc: node.loc,
+				messageId: "missingAriaLabel",
+				data: { component: name }
+			});
+		} };
+	},
+	meta: {
+		type: "problem",
+		docs: { description: "Require a nonempty aria-label on icon-only *Button JSX (any name ending in Button, including InputGroup.Button) whose size starts with icon or variant is icon; static expression strings and templates count" },
+		schema: [],
+		messages: { missingAriaLabel: "Icon-only <{{component}}> must have an aria-label for accessibility. Add aria-label={t(\"...\")} to provide a screen reader label." }
+	}
+});
+//#endregion
+//#region ../oxlint-plugin/rules/restrict-browser-helper-copy.js
+const HELPERS = /* @__PURE__ */ new Set([
+	"roleNamed",
+	"headingNamed",
+	"cssVarColor",
+	"textNamed",
+	"textboxNamed",
+	"stampDensity",
+	"px"
+]);
+const OWNER_SUFFIX$1 = "/test/themed-browser-render.tsx";
+/**
+* @param {string} filename
+*/
+function isOwner$1(filename) {
+	return normalizeFilename(filename).endsWith(OWNER_SUFFIX$1);
+}
+/**
+* @param {import("estree").Node | null | undefined} id
+* @returns {string | null}
+*/
+function helperName(id) {
+	if (id?.type !== "Identifier" || !HELPERS.has(id.name)) return null;
+	return id.name;
+}
+var restrict_browser_helper_copy_default = defineRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Forbid local declarations of the shared browser-harness helpers (roleNamed, headingNamed, cssVarColor, textNamed, textboxNamed, stampDensity, px) outside packages/ui/test/themed-browser-render.tsx" },
+		messages: { localCopy: "Import {{helper}} from packages/ui/test/themed-browser-render.tsx. Suites do not re-declare harness helpers." },
+		schema: []
+	},
+	defaultOptions: [],
+	createOnce(context) {
+		let skipFile = false;
+		return {
+			Program() {
+				skipFile = isOwner$1(context.filename);
+			},
+			FunctionDeclaration(node) {
+				if (skipFile) return;
+				const helper = helperName(node.id);
+				if (helper === null) return;
+				context.report({
+					node: node.id,
+					messageId: "localCopy",
+					data: { helper }
+				});
+			},
+			VariableDeclarator(node) {
+				if (skipFile) return;
+				const helper = helperName(node.id);
+				if (helper === null) return;
+				context.report({
+					node: node.id,
+					messageId: "localCopy",
+					data: { helper }
+				});
+			}
+		};
+	}
+});
+//#endregion
+//#region ../oxlint-plugin/rules/restrict-focus-ring-call.js
+const ALLOWED_SUFFIXES = ["/src/styles/utils.ts", "/src/react-aria/link/link.tsx"];
+/**
+* @param {string} filename
+*/
+function isTestFile(filename) {
+	return filename.endsWith(".test.ts") || filename.endsWith(".test.tsx") || filename.endsWith(".browser.test.tsx") || filename.endsWith(".test-d.tsx");
+}
+/**
+* @param {string} filename
+*/
+function isAllowedOwner(filename) {
+	const normalized = normalizeFilename(filename);
+	if (isTestFile(normalized)) return true;
+	return ALLOWED_SUFFIXES.some((suffix) => normalized.endsWith(suffix));
+}
+var restrict_focus_ring_call_default = defineRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Forbid focusRing({…}) calls outside styles/utils.ts except the live isFocusVisible call in react-aria/link" },
+		messages: { restrictedCall: "Fixed focus-ring rungs are the constants exported from styles/utils.ts. The only live `focusRing({…})` call is react-aria/link, which passes `isFocusVisible` per render." },
+		schema: []
+	},
+	defaultOptions: [],
+	createOnce(context) {
+		let skipFile = false;
+		return {
+			Program() {
+				skipFile = isAllowedOwner(context.filename);
+			},
+			CallExpression(node) {
+				if (skipFile || !isNamedCall(node.callee, "focusRing")) return;
+				context.report({
+					node,
+					messageId: "restrictedCall"
+				});
+			}
+		};
+	}
+});
+//#endregion
+//#region ../oxlint-plugin/rules/restrict-package-root-from-script.js
+const OWNER_SUFFIX = "/scripts/paths.ts";
+/**
+* @param {string} filename
+*/
+function isOwner(filename) {
+	return normalizeFilename(filename).endsWith(OWNER_SUFFIX);
+}
+/**
+* @param {import("estree").Node | null | undefined} node
+*/
+function isImportMetaUrl(node) {
+	return node?.type === "MemberExpression" && node.object?.type === "MetaProperty" && node.object.meta?.name === "import" && node.object.property?.name === "meta" && node.property?.type === "Identifier" && node.property.name === "url";
+}
+/**
+* @param {import("estree").Node | null | undefined} node
+*/
+function isFileUrlToPathOfImportMetaUrl(node) {
+	return node?.type === "CallExpression" && isNamedCall(node.callee, "fileURLToPath") && node.arguments.length > 0 && isImportMetaUrl(node.arguments[0]);
+}
+var restrict_package_root_from_script_default = defineRule({
+	meta: {
+		type: "problem",
+		docs: { description: "Forbid dirname(fileURLToPath(import.meta.url)) outside packages/ui/scripts/paths.ts" },
+		messages: { usePackageRootFromScript: "Locate the package root with packageRootFromScript(import.meta.url). dirname(fileURLToPath(import.meta.url)) lives only in scripts/paths.ts." },
+		schema: []
+	},
+	defaultOptions: [],
+	createOnce(context) {
+		let skipFile = false;
+		return {
+			Program() {
+				skipFile = isOwner(context.filename);
+			},
+			CallExpression(node) {
+				if (skipFile || !isNamedCall(node.callee, "dirname")) return;
+				if (!isFileUrlToPathOfImportMetaUrl(node.arguments[0])) return;
+				context.report({
+					node,
+					messageId: "usePackageRootFromScript"
+				});
+			}
+		};
+	}
+});
+//#endregion
+//#region ../oxlint-plugin/rules/restrict-process-env.js
+const MESSAGE = "Direct process.env access is forbidden except the process.env.NODE_ENV comparison in the theme validator module.";
+const ALLOWED_VALIDATOR_SUFFIX = "/src/theme/validate-theme.ts";
+/**
+* @param {import("estree").Node | null | undefined} node
+* @returns {node is import("estree").Identifier}
+*/
+function isProcessIdentifier(node) {
+	return node?.type === "Identifier" && node.name === "process";
+}
+/**
+* @param {import("estree").Node | null | undefined} node
+* @param {boolean} isComputed
+*/
+function isEnvProperty(node, isComputed) {
+	if (!isComputed) return node?.type === "Identifier" && node.name === "env";
+	return node?.type === "Literal" && node.value === "env";
+}
+/**
+* @param {import("estree").Node | null | undefined} node
+* @returns {node is import("estree").MemberExpression}
+*/
+function isProcessEnvMemberExpression(node) {
+	return node?.type === "MemberExpression" && isProcessIdentifier(node.object) && isEnvProperty(node.property, node.computed);
+}
+/**
+* @param {import("estree").Node | null | undefined} node
+* @param {boolean} isComputed
+*/
+function isNodeEnvProperty(node, isComputed) {
+	if (!isComputed) return node?.type === "Identifier" && node.name === "NODE_ENV";
+	return node?.type === "Literal" && node.value === "NODE_ENV";
+}
+/**
+* @param {import("estree").MemberExpression} processEnvNode
+*/
+function isProcessEnvNodeEnv(processEnvNode) {
+	const parent = processEnvNode.parent;
+	return parent?.type === "MemberExpression" && parent.object === processEnvNode && isNodeEnvProperty(parent.property, parent.computed);
+}
+/**
+* @param {string} operator
+*/
+function isComparisonOperator(operator) {
+	return operator === "===" || operator === "!==" || operator === "==" || operator === "!=";
+}
+/**
+* @param {import("estree").MemberExpression} processEnvNode
+*/
+function isNodeEnvComparison(processEnvNode) {
+	if (!isProcessEnvNodeEnv(processEnvNode)) return false;
+	const comparison = processEnvNode.parent.parent;
+	return comparison?.type === "BinaryExpression" && isComparisonOperator(comparison.operator);
+}
+/**
+* @param {string} filename
+*/
+function isThemeValidatorModule(filename) {
+	return normalizeFilename(filename).endsWith(ALLOWED_VALIDATOR_SUFFIX);
+}
+var restrict_process_env_default = defineRule({
+	createOnce(context) {
+		return { 
+		/** @param {import("estree").MemberExpression} node */
+MemberExpression(node) {
+			if (!isProcessEnvMemberExpression(node)) return;
+			if (isThemeValidatorModule(context.filename) && isNodeEnvComparison(node)) return;
+			context.report({
+				loc: node.loc,
+				messageId: "restrictedAccess"
+			});
+		} };
+	},
+	meta: {
+		type: "problem",
+		docs: { description: "Disallow direct process.env access except the process.env.NODE_ENV comparison in the theme validator" },
+		schema: [],
+		messages: { restrictedAccess: MESSAGE }
+	}
+});
+//#endregion
+//#region src/oxlint.ts
+const plugin = eslintCompatPlugin({
+	meta: { name: "elmera" },
+	rules: {
+		"enforce-variant-standard": enforce_variant_standard_default,
+		"facade-reexport-grammar": facade_reexport_grammar_default,
+		"no-field-part-jsx": no_field_part_jsx_default,
+		"no-hardcoded-density-metrics": no_hardcoded_density_metrics_default,
+		"no-internal-dynamic-import": no_internal_dynamic_import_default,
+		"no-local-focus-ring": no_local_focus_ring_default,
+		"no-primitive-colors": no_primitive_colors_default,
+		"no-rac-outside-quarantine": no_rac_outside_quarantine_default,
+		"no-raw-class-map": no_raw_class_map_default,
+		"no-tailwind-dark-variant": no_tailwind_dark_variant_default,
+		"require-icon-button-label": require_icon_button_label_default,
+		"restrict-browser-helper-copy": restrict_browser_helper_copy_default,
+		"restrict-focus-ring-call": restrict_focus_ring_call_default,
+		"restrict-package-root-from-script": restrict_package_root_from_script_default,
+		"restrict-process-env": restrict_process_env_default
+	}
+});
+//#endregion
+export { plugin as default };