praxis-kit 0.1.0

package/dist/eslint/index.js

@@ -0,0 +1,1047 @@
+import { RuleCreator } from "@typescript-eslint/utils/eslint-utils";
+import "../_shared/diagnostics.js";
+//#region ../../lib/foundation/src/iterate.ts
+function find(iterable, callback) {
+	for (const value of iterable) {
+		const result = callback(value);
+		if (result != null) return result;
+	}
+	return null;
+}
+function some(iterable, predicate) {
+	for (const value of iterable) if (predicate(value)) return true;
+	return false;
+}
+function every(iterable, predicate) {
+	let index = 0;
+	for (const value of iterable) if (!predicate(value, index++)) return false;
+	return true;
+}
+function* filter(iterable, predicate) {
+	let index = 0;
+	for (const value of iterable) if (predicate(value, index++)) yield value;
+}
+function* map(iterable, callback) {
+	let index = 0;
+	for (const value of iterable) yield callback(value, index++);
+}
+function forEach(iterable, callback) {
+	let index = 0;
+	for (const value of iterable) callback(value, index++);
+}
+function reduce(iterable, initial, callback) {
+	let accumulator = initial;
+	let index = 0;
+	for (const value of iterable) accumulator = callback(accumulator, value, index++);
+	return accumulator;
+}
+/**
+* Transforms an iterable into a Record.
+*
+* The callback returns a `[key, value]` tuple for each element. Returning
+* `null` aborts the collection and causes `collect()` to return `null`.
+*/
+function collect(iterable, callback) {
+	const result = {};
+	let index = 0;
+	for (const value of iterable) {
+		const entry = callback(value, index++);
+		if (entry === null) return null;
+		result[entry[0]] = entry[1];
+	}
+	return result;
+}
+function findLast(value, callback) {
+	for (let index = value.length - 1; index >= 0; index--) {
+		const result = callback(value[index], index);
+		if (result != null) return result;
+	}
+	return null;
+}
+function* items(collection) {
+	for (let i = 0; i < collection.length; i++) {
+		const item = collection.item(i);
+		if (item !== null) yield item;
+	}
+}
+function nodeList(list) {
+	return { *[Symbol.iterator]() {
+		for (let i = 0; i < list.length; i++) {
+			const node = list.item(i);
+			if (node !== null) yield node;
+		}
+	} };
+}
+function mapEntries(m) {
+	return m.entries();
+}
+function set(s) {
+	return s.values();
+}
+function hasOwn(object, key) {
+	return Object.hasOwn(object, key);
+}
+function* entries(object) {
+	for (const key in object) {
+		if (!hasOwn(object, key)) continue;
+		yield [key, object[key]];
+	}
+}
+function* keys(object) {
+	for (const [key] of entries(object)) yield key;
+}
+function* values(object) {
+	for (const [, value] of entries(object)) yield value;
+}
+function mapValues(object, callback) {
+	const result = {};
+	for (const [key, value] of entries(object)) result[key] = callback(value, key);
+	return result;
+}
+function forEachEntry(object, callback) {
+	for (const [key, value] of entries(object)) callback(key, value);
+}
+function forEachKey(object, callback) {
+	for (const key of keys(object)) callback(key);
+}
+function forEachValue(object, callback) {
+	for (const value of values(object)) callback(value);
+}
+function forEachSet(s, callback) {
+	for (const value of s) callback(value);
+}
+const iterate = Object.freeze({
+	entries,
+	filter,
+	find,
+	findLast,
+	forEach,
+	forEachEntry,
+	forEachKey,
+	forEachSet,
+	forEachValue,
+	items,
+	keys,
+	map,
+	mapEntries,
+	mapValues,
+	nodeList,
+	reduce,
+	collect,
+	set,
+	some,
+	every,
+	values
+});
+//#endregion
+//#region ../../lib/foundation/src/type-guards.ts
+function isString(value) {
+	return typeof value === "string";
+}
+function isObject(value, excludeArrays = false) {
+	if (value === null || typeof value !== "object") return false;
+	return excludeArrays ? !Array.isArray(value) : true;
+}
+//#endregion
+//#region ../../plugins/eslint/src/utils/ast.ts
+/** Narrows any node-shaped value to one whose `value` property is a string — the common check
+*  behind both `asStringLiteral` and `getPropertyKey`'s `Literal` branch. */
+function hasStringValue(node) {
+	return isObject(node, true) && isString(node.value);
+}
+function asObjectExpression(node) {
+	return node?.type === "ObjectExpression" ? node : void 0;
+}
+function asArrayExpression(node) {
+	return node?.type === "ArrayExpression" ? node : void 0;
+}
+function asNumericLiteral(node) {
+	if (node?.type === "Literal") {
+		const { value } = node;
+		if (typeof value === "number") return value;
+	}
+	if (node?.type === "UnaryExpression") {
+		const { operator, argument } = node;
+		if ((operator === "-" || operator === "+") && argument.type === "Literal" && typeof argument.value === "number") return operator === "-" ? -argument.value : argument.value;
+	}
+}
+function asStringLiteral(node) {
+	if (node?.type === "Literal" && hasStringValue(node)) return node.value;
+}
+function getPropertyKey(prop) {
+	const { key } = prop;
+	if (prop.computed) return void 0;
+	if (key.type === "Identifier") return key.name;
+	if (key.type === "Literal" && hasStringValue(key)) return key.value;
+}
+function getObjectProperty(obj, key) {
+	return obj.properties.find((prop) => {
+		if (prop.type !== "Property" || prop.kind !== "init") return false;
+		return getPropertyKey(prop) === key;
+	});
+}
+function getFirstObjectArg(node) {
+	const [first] = node.arguments;
+	return first?.type === "ObjectExpression" ? first : void 0;
+}
+function isFactoryCall(node, calleeNames) {
+	const { callee } = node;
+	if (callee.type === "Identifier") return calleeNames.has(callee.name);
+	if (callee.type === "MemberExpression" && !callee.computed) {
+		const { property } = callee;
+		return property.type === "Identifier" && calleeNames.has(property.name);
+	}
+	return false;
+}
+function extractVariantValues(node) {
+	const valuesObj = asObjectExpression(node);
+	if (!valuesObj) return void 0;
+	const values = /* @__PURE__ */ new Set();
+	iterate.forEach(valuesObj.properties, (prop) => {
+		if (prop.type !== "Property") return;
+		const key = getPropertyKey(prop);
+		if (key) values.add(key);
+	});
+	return values;
+}
+function extractVariantMap(variantsNode) {
+	const variantsObj = asObjectExpression(variantsNode);
+	if (!variantsObj) return void 0;
+	const map = /* @__PURE__ */ new Map();
+	iterate.forEach(variantsObj.properties, (prop) => {
+		if (prop.type !== "Property") return;
+		const key = getPropertyKey(prop);
+		if (!key) return;
+		const values = extractVariantValues(prop.value);
+		if (!values) return;
+		map.set(key, values);
+	});
+	return map;
+}
+//#endregion
+//#region ../../plugins/eslint/src/diagnostics.ts
+/**
+* ESLint-compatible `{{ }}` template strings for meta.messages.
+* Rules source their message text from here rather than constructing it inline.
+*/
+const EslintDiagnosticTemplates = {
+	redundantRole: "role=\"{{ role }}\" is redundant on <{{ tag }}>: the element already carries this implicit ARIA role. Remove the attribute.",
+	invalidChild: "<{{ child }}> is not a valid direct child of <{{ parent }}>. Allowed: {{ allowed }}.",
+	deadCompoundKey: "\"{{ key }}\" is not a variant defined in styling.variants. This compound condition can never match.",
+	deadCompoundValue: "\"{{ value }}\" is not a valid value for variant \"{{ key }}\". Expected one of: {{ allowed }}. This compound condition can never match.",
+	deadCompoundNonLiteral: "Compound value for \"{{ key }}\" is not a string literal and cannot be statically validated.",
+	missingStrict: "enforcement.{{ field }} is defined but enforcement.diagnostics is not explicitly set. Pass a Diagnostics instance (e.g. warnDiagnostics, throwDiagnostics) so the enforcement behavior is clear at the call site.",
+	invalidDefaultKey: "\"{{ key }}\" is not a variant defined in styling.variants. This default will have no effect.",
+	invalidDefaultValue: "\"{{ value }}\" is not a valid value for variant \"{{ key }}\". Expected one of: {{ allowed }}. This default will have no effect.",
+	invalidDefaultNonLiteral: "Default value for \"{{ key }}\" is not a string literal and cannot be statically validated.",
+	negativeMin: "cardinality.min must be >= 0 (got {{ value }}).",
+	negativeMax: "cardinality.max must be >= 0 (got {{ value }}).",
+	maxLessThanMin: "cardinality.max ({{ max }}) must be >= cardinality.min ({{ min }}). This rule can never be satisfied.",
+	multipleFirst: "Multiple enforcement.children rules require position: \"first\". Only one child can occupy the first position.",
+	multipleLast: "Multiple enforcement.children rules require position: \"last\". Only one child can occupy the last position.",
+	minSumExceedsCapacity: "A rule with position: \"only\" requires min >= 1, but {{ count }} other rule(s) also require min >= 1. These constraints cannot be satisfied simultaneously."
+};
+const noDeadCompound = RuleCreator((name) => `https://praxis-kit.dev/eslint-rules/${name}`)({
+	name: "no-dead-compound",
+	meta: {
+		type: "problem",
+		docs: { description: "Disallow compound variant conditions that reference unknown variant keys or values — compounds that can never fire." },
+		messages: {
+			unknownVariantKey: EslintDiagnosticTemplates.deadCompoundKey,
+			unknownVariantValue: EslintDiagnosticTemplates.deadCompoundValue,
+			nonLiteralValue: EslintDiagnosticTemplates.deadCompoundNonLiteral
+		},
+		schema: [{
+			type: "object",
+			properties: {
+				calleeNames: {
+					type: "array",
+					items: { type: "string" }
+				},
+				reportNonLiteral: { type: "boolean" }
+			},
+			additionalProperties: false
+		}]
+	},
+	defaultOptions: [{}],
+	create(context) {
+		const calleeNames = new Set(context.options[0]?.calleeNames ?? ["createContractComponent"]);
+		const reportNonLiteral = context.options[0]?.reportNonLiteral ?? false;
+		return { CallExpression(node) {
+			if (!isFactoryCall(node, calleeNames)) return;
+			const arg = getFirstObjectArg(node);
+			if (!arg) return;
+			const stylingProp = getObjectProperty(arg, "styling");
+			if (!stylingProp) return;
+			const styling = asObjectExpression(stylingProp.value);
+			if (!styling) return;
+			const variantsProp = getObjectProperty(styling, "variants");
+			if (!variantsProp) return;
+			const variantMap = extractVariantMap(variantsProp.value);
+			if (!variantMap || variantMap.size === 0) return;
+			const compoundsProp = getObjectProperty(styling, "compounds");
+			if (!compoundsProp) return;
+			const compounds = asArrayExpression(compoundsProp.value);
+			if (!compounds) return;
+			iterate.forEach(compounds.elements, (element) => {
+				if (!element || element.type !== "ObjectExpression") return;
+				iterate.forEach(element.properties, (prop) => {
+					if (prop.type !== "Property") return;
+					const literalProp = prop;
+					const key = getPropertyKey(literalProp);
+					if (!key || key === "class" || key === "className") return;
+					if (!variantMap.has(key)) {
+						context.report({
+							node: prop,
+							messageId: "unknownVariantKey",
+							data: { key }
+						});
+						return;
+					}
+					const value = asStringLiteral(literalProp.value);
+					if (value === void 0) {
+						if (reportNonLiteral) context.report({
+							node: prop,
+							messageId: "nonLiteralValue",
+							data: { key }
+						});
+						return;
+					}
+					const allowed = variantMap.get(key);
+					if (!allowed.has(value)) context.report({
+						node: prop,
+						messageId: "unknownVariantValue",
+						data: {
+							key,
+							value,
+							allowed: iterate.reduce([...allowed], "", (acc, value, index) => index === 0 ? `"${value}"` : `${acc}, "${value}"`)
+						}
+					});
+				});
+			});
+		} };
+	}
+});
+const noEnforcementWithoutStrict = RuleCreator((name) => `https://praxis-kit.dev/eslint-rules/${name}`)({
+	name: "no-enforcement-without-strict",
+	meta: {
+		type: "problem",
+		docs: { description: "Require enforcement.strict when enforcement.children or enforcement.aria is defined." },
+		messages: { missingStrict: EslintDiagnosticTemplates.missingStrict },
+		schema: [{
+			type: "object",
+			properties: { calleeNames: {
+				type: "array",
+				items: { type: "string" }
+			} },
+			additionalProperties: false
+		}]
+	},
+	defaultOptions: [{}],
+	create(context) {
+		const calleeNames = new Set(context.options[0]?.calleeNames ?? ["createContractComponent"]);
+		return { CallExpression(node) {
+			if (!isFactoryCall(node, calleeNames)) return;
+			const arg = getFirstObjectArg(node);
+			if (!arg) return;
+			const enfProp = getObjectProperty(arg, "enforcement");
+			if (!enfProp) return;
+			const enf = asObjectExpression(enfProp.value);
+			if (!enf) return;
+			if (getObjectProperty(enf, "diagnostics") !== void 0) return;
+			const field = iterate.find(["children", "aria"], (field) => {
+				const fieldProp = getObjectProperty(enf, field);
+				if (!fieldProp) return null;
+				if (field === "children") {
+					const arr = asArrayExpression(fieldProp.value);
+					if (!arr || arr.elements.length === 0) return null;
+				}
+				return field;
+			});
+			if (field) context.report({
+				node,
+				messageId: "missingStrict",
+				data: { field }
+			});
+		} };
+	}
+});
+//#endregion
+//#region ../../plugins/eslint/src/rules/no-invalid-default.ts
+function formatAllowedValues(values) {
+	return Array.from(values, (value) => `"${value}"`).join(", ");
+}
+const noInvalidDefault = RuleCreator((name) => `https://praxis-kit.dev/eslint-rules/${name}`)({
+	name: "no-invalid-default",
+	meta: {
+		type: "problem",
+		docs: { description: "Disallow styling.defaults entries whose keys or values do not exist in styling.variants." },
+		messages: {
+			unknownDefaultKey: EslintDiagnosticTemplates.invalidDefaultKey,
+			unknownDefaultValue: EslintDiagnosticTemplates.invalidDefaultValue,
+			nonLiteralValue: EslintDiagnosticTemplates.invalidDefaultNonLiteral
+		},
+		schema: [{
+			type: "object",
+			properties: {
+				calleeNames: {
+					type: "array",
+					items: { type: "string" }
+				},
+				reportNonLiteral: { type: "boolean" }
+			},
+			additionalProperties: false
+		}]
+	},
+	defaultOptions: [{}],
+	create(context) {
+		const calleeNames = new Set(context.options[0]?.calleeNames ?? ["createContractComponent"]);
+		const reportNonLiteral = context.options[0]?.reportNonLiteral ?? false;
+		return { CallExpression(node) {
+			if (!isFactoryCall(node, calleeNames)) return;
+			const arg = getFirstObjectArg(node);
+			if (!arg) return;
+			const stylingProp = getObjectProperty(arg, "styling");
+			if (!stylingProp) return;
+			const styling = asObjectExpression(stylingProp.value);
+			if (!styling) return;
+			const variantsProp = getObjectProperty(styling, "variants");
+			if (!variantsProp) return;
+			const variantMap = extractVariantMap(variantsProp.value);
+			if (!variantMap || variantMap.size === 0) return;
+			const defaultsProp = getObjectProperty(styling, "defaults");
+			if (!defaultsProp) return;
+			const defaults = asObjectExpression(defaultsProp.value);
+			if (!defaults) return;
+			iterate.forEach(defaults.properties, (prop) => {
+				if (prop.type !== "Property") return;
+				const key = getPropertyKey(prop);
+				if (!key) return;
+				if (!variantMap.has(key)) {
+					context.report({
+						node: prop,
+						messageId: "unknownDefaultKey",
+						data: { key }
+					});
+					return;
+				}
+				const value = asStringLiteral(prop.value);
+				if (value === void 0) {
+					if (reportNonLiteral) context.report({
+						node: prop,
+						messageId: "nonLiteralValue",
+						data: { key }
+					});
+					return;
+				}
+				const allowed = variantMap.get(key);
+				if (!allowed.has(value)) context.report({
+					node: prop,
+					messageId: "unknownDefaultValue",
+					data: {
+						key,
+						value,
+						allowed: formatAllowedValues(allowed)
+					}
+				});
+			});
+		} };
+	}
+});
+//#endregion
+//#region ../../plugins/eslint/src/utils/content-model-builders.ts
+function categories(...values) {
+	return new Set(values);
+}
+function tags(...values) {
+	return new Set(values);
+}
+function category(...allowed) {
+	return { model: {
+		kind: "category",
+		allowed: categories(...allowed)
+	} };
+}
+function specific(...allowed) {
+	return { model: {
+		kind: "specific",
+		allowed: tags(...allowed)
+	} };
+}
+function phrasing() {
+	return category("phrasing");
+}
+function phrasingOrHeading() {
+	return category("phrasing", "heading");
+}
+/** Builds a `{ tag: categorySet }` slice for `TAG_CATEGORIES`, one category set shared across
+*  every tag in `tagNames` — the common case where a whole group of tags shares identical
+*  category membership (e.g. every plain flow+phrasing inline element). Spread the result into
+*  `TAG_CATEGORIES`'s object literal rather than mutating an already-built map — each tag's
+*  entry is then created exactly once, with no runtime mutation after construction. */
+function categoriesFor(categoryList, tagNames) {
+	return Object.fromEntries(tagNames.map((tagName) => [tagName, categories(...categoryList)]));
+}
+/**
+* Identity function over a content-model table literal — exists purely so a `HTML_CONTENT_MODELS`
+* table can be authored as a plain object literal (readable, one entry per line) while still
+* getting `const`-context literal inference for each entry's `kind` discriminant, the same
+* benefit an explicit `ContentModelMap` annotation would otherwise cost by widening every
+* property to the annotation's type up front. TypeScript's `const` type parameter modifier
+* (5.0+) does the actual work; this function just gives it a name at the call site.
+*/
+function defineContentModels(definitions) {
+	return definitions;
+}
+//#endregion
+//#region ../../plugins/eslint/src/utils/html-nesting.ts
+const FLOW_PHRASING_TAGS = [
+	"abbr",
+	"b",
+	"bdi",
+	"bdo",
+	"br",
+	"cite",
+	"code",
+	"data",
+	"dfn",
+	"em",
+	"i",
+	"kbd",
+	"mark",
+	"output",
+	"q",
+	"ruby",
+	"s",
+	"samp",
+	"small",
+	"span",
+	"strong",
+	"sub",
+	"sup",
+	"time",
+	"u",
+	"var",
+	"wbr"
+];
+const FLOW_PHRASING_EMBEDDED_TAGS = [
+	"audio",
+	"canvas",
+	"img",
+	"math",
+	"object",
+	"picture",
+	"svg",
+	"video"
+];
+const FLOW_PHRASING_INTERACTIVE_TAGS = [
+	"button",
+	"input",
+	"label",
+	"select",
+	"textarea"
+];
+const FLOW_PHRASING_EMBEDDED_INTERACTIVE_TAGS = ["embed", "iframe"];
+const FLOW_PHRASING_METADATA_TAGS = [
+	"meta",
+	"noscript",
+	"script",
+	"template",
+	"link"
+];
+const FLOW_ONLY_TAGS = [
+	"address",
+	"blockquote",
+	"dialog",
+	"div",
+	"dl",
+	"fieldset",
+	"figure",
+	"footer",
+	"form",
+	"header",
+	"hr",
+	"li",
+	"main",
+	"menu",
+	"ol",
+	"p",
+	"pre",
+	"summary",
+	"table",
+	"ul"
+];
+const FLOW_SECTIONING_TAGS = [
+	"article",
+	"aside",
+	"nav",
+	"section"
+];
+const FLOW_INTERACTIVE_TAGS = ["details"];
+const FLOW_METADATA_TAGS = ["style"];
+const FLOW_HEADING_TAGS = [
+	"h1",
+	"h2",
+	"h3",
+	"h4",
+	"h5",
+	"h6",
+	"hgroup"
+];
+const METADATA_ONLY_TAGS = ["base", "title"];
+const TAG_CATEGORIES = {
+	...categoriesFor(["flow", "phrasing"], FLOW_PHRASING_TAGS),
+	...categoriesFor([
+		"flow",
+		"phrasing",
+		"embedded"
+	], FLOW_PHRASING_EMBEDDED_TAGS),
+	...categoriesFor([
+		"flow",
+		"phrasing",
+		"interactive"
+	], FLOW_PHRASING_INTERACTIVE_TAGS),
+	...categoriesFor([
+		"flow",
+		"phrasing",
+		"embedded",
+		"interactive"
+	], FLOW_PHRASING_EMBEDDED_INTERACTIVE_TAGS),
+	...categoriesFor([
+		"metadata",
+		"flow",
+		"phrasing"
+	], FLOW_PHRASING_METADATA_TAGS),
+	...categoriesFor(["flow"], FLOW_ONLY_TAGS),
+	...categoriesFor(["flow", "sectioning"], FLOW_SECTIONING_TAGS),
+	...categoriesFor(["flow", "interactive"], FLOW_INTERACTIVE_TAGS),
+	...categoriesFor(["flow", "metadata"], FLOW_METADATA_TAGS),
+	...categoriesFor(["flow", "heading"], FLOW_HEADING_TAGS),
+	...categoriesFor(["metadata"], METADATA_ONLY_TAGS)
+};
+const HTML_CONTENT_MODELS = defineContentModels({
+	colgroup: specific("col", "template"),
+	dl: specific("dt", "dd", "div", "script", "template"),
+	menu: specific("li", "script", "template"),
+	ol: specific("li", "script", "template"),
+	optgroup: specific("option", "script", "template"),
+	picture: specific("source", "img", "script", "template"),
+	select: specific("option", "optgroup", "hr", "script", "template"),
+	table: specific("caption", "colgroup", "thead", "tbody", "tfoot", "tr", "script", "template"),
+	tbody: specific("tr", "script", "template"),
+	tfoot: specific("tr", "script", "template"),
+	thead: specific("tr", "script", "template"),
+	tr: specific("td", "th", "script", "template"),
+	ul: specific("li", "script", "template"),
+	abbr: phrasing(),
+	b: phrasing(),
+	bdi: phrasing(),
+	bdo: phrasing(),
+	cite: phrasing(),
+	code: phrasing(),
+	data: phrasing(),
+	dfn: phrasing(),
+	dt: phrasing(),
+	em: phrasing(),
+	h1: phrasing(),
+	h2: phrasing(),
+	h3: phrasing(),
+	h4: phrasing(),
+	h5: phrasing(),
+	h6: phrasing(),
+	i: phrasing(),
+	kbd: phrasing(),
+	label: phrasing(),
+	mark: phrasing(),
+	output: phrasing(),
+	p: phrasing(),
+	q: phrasing(),
+	ruby: phrasing(),
+	s: phrasing(),
+	samp: phrasing(),
+	small: phrasing(),
+	span: phrasing(),
+	strong: phrasing(),
+	sub: phrasing(),
+	sup: phrasing(),
+	time: phrasing(),
+	u: phrasing(),
+	var: phrasing(),
+	legend: phrasingOrHeading(),
+	summary: phrasingOrHeading()
+});
+function getTagCategorySet(tagCategories, tagName) {
+	return tagCategories[tagName];
+}
+function getContentModelDefinition(contentModels, tagName) {
+	return contentModels[tagName];
+}
+//#endregion
+//#region ../../plugins/eslint/src/rules/no-invalid-html-nesting.ts
+const createRule$3 = RuleCreator((name) => `https://praxis-kit.dev/eslint-rules/${name}`);
+function describeAllowed(definition) {
+	const { model } = definition;
+	switch (model.kind) {
+		case "specific": return [...model.allowed].join(", ");
+		case "category": return [...model.allowed].map((c) => `${c} content`).join(", ");
+		case "transparent":
+		case "nothing":
+		case "structured": return "";
+	}
+}
+const ALLOWED_TEXT = Object.fromEntries(Object.entries(HTML_CONTENT_MODELS).filter((entry) => entry[1] !== void 0).map(([tag, definition]) => [tag, describeAllowed(definition)]));
+function getIntrinsicTag(name) {
+	if (name.type !== "JSXIdentifier") return void 0;
+	return /^[a-z]/.test(name.name) ? name.name : void 0;
+}
+/**
+* Evaluates a `ContentModelDefinition` against a candidate child tag.
+*
+* Only `specific` (explicit tag allowlist) and `category` (content-category membership) are
+* evaluated today — the same two kinds every entry in `HTML_CONTENT_MODELS` currently uses.
+* `transparent`/`nothing`/`structured` are real HTML content-model concepts (see their own doc
+* comments in `types/content-model.ts`) that this validator doesn't check yet: `transparent`
+* needs the parent's own rendering context, `nothing` needs a void-element check this rule
+* doesn't perform, and `structured` needs an order-aware grammar evaluator, not a flat
+* membership test. Each passes through (no violation reported) rather than being treated as
+* disallowing everything, so introducing one of these kinds to a future table entry doesn't
+* silently start flagging valid markup the validator can't actually reason about yet.
+*/
+function isAllowed(childTag, definition) {
+	const { model } = definition;
+	switch (model.kind) {
+		case "specific": return model.allowed.has(childTag);
+		case "category": {
+			const cats = getTagCategorySet(TAG_CATEGORIES, childTag);
+			if (!cats) return true;
+			return [...model.allowed].some((c) => cats.has(c));
+		}
+		case "transparent":
+		case "nothing":
+		case "structured": return true;
+	}
+}
+const noInvalidHtmlNesting = createRule$3({
+	name: "no-invalid-html-nesting",
+	meta: {
+		type: "problem",
+		docs: { description: "Disallow HTML children that violate the HTML5 content model for their parent element." },
+		messages: { invalidChild: EslintDiagnosticTemplates.invalidChild },
+		schema: []
+	},
+	defaultOptions: [],
+	create(context) {
+		return { JSXElement(node) {
+			const parentTag = getIntrinsicTag(node.openingElement.name);
+			if (!parentTag) return;
+			const definition = getContentModelDefinition(HTML_CONTENT_MODELS, parentTag);
+			if (!definition) return;
+			iterate.forEach(node.children, (child) => {
+				if (child.type !== "JSXElement") return;
+				const childTag = getIntrinsicTag(child.openingElement.name);
+				if (childTag === void 0) return;
+				if (isAllowed(childTag, definition)) return;
+				context.report({
+					node: child,
+					messageId: "invalidChild",
+					data: {
+						child: childTag,
+						parent: parentTag,
+						allowed: ALLOWED_TEXT[parentTag] ?? ""
+					}
+				});
+			});
+		} };
+	}
+});
+//#endregion
+//#region ../../plugins/eslint/src/utils/implicit-roles.ts
+const IMPLICIT_ROLES = {
+	article: "article",
+	aside: "complementary",
+	button: "button",
+	datalist: "listbox",
+	details: "group",
+	dialog: "dialog",
+	figure: "figure",
+	form: "form",
+	h1: "heading",
+	h2: "heading",
+	h3: "heading",
+	h4: "heading",
+	h5: "heading",
+	h6: "heading",
+	hr: "separator",
+	img: "img",
+	li: "listitem",
+	main: "main",
+	math: "math",
+	menu: "list",
+	meter: "meter",
+	nav: "navigation",
+	ol: "list",
+	option: "option",
+	output: "status",
+	progress: "progressbar",
+	search: "search",
+	section: "region",
+	select: "listbox",
+	summary: "button",
+	table: "table",
+	tbody: "rowgroup",
+	td: "cell",
+	textarea: "textbox",
+	tfoot: "rowgroup",
+	th: "columnheader",
+	thead: "rowgroup",
+	tr: "row",
+	ul: "list"
+};
+//#endregion
+//#region ../../plugins/eslint/src/rules/no-redundant-role.ts
+const createRule$2 = RuleCreator((name) => `https://praxis-kit.dev/eslint-rules/${name}`);
+function isRedundantRole(explicit, implicit) {
+	return explicit === implicit;
+}
+function getJsxTagName(node) {
+	const name = node.name;
+	if (name.type === "JSXIdentifier") return name.name;
+}
+function getJsxStringAttribute(node, attrName) {
+	return iterate.find(node.attributes, (attr) => {
+		if (attr.type !== "JSXAttribute") return null;
+		const { name: key } = attr;
+		if (key.type !== "JSXIdentifier" || key.name !== attrName) return null;
+		const { value: val } = attr;
+		if (val === null) return null;
+		if (val.type === "Literal" && isString(val.value)) return {
+			node: attr,
+			value: val.value
+		};
+		if (val.type === "JSXExpressionContainer" && val.expression.type === "Literal" && isString(val.expression.value)) return {
+			node: attr,
+			value: val.expression.value
+		};
+		return null;
+	}) ?? void 0;
+}
+const noRedundantRole = createRule$2({
+	name: "no-redundant-role",
+	meta: {
+		type: "suggestion",
+		docs: { description: "Disallow role attributes that duplicate the implicit ARIA role of the HTML element." },
+		fixable: "code",
+		messages: { redundantRole: EslintDiagnosticTemplates.redundantRole },
+		schema: []
+	},
+	defaultOptions: [],
+	create(context) {
+		return { JSXOpeningElement(node) {
+			const tag = getJsxTagName(node);
+			if (!tag) return;
+			const implicitRole = IMPLICIT_ROLES[tag];
+			if (!implicitRole) return;
+			const roleAttr = getJsxStringAttribute(node, "role");
+			if (!roleAttr) return;
+			if (isRedundantRole(roleAttr.value, implicitRole)) context.report({
+				node: roleAttr.node,
+				messageId: "redundantRole",
+				data: {
+					tag,
+					role: roleAttr.value
+				},
+				fix(fixer) {
+					return fixer.remove(roleAttr.node);
+				}
+			});
+		} };
+	}
+});
+const validCardinality = RuleCreator((name) => `https://praxis-kit.dev/eslint-rules/${name}`)({
+	name: "valid-cardinality",
+	meta: {
+		type: "problem",
+		docs: { description: "Enforce valid min/max values in enforcement.children cardinality rules." },
+		messages: {
+			negativeMin: EslintDiagnosticTemplates.negativeMin,
+			negativeMax: EslintDiagnosticTemplates.negativeMax,
+			maxLessThanMin: EslintDiagnosticTemplates.maxLessThanMin
+		},
+		schema: [{
+			type: "object",
+			properties: { calleeNames: {
+				type: "array",
+				items: { type: "string" }
+			} },
+			additionalProperties: false
+		}]
+	},
+	defaultOptions: [{}],
+	create(context) {
+		const calleeNames = new Set(context.options[0]?.calleeNames ?? ["createContractComponent"]);
+		function validateCardinality(cardProp) {
+			const card = asObjectExpression(cardProp.value);
+			if (!card) return;
+			const minProp = getObjectProperty(card, "min");
+			const maxProp = getObjectProperty(card, "max");
+			const min = minProp ? asNumericLiteral(minProp.value) : void 0;
+			const max = maxProp ? asNumericLiteral(maxProp.value) : void 0;
+			if (minProp && min !== void 0 && min < 0) context.report({
+				node: minProp,
+				messageId: "negativeMin",
+				data: { value: String(min) }
+			});
+			if (maxProp && max !== void 0 && max < 0) context.report({
+				node: maxProp,
+				messageId: "negativeMax",
+				data: { value: String(max) }
+			});
+			if (min !== void 0 && max !== void 0 && min >= 0 && max > 0 && max < min) context.report({
+				node: cardProp,
+				messageId: "maxLessThanMin",
+				data: {
+					min: String(min),
+					max: String(max)
+				}
+			});
+		}
+		return { CallExpression(node) {
+			if (!isFactoryCall(node, calleeNames)) return;
+			const arg = getFirstObjectArg(node);
+			if (!arg) return;
+			const enfProp = getObjectProperty(arg, "enforcement");
+			if (!enfProp) return;
+			const enf = asObjectExpression(enfProp.value);
+			if (!enf) return;
+			const childrenProp = getObjectProperty(enf, "children");
+			if (!childrenProp) return;
+			const arr = asArrayExpression(childrenProp.value);
+			if (!arr) return;
+			iterate.forEach(arr.elements, (element) => {
+				if (!element || element.type !== "ObjectExpression") return;
+				const cardProp = getObjectProperty(element, "cardinality");
+				if (!cardProp) return;
+				validateCardinality(cardProp);
+			});
+		} };
+	}
+});
+//#endregion
+//#region ../../plugins/eslint/src/rules/valid-children-config.ts
+const createRule = RuleCreator((name) => `https://praxis-kit.dev/eslint-rules/${name}`);
+function analyzeChildrenRules(elements) {
+	const firstPositionProps = [];
+	const lastPositionProps = [];
+	let onlyWithMinProp = null;
+	let requiredRuleCount = 0;
+	iterate.forEach(elements, (element) => {
+		if (!element || element.type !== "ObjectExpression") return;
+		const positionProp = getObjectProperty(element, "position");
+		const position = positionProp ? asStringLiteral(positionProp.value) : void 0;
+		const cardProp = getObjectProperty(element, "cardinality");
+		const card = cardProp ? asObjectExpression(cardProp.value) : void 0;
+		const minProp = card ? getObjectProperty(card, "min") : void 0;
+		const min = minProp ? asNumericLiteral(minProp.value) ?? 0 : 0;
+		if (position === "first" && positionProp) firstPositionProps.push(positionProp);
+		if (position === "last" && positionProp) lastPositionProps.push(positionProp);
+		if (min >= 1) {
+			requiredRuleCount++;
+			if (position === "only" && positionProp && !onlyWithMinProp) onlyWithMinProp = positionProp;
+		}
+	});
+	return {
+		firstPositionProps,
+		lastPositionProps,
+		onlyWithMinProp,
+		requiredRuleCount
+	};
+}
+const validChildrenConfig = createRule({
+	name: "valid-children-config",
+	meta: {
+		type: "problem",
+		docs: { description: "Enforce cross-rule consistency of enforcement.children — detect positional conflicts and cardinality impossibilities." },
+		messages: {
+			multipleFirst: EslintDiagnosticTemplates.multipleFirst,
+			multipleLast: EslintDiagnosticTemplates.multipleLast,
+			minSumExceedsCapacity: EslintDiagnosticTemplates.minSumExceedsCapacity
+		},
+		schema: [{
+			type: "object",
+			properties: { calleeNames: {
+				type: "array",
+				items: { type: "string" }
+			} },
+			additionalProperties: false
+		}]
+	},
+	defaultOptions: [{}],
+	create(context) {
+		const calleeNames = new Set(context.options[0]?.calleeNames ?? ["createContractComponent"]);
+		return { CallExpression(node) {
+			if (!isFactoryCall(node, calleeNames)) return;
+			const arg = getFirstObjectArg(node);
+			if (!arg) return;
+			const enfProp = getObjectProperty(arg, "enforcement");
+			if (!enfProp) return;
+			const enf = asObjectExpression(enfProp.value);
+			if (!enf) return;
+			const childrenProp = getObjectProperty(enf, "children");
+			if (!childrenProp) return;
+			const arr = asArrayExpression(childrenProp.value);
+			if (!arr) return;
+			const { firstPositionProps, lastPositionProps, onlyWithMinProp, requiredRuleCount } = analyzeChildrenRules(arr.elements);
+			iterate.forEach(firstPositionProps.slice(1), (prop) => {
+				context.report({
+					node: prop,
+					messageId: "multipleFirst"
+				});
+			});
+			iterate.forEach(lastPositionProps.slice(1), (prop) => {
+				context.report({
+					node: prop,
+					messageId: "multipleLast"
+				});
+			});
+			if (onlyWithMinProp && requiredRuleCount > 1) context.report({
+				node: onlyWithMinProp,
+				messageId: "minSumExceedsCapacity",
+				data: { count: String(requiredRuleCount - 1) }
+			});
+		} };
+	}
+});
+//#endregion
+//#region ../../plugins/eslint/src/index.ts
+const plugin = {
+	meta: {
+		name: "@praxis-kit/eslint-plugin",
+		version: "1.0.0"
+	},
+	rules: {
+		"no-dead-compound": noDeadCompound,
+		"no-enforcement-without-strict": noEnforcementWithoutStrict,
+		"no-invalid-default": noInvalidDefault,
+		"no-invalid-html-nesting": noInvalidHtmlNesting,
+		"no-redundant-role": noRedundantRole,
+		"valid-cardinality": validCardinality,
+		"valid-children-config": validChildrenConfig
+	},
+	configs: {}
+};
+const recommended = {
+	name: "@praxis-kit/recommended",
+	plugins: { "@praxis-kit": plugin },
+	rules: {
+		"@praxis-kit/no-dead-compound": "error",
+		"@praxis-kit/no-enforcement-without-strict": "error",
+		"@praxis-kit/no-invalid-default": "error",
+		"@praxis-kit/no-invalid-html-nesting": "error",
+		"@praxis-kit/no-redundant-role": "warn",
+		"@praxis-kit/valid-cardinality": "error",
+		"@praxis-kit/valid-children-config": "error"
+	}
+};
+plugin.configs["recommended"] = recommended;
+//#endregion
+export { plugin as default, plugin, noDeadCompound, noEnforcementWithoutStrict, noInvalidDefault, noInvalidHtmlNesting, noRedundantRole, recommended, validCardinality, validChildrenConfig };