praxis-kit 1.1.0

package/dist/eslint/index.js

@@ -0,0 +1,1068 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// ../../node_modules/.pnpm/@typescript-eslint+utils@8.60.0_eslint@10.4.1_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/eslint-utils/deepMerge.js
+var require_deepMerge = __commonJS({
+  "../../node_modules/.pnpm/@typescript-eslint+utils@8.60.0_eslint@10.4.1_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/eslint-utils/deepMerge.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.isObjectNotArray = isObjectNotArray;
+    exports.deepMerge = deepMerge;
+    function isObjectNotArray(obj) {
+      return typeof obj === "object" && obj != null && !Array.isArray(obj);
+    }
+    function deepMerge(first = {}, second = {}) {
+      const keys = /* @__PURE__ */ new Set([...Object.keys(first), ...Object.keys(second)]);
+      return Object.fromEntries([...keys].map((key) => {
+        const firstHasKey = key in first;
+        const secondHasKey = key in second;
+        const firstValue = first[key];
+        const secondValue = second[key];
+        let value;
+        if (firstHasKey && secondHasKey) {
+          if (isObjectNotArray(firstValue) && isObjectNotArray(secondValue)) {
+            value = deepMerge(firstValue, secondValue);
+          } else {
+            value = secondValue;
+          }
+        } else if (firstHasKey) {
+          value = firstValue;
+        } else {
+          value = secondValue;
+        }
+        return [key, value];
+      }));
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/@typescript-eslint+utils@8.60.0_eslint@10.4.1_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/eslint-utils/applyDefault.js
+var require_applyDefault = __commonJS({
+  "../../node_modules/.pnpm/@typescript-eslint+utils@8.60.0_eslint@10.4.1_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/eslint-utils/applyDefault.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.applyDefault = applyDefault;
+    var deepMerge_1 = require_deepMerge();
+    function applyDefault(defaultOptions, userOptions) {
+      const options = structuredClone(defaultOptions);
+      if (userOptions == null) {
+        return options;
+      }
+      options.forEach((opt, i) => {
+        if (userOptions[i] !== void 0) {
+          const userOpt = userOptions[i];
+          if ((0, deepMerge_1.isObjectNotArray)(userOpt) && (0, deepMerge_1.isObjectNotArray)(opt)) {
+            options[i] = (0, deepMerge_1.deepMerge)(opt, userOpt);
+          } else {
+            options[i] = userOpt;
+          }
+        }
+      });
+      return options;
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/@typescript-eslint+utils@8.60.0_eslint@10.4.1_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/eslint-utils/parserSeemsToBeTSESLint.js
+var require_parserSeemsToBeTSESLint = __commonJS({
+  "../../node_modules/.pnpm/@typescript-eslint+utils@8.60.0_eslint@10.4.1_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/eslint-utils/parserSeemsToBeTSESLint.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.parserSeemsToBeTSESLint = parserSeemsToBeTSESLint;
+    function parserSeemsToBeTSESLint(parser) {
+      return !!parser && /(?:typescript-eslint|\.\.)[\w/\\]*parser/.test(parser);
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/@typescript-eslint+utils@8.60.0_eslint@10.4.1_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/eslint-utils/getParserServices.js
+var require_getParserServices = __commonJS({
+  "../../node_modules/.pnpm/@typescript-eslint+utils@8.60.0_eslint@10.4.1_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/eslint-utils/getParserServices.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.getParserServices = getParserServices;
+    var parserSeemsToBeTSESLint_1 = require_parserSeemsToBeTSESLint();
+    var ERROR_MESSAGE_REQUIRES_PARSER_SERVICES = "You have used a rule which requires type information, but don't have parserOptions set to generate type information for this file. See https://tseslint.com/typed-linting for enabling linting with type information.";
+    var ERROR_MESSAGE_UNKNOWN_PARSER = 'Note: detected a parser other than @typescript-eslint/parser. Make sure the parser is configured to forward "parserOptions.project" to @typescript-eslint/parser.';
+    function getParserServices(context, allowWithoutFullTypeInformation = false) {
+      const parser = (
+        // eslint-disable-next-line @typescript-eslint/no-deprecated -- For compatibility with ESLint 8
+        context.parserPath || context.languageOptions.parser?.meta?.name
+      );
+      if (context.sourceCode.parserServices?.esTreeNodeToTSNodeMap == null || context.sourceCode.parserServices.tsNodeToESTreeNodeMap == null) {
+        throwError(parser);
+      }
+      if (context.sourceCode.parserServices.program == null && !allowWithoutFullTypeInformation) {
+        throwError(parser);
+      }
+      return context.sourceCode.parserServices;
+    }
+    function throwError(parser) {
+      const messages = [
+        ERROR_MESSAGE_REQUIRES_PARSER_SERVICES,
+        `Parser: ${parser || "(unknown)"}`,
+        !(0, parserSeemsToBeTSESLint_1.parserSeemsToBeTSESLint)(parser) && ERROR_MESSAGE_UNKNOWN_PARSER
+      ].filter(Boolean);
+      throw new Error(messages.join("\n"));
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/@typescript-eslint+utils@8.60.0_eslint@10.4.1_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/eslint-utils/InferTypesFromRule.js
+var require_InferTypesFromRule = __commonJS({
+  "../../node_modules/.pnpm/@typescript-eslint+utils@8.60.0_eslint@10.4.1_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/eslint-utils/InferTypesFromRule.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+  }
+});
+
+// ../../node_modules/.pnpm/@typescript-eslint+utils@8.60.0_eslint@10.4.1_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/eslint-utils/nullThrows.js
+var require_nullThrows = __commonJS({
+  "../../node_modules/.pnpm/@typescript-eslint+utils@8.60.0_eslint@10.4.1_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/eslint-utils/nullThrows.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.NullThrowsReasons = void 0;
+    exports.nullThrows = nullThrows;
+    exports.NullThrowsReasons = {
+      MissingParent: "Expected node to have a parent.",
+      MissingToken: (token, thing) => `Expected to find a ${token} for the ${thing}.`
+    };
+    function nullThrows(value, message) {
+      if (value == null) {
+        throw new Error(`Non-null Assertion Failed: ${message}`);
+      }
+      return value;
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/@typescript-eslint+utils@8.60.0_eslint@10.4.1_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/eslint-utils/RuleCreator.js
+var require_RuleCreator = __commonJS({
+  "../../node_modules/.pnpm/@typescript-eslint+utils@8.60.0_eslint@10.4.1_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/eslint-utils/RuleCreator.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.RuleCreator = RuleCreator8;
+    var applyDefault_1 = require_applyDefault();
+    function RuleCreator8(urlCreator) {
+      return function createNamedRule({ meta, name, ...rule }) {
+        const ruleWithDocs = createRule8({
+          meta: {
+            ...meta,
+            docs: {
+              ...meta.docs,
+              url: urlCreator(name)
+            }
+          },
+          name,
+          ...rule
+        });
+        return ruleWithDocs;
+      };
+    }
+    function createRule8({
+      create,
+      // Keep accepting deprecated defaultOptions for backward compatibility.
+      // eslint-disable-next-line @typescript-eslint/no-deprecated
+      defaultOptions,
+      meta,
+      name
+    }) {
+      const resolvedDefaultOptions = meta.defaultOptions ?? defaultOptions ?? [];
+      return {
+        create(context) {
+          const optionsWithDefault = (0, applyDefault_1.applyDefault)(resolvedDefaultOptions, context.options);
+          return create(context, optionsWithDefault);
+        },
+        defaultOptions,
+        meta,
+        name
+      };
+    }
+    RuleCreator8.withoutDocs = function withoutDocs(args) {
+      return createRule8(args);
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/@typescript-eslint+utils@8.60.0_eslint@10.4.1_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/eslint-utils/index.js
+var require_eslint_utils = __commonJS({
+  "../../node_modules/.pnpm/@typescript-eslint+utils@8.60.0_eslint@10.4.1_jiti@2.7.0__typescript@6.0.3/node_modules/@typescript-eslint/utils/dist/eslint-utils/index.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __exportStar = exports && exports.__exportStar || function(m, exports2) {
+      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p)) __createBinding(exports2, m, p);
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    __exportStar(require_applyDefault(), exports);
+    __exportStar(require_deepMerge(), exports);
+    __exportStar(require_getParserServices(), exports);
+    __exportStar(require_InferTypesFromRule(), exports);
+    __exportStar(require_nullThrows(), exports);
+    __exportStar(require_RuleCreator(), exports);
+  }
+});
+
+// ../eslint-plugin/src/rules/no-dead-compound.ts
+var import_eslint_utils = __toESM(require_eslint_utils(), 1);
+
+// ../eslint-plugin/src/utils/ast.ts
+function getObjectProperty(obj, key) {
+  return obj.properties.find((prop) => {
+    if (prop.type !== "Property" || prop.kind !== "init" || prop.computed) {
+      return false;
+    }
+    const { key: propKey } = prop;
+    return propKey.type === "Identifier" && propKey.name === key || propKey.type === "Literal" && propKey.value === key;
+  });
+}
+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;
+    }
+  }
+  return 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 getFirstObjectArg(node) {
+  const [first] = node.arguments;
+  return first?.type === "ObjectExpression" ? first : void 0;
+}
+function asStringLiteral(node) {
+  if (node?.type === "Literal" && typeof node.value === "string") return node.value;
+  return void 0;
+}
+function getPropertyKey(prop) {
+  const { key } = prop;
+  if (prop.computed) return void 0;
+  if (key.type === "Identifier") return key.name;
+  if (key.type === "Literal" && typeof key.value === "string") return key.value;
+  return void 0;
+}
+function extractVariantMap(variantsNode) {
+  const variantsObj = asObjectExpression(variantsNode);
+  if (!variantsObj) return void 0;
+  const map = /* @__PURE__ */ new Map();
+  for (const prop of variantsObj.properties) {
+    if (prop.type !== "Property") continue;
+    const key = getPropertyKey(prop);
+    if (!key) continue;
+    const valuesObj = asObjectExpression(prop.value);
+    if (!valuesObj) continue;
+    const values = /* @__PURE__ */ new Set();
+    for (const vProp of valuesObj.properties) {
+      if (vProp.type !== "Property") continue;
+      const vKey = getPropertyKey(vProp);
+      if (vKey !== void 0) values.add(vKey);
+    }
+    map.set(key, values);
+  }
+  return map;
+}
+
+// ../eslint-plugin/src/rules/no-dead-compound.ts
+var createRule = (0, import_eslint_utils.RuleCreator)((name) => `https://praxis-kit.dev/eslint-rules/${name}`);
+var noDeadCompound = createRule({
+  name: "no-dead-compound",
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow compound variant conditions that reference unknown variant keys or values \u2014 compounds that can never fire."
+    },
+    messages: {
+      unknownVariantKey: '"{{ key }}" is not a variant defined in styling.variants. This compound condition can never match.',
+      unknownVariantValue: '"{{ value }}" is not a valid value for variant "{{ key }}". Expected one of: {{ allowed }}. This compound condition can never match.',
+      nonLiteralValue: 'Compound value for "{{ key }}" is not a string literal and cannot be statically validated.'
+    },
+    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;
+        for (const element of compounds.elements) {
+          if (!element || element.type !== "ObjectExpression") continue;
+          for (const prop of element.properties) {
+            if (prop.type !== "Property") continue;
+            const key = getPropertyKey(prop);
+            if (!key || key === "class" || key === "className") continue;
+            if (!variantMap.has(key)) {
+              context.report({
+                node: prop,
+                messageId: "unknownVariantKey",
+                data: { key }
+              });
+              continue;
+            }
+            const value = asStringLiteral(prop.value);
+            if (value === void 0) {
+              if (reportNonLiteral) {
+                context.report({ node: prop, messageId: "nonLiteralValue", data: { key } });
+              }
+              continue;
+            }
+            const allowed = variantMap.get(key);
+            if (!allowed.has(value)) {
+              context.report({
+                node: prop,
+                messageId: "unknownVariantValue",
+                data: { key, value, allowed: [...allowed].map((v) => `"${v}"`).join(", ") }
+              });
+            }
+          }
+        }
+      }
+    };
+  }
+});
+
+// ../eslint-plugin/src/rules/no-enforcement-without-strict.ts
+var import_eslint_utils2 = __toESM(require_eslint_utils(), 1);
+var createRule2 = (0, import_eslint_utils2.RuleCreator)((name) => `https://praxis-kit.dev/eslint-rules/${name}`);
+var noEnforcementWithoutStrict = createRule2({
+  name: "no-enforcement-without-strict",
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Require enforcement.strict when enforcement.children or enforcement.aria is defined."
+    },
+    messages: {
+      missingStrict: "enforcement.{{ field }} is defined but enforcement.strict is not explicitly set. Adapter defaults vary \u2014 declare strict explicitly so the behavior is clear at the call site."
+    },
+    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 hasStrict = getObjectProperty(enf, "strict") !== void 0;
+        for (const field of ["children", "aria"]) {
+          const fieldProp = getObjectProperty(enf, field);
+          if (!fieldProp) continue;
+          if (field === "children") {
+            const arr = asArrayExpression(fieldProp.value);
+            if (!arr || arr.elements.length === 0) continue;
+          }
+          if (!hasStrict) {
+            context.report({ node, messageId: "missingStrict", data: { field } });
+            return;
+          }
+        }
+      }
+    };
+  }
+});
+
+// ../eslint-plugin/src/rules/no-invalid-default.ts
+var import_eslint_utils3 = __toESM(require_eslint_utils(), 1);
+var createRule3 = (0, import_eslint_utils3.RuleCreator)((name) => `https://praxis-kit.dev/eslint-rules/${name}`);
+var noInvalidDefault = createRule3({
+  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: '"{{ key }}" is not a variant defined in styling.variants. This default will have no effect.',
+      unknownDefaultValue: '"{{ value }}" is not a valid value for variant "{{ key }}". Expected one of: {{ allowed }}. This default will have no effect.',
+      nonLiteralValue: 'Default value for "{{ key }}" is not a string literal and cannot be statically validated.'
+    },
+    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;
+        for (const prop of defaults.properties) {
+          if (prop.type !== "Property") continue;
+          const key = getPropertyKey(prop);
+          if (!key) continue;
+          if (!variantMap.has(key)) {
+            context.report({ node: prop, messageId: "unknownDefaultKey", data: { key } });
+            continue;
+          }
+          const value = asStringLiteral(prop.value);
+          if (value === void 0) {
+            if (reportNonLiteral) {
+              context.report({ node: prop, messageId: "nonLiteralValue", data: { key } });
+            }
+            continue;
+          }
+          const allowed = variantMap.get(key);
+          if (!allowed.has(value)) {
+            context.report({
+              node: prop,
+              messageId: "unknownDefaultValue",
+              data: { key, value, allowed: [...allowed].map((v) => `"${v}"`).join(", ") }
+            });
+          }
+        }
+      }
+    };
+  }
+});
+
+// ../eslint-plugin/src/rules/no-invalid-html-nesting.ts
+var import_eslint_utils4 = __toESM(require_eslint_utils(), 1);
+
+// ../eslint-plugin/src/utils/html-nesting.ts
+var TAG_CATEGORIES = {
+  // Phrasing + flow
+  abbr: /* @__PURE__ */ new Set(["flow", "phrasing"]),
+  audio: /* @__PURE__ */ new Set(["flow", "phrasing", "embedded"]),
+  b: /* @__PURE__ */ new Set(["flow", "phrasing"]),
+  bdi: /* @__PURE__ */ new Set(["flow", "phrasing"]),
+  bdo: /* @__PURE__ */ new Set(["flow", "phrasing"]),
+  br: /* @__PURE__ */ new Set(["flow", "phrasing"]),
+  button: /* @__PURE__ */ new Set(["flow", "phrasing", "interactive"]),
+  canvas: /* @__PURE__ */ new Set(["flow", "phrasing", "embedded"]),
+  cite: /* @__PURE__ */ new Set(["flow", "phrasing"]),
+  code: /* @__PURE__ */ new Set(["flow", "phrasing"]),
+  data: /* @__PURE__ */ new Set(["flow", "phrasing"]),
+  dfn: /* @__PURE__ */ new Set(["flow", "phrasing"]),
+  em: /* @__PURE__ */ new Set(["flow", "phrasing"]),
+  embed: /* @__PURE__ */ new Set(["flow", "phrasing", "embedded", "interactive"]),
+  i: /* @__PURE__ */ new Set(["flow", "phrasing"]),
+  iframe: /* @__PURE__ */ new Set(["flow", "phrasing", "embedded", "interactive"]),
+  img: /* @__PURE__ */ new Set(["flow", "phrasing", "embedded"]),
+  input: /* @__PURE__ */ new Set(["flow", "phrasing", "interactive"]),
+  kbd: /* @__PURE__ */ new Set(["flow", "phrasing"]),
+  label: /* @__PURE__ */ new Set(["flow", "phrasing", "interactive"]),
+  mark: /* @__PURE__ */ new Set(["flow", "phrasing"]),
+  math: /* @__PURE__ */ new Set(["flow", "phrasing", "embedded"]),
+  meta: /* @__PURE__ */ new Set(["metadata", "flow", "phrasing"]),
+  noscript: /* @__PURE__ */ new Set(["metadata", "flow", "phrasing"]),
+  object: /* @__PURE__ */ new Set(["flow", "phrasing", "embedded"]),
+  output: /* @__PURE__ */ new Set(["flow", "phrasing"]),
+  picture: /* @__PURE__ */ new Set(["flow", "phrasing", "embedded"]),
+  q: /* @__PURE__ */ new Set(["flow", "phrasing"]),
+  ruby: /* @__PURE__ */ new Set(["flow", "phrasing"]),
+  s: /* @__PURE__ */ new Set(["flow", "phrasing"]),
+  samp: /* @__PURE__ */ new Set(["flow", "phrasing"]),
+  script: /* @__PURE__ */ new Set(["metadata", "flow", "phrasing"]),
+  select: /* @__PURE__ */ new Set(["flow", "phrasing", "interactive"]),
+  small: /* @__PURE__ */ new Set(["flow", "phrasing"]),
+  span: /* @__PURE__ */ new Set(["flow", "phrasing"]),
+  strong: /* @__PURE__ */ new Set(["flow", "phrasing"]),
+  sub: /* @__PURE__ */ new Set(["flow", "phrasing"]),
+  sup: /* @__PURE__ */ new Set(["flow", "phrasing"]),
+  svg: /* @__PURE__ */ new Set(["flow", "phrasing", "embedded"]),
+  template: /* @__PURE__ */ new Set(["metadata", "flow", "phrasing"]),
+  textarea: /* @__PURE__ */ new Set(["flow", "phrasing", "interactive"]),
+  time: /* @__PURE__ */ new Set(["flow", "phrasing"]),
+  u: /* @__PURE__ */ new Set(["flow", "phrasing"]),
+  var: /* @__PURE__ */ new Set(["flow", "phrasing"]),
+  video: /* @__PURE__ */ new Set(["flow", "phrasing", "embedded"]),
+  wbr: /* @__PURE__ */ new Set(["flow", "phrasing"]),
+  // Flow only (block-level)
+  address: /* @__PURE__ */ new Set(["flow"]),
+  article: /* @__PURE__ */ new Set(["flow", "sectioning"]),
+  aside: /* @__PURE__ */ new Set(["flow", "sectioning"]),
+  blockquote: /* @__PURE__ */ new Set(["flow"]),
+  details: /* @__PURE__ */ new Set(["flow", "interactive"]),
+  dialog: /* @__PURE__ */ new Set(["flow"]),
+  div: /* @__PURE__ */ new Set(["flow"]),
+  dl: /* @__PURE__ */ new Set(["flow"]),
+  fieldset: /* @__PURE__ */ new Set(["flow"]),
+  figure: /* @__PURE__ */ new Set(["flow"]),
+  footer: /* @__PURE__ */ new Set(["flow"]),
+  form: /* @__PURE__ */ new Set(["flow"]),
+  header: /* @__PURE__ */ new Set(["flow"]),
+  hr: /* @__PURE__ */ new Set(["flow"]),
+  li: /* @__PURE__ */ new Set(["flow"]),
+  link: /* @__PURE__ */ new Set(["metadata", "flow", "phrasing"]),
+  main: /* @__PURE__ */ new Set(["flow"]),
+  menu: /* @__PURE__ */ new Set(["flow"]),
+  nav: /* @__PURE__ */ new Set(["flow", "sectioning"]),
+  ol: /* @__PURE__ */ new Set(["flow"]),
+  p: /* @__PURE__ */ new Set(["flow"]),
+  pre: /* @__PURE__ */ new Set(["flow"]),
+  section: /* @__PURE__ */ new Set(["flow", "sectioning"]),
+  style: /* @__PURE__ */ new Set(["metadata", "flow"]),
+  summary: /* @__PURE__ */ new Set(["flow"]),
+  table: /* @__PURE__ */ new Set(["flow"]),
+  ul: /* @__PURE__ */ new Set(["flow"]),
+  // Heading
+  h1: /* @__PURE__ */ new Set(["flow", "heading"]),
+  h2: /* @__PURE__ */ new Set(["flow", "heading"]),
+  h3: /* @__PURE__ */ new Set(["flow", "heading"]),
+  h4: /* @__PURE__ */ new Set(["flow", "heading"]),
+  h5: /* @__PURE__ */ new Set(["flow", "heading"]),
+  h6: /* @__PURE__ */ new Set(["flow", "heading"]),
+  hgroup: /* @__PURE__ */ new Set(["flow", "heading"]),
+  // Metadata only
+  base: /* @__PURE__ */ new Set(["metadata"]),
+  title: /* @__PURE__ */ new Set(["metadata"])
+};
+var HTML_CONTENT_MODELS = {
+  // Specific-tag constraints (structural elements whose content is enumerated, not categorical)
+  colgroup: { kind: "specific", allowed: /* @__PURE__ */ new Set(["col", "template"]) },
+  dl: { kind: "specific", allowed: /* @__PURE__ */ new Set(["dt", "dd", "div", "script", "template"]) },
+  menu: { kind: "specific", allowed: /* @__PURE__ */ new Set(["li", "script", "template"]) },
+  ol: { kind: "specific", allowed: /* @__PURE__ */ new Set(["li", "script", "template"]) },
+  optgroup: { kind: "specific", allowed: /* @__PURE__ */ new Set(["option", "script", "template"]) },
+  picture: { kind: "specific", allowed: /* @__PURE__ */ new Set(["source", "img", "script", "template"]) },
+  select: {
+    kind: "specific",
+    allowed: /* @__PURE__ */ new Set(["option", "optgroup", "hr", "script", "template"])
+  },
+  table: {
+    kind: "specific",
+    allowed: /* @__PURE__ */ new Set([
+      "caption",
+      "colgroup",
+      "thead",
+      "tbody",
+      "tfoot",
+      "tr",
+      "script",
+      "template"
+    ])
+  },
+  tbody: { kind: "specific", allowed: /* @__PURE__ */ new Set(["tr", "script", "template"]) },
+  tfoot: { kind: "specific", allowed: /* @__PURE__ */ new Set(["tr", "script", "template"]) },
+  thead: { kind: "specific", allowed: /* @__PURE__ */ new Set(["tr", "script", "template"]) },
+  tr: { kind: "specific", allowed: /* @__PURE__ */ new Set(["td", "th", "script", "template"]) },
+  ul: { kind: "specific", allowed: /* @__PURE__ */ new Set(["li", "script", "template"]) },
+  // Phrasing-content parents (any element whose content model is phrasing content)
+  abbr: { kind: "category", allowed: /* @__PURE__ */ new Set(["phrasing"]) },
+  b: { kind: "category", allowed: /* @__PURE__ */ new Set(["phrasing"]) },
+  bdi: { kind: "category", allowed: /* @__PURE__ */ new Set(["phrasing"]) },
+  bdo: { kind: "category", allowed: /* @__PURE__ */ new Set(["phrasing"]) },
+  cite: { kind: "category", allowed: /* @__PURE__ */ new Set(["phrasing"]) },
+  code: { kind: "category", allowed: /* @__PURE__ */ new Set(["phrasing"]) },
+  data: { kind: "category", allowed: /* @__PURE__ */ new Set(["phrasing"]) },
+  dfn: { kind: "category", allowed: /* @__PURE__ */ new Set(["phrasing"]) },
+  dt: { kind: "category", allowed: /* @__PURE__ */ new Set(["phrasing"]) },
+  em: { kind: "category", allowed: /* @__PURE__ */ new Set(["phrasing"]) },
+  h1: { kind: "category", allowed: /* @__PURE__ */ new Set(["phrasing"]) },
+  h2: { kind: "category", allowed: /* @__PURE__ */ new Set(["phrasing"]) },
+  h3: { kind: "category", allowed: /* @__PURE__ */ new Set(["phrasing"]) },
+  h4: { kind: "category", allowed: /* @__PURE__ */ new Set(["phrasing"]) },
+  h5: { kind: "category", allowed: /* @__PURE__ */ new Set(["phrasing"]) },
+  h6: { kind: "category", allowed: /* @__PURE__ */ new Set(["phrasing"]) },
+  i: { kind: "category", allowed: /* @__PURE__ */ new Set(["phrasing"]) },
+  kbd: { kind: "category", allowed: /* @__PURE__ */ new Set(["phrasing"]) },
+  label: { kind: "category", allowed: /* @__PURE__ */ new Set(["phrasing"]) },
+  mark: { kind: "category", allowed: /* @__PURE__ */ new Set(["phrasing"]) },
+  output: { kind: "category", allowed: /* @__PURE__ */ new Set(["phrasing"]) },
+  p: { kind: "category", allowed: /* @__PURE__ */ new Set(["phrasing"]) },
+  q: { kind: "category", allowed: /* @__PURE__ */ new Set(["phrasing"]) },
+  ruby: { kind: "category", allowed: /* @__PURE__ */ new Set(["phrasing"]) },
+  s: { kind: "category", allowed: /* @__PURE__ */ new Set(["phrasing"]) },
+  samp: { kind: "category", allowed: /* @__PURE__ */ new Set(["phrasing"]) },
+  small: { kind: "category", allowed: /* @__PURE__ */ new Set(["phrasing"]) },
+  span: { kind: "category", allowed: /* @__PURE__ */ new Set(["phrasing"]) },
+  strong: { kind: "category", allowed: /* @__PURE__ */ new Set(["phrasing"]) },
+  sub: { kind: "category", allowed: /* @__PURE__ */ new Set(["phrasing"]) },
+  sup: { kind: "category", allowed: /* @__PURE__ */ new Set(["phrasing"]) },
+  time: { kind: "category", allowed: /* @__PURE__ */ new Set(["phrasing"]) },
+  u: { kind: "category", allowed: /* @__PURE__ */ new Set(["phrasing"]) },
+  var: { kind: "category", allowed: /* @__PURE__ */ new Set(["phrasing"]) },
+  // Phrasing or heading (spec allows either as first child)
+  legend: { kind: "category", allowed: /* @__PURE__ */ new Set(["phrasing", "heading"]) },
+  summary: { kind: "category", allowed: /* @__PURE__ */ new Set(["phrasing", "heading"]) }
+};
+
+// ../eslint-plugin/src/rules/no-invalid-html-nesting.ts
+var createRule4 = (0, import_eslint_utils4.RuleCreator)((name) => `https://praxis-kit.dev/eslint-rules/${name}`);
+var ALLOWED_TEXT = Object.fromEntries(
+  Object.entries(HTML_CONTENT_MODELS).map(([tag, model]) => [
+    tag,
+    model.kind === "specific" ? [...model.allowed].join(", ") : [...model.allowed].map((c) => `${c} content`).join(", ")
+  ])
+);
+function getIntrinsicTag(name) {
+  if (name.type !== "JSXIdentifier") return void 0;
+  return /^[a-z]/.test(name.name) ? name.name : void 0;
+}
+function isAllowed(childTag, model) {
+  if (model.kind === "specific") return model.allowed.has(childTag);
+  const cats = TAG_CATEGORIES[childTag];
+  if (!cats) return true;
+  return [...model.allowed].some((c) => cats.has(c));
+}
+var noInvalidHtmlNesting = createRule4({
+  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: "<{{ child }}> is not a valid direct child of <{{ parent }}>. Allowed: {{ allowed }}."
+    },
+    schema: []
+  },
+  defaultOptions: [],
+  create(context) {
+    return {
+      JSXElement(node) {
+        const parentTag = getIntrinsicTag(node.openingElement.name);
+        if (!parentTag) return;
+        const model = HTML_CONTENT_MODELS[parentTag];
+        if (!model) return;
+        for (const child of node.children) {
+          if (child.type !== "JSXElement") continue;
+          const childTag = getIntrinsicTag(child.openingElement.name);
+          if (childTag === void 0) continue;
+          if (isAllowed(childTag, model)) continue;
+          context.report({
+            node: child,
+            messageId: "invalidChild",
+            data: {
+              child: childTag,
+              parent: parentTag,
+              allowed: ALLOWED_TEXT[parentTag] ?? ""
+            }
+          });
+        }
+      }
+    };
+  }
+});
+
+// ../eslint-plugin/src/rules/no-redundant-role.ts
+var import_eslint_utils5 = __toESM(require_eslint_utils(), 1);
+
+// ../eslint-plugin/src/utils/implicit-roles.ts
+var 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"
+};
+
+// ../eslint-plugin/src/rules/no-redundant-role.ts
+var createRule5 = (0, import_eslint_utils5.RuleCreator)((name) => `https://praxis-kit.dev/eslint-rules/${name}`);
+function getJsxTagName(node) {
+  const name = node.name;
+  if (name.type === "JSXIdentifier") return name.name;
+  return void 0;
+}
+function getJsxStringAttribute(node, attrName) {
+  for (const attr of node.attributes) {
+    if (attr.type !== "JSXAttribute") continue;
+    const key = attr.name;
+    if (key.type !== "JSXIdentifier" || key.name !== attrName) continue;
+    const val = attr.value;
+    if (val === null) continue;
+    if (val.type === "Literal" && typeof val.value === "string") {
+      return { node: attr, value: val.value };
+    }
+    if (val.type === "JSXExpressionContainer" && val.expression.type === "Literal" && typeof val.expression.value === "string") {
+      return { node: attr, value: val.expression.value };
+    }
+  }
+  return void 0;
+}
+var noRedundantRole = createRule5({
+  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: 'role="{{ role }}" is redundant on <{{ tag }}>: the element already carries this implicit ARIA role. Remove the attribute.'
+    },
+    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 (roleAttr.value === implicitRole) {
+          context.report({
+            node: roleAttr.node,
+            messageId: "redundantRole",
+            data: { role: roleAttr.value, tag },
+            fix(fixer) {
+              return fixer.remove(roleAttr.node);
+            }
+          });
+        }
+      }
+    };
+  }
+});
+
+// ../eslint-plugin/src/rules/valid-cardinality.ts
+var import_eslint_utils6 = __toESM(require_eslint_utils(), 1);
+var createRule6 = (0, import_eslint_utils6.RuleCreator)((name) => `https://praxis-kit.dev/eslint-rules/${name}`);
+var validCardinality = createRule6({
+  name: "valid-cardinality",
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Enforce valid min/max values in enforcement.children cardinality rules."
+    },
+    messages: {
+      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.",
+      zeroMax: "cardinality.max of 0 means no children of this type are allowed. Use 0 intentionally or remove the rule."
+    },
+    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;
+        for (const element of arr.elements) {
+          if (!element || element.type !== "ObjectExpression") continue;
+          const cardProp = getObjectProperty(element, "cardinality");
+          if (!cardProp) continue;
+          const card = asObjectExpression(cardProp.value);
+          if (!card) continue;
+          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 (min !== void 0 && min < 0) {
+            context.report({
+              node: minProp,
+              messageId: "negativeMin",
+              data: { value: String(min) }
+            });
+          }
+          if (max !== void 0 && max < 0) {
+            context.report({
+              node: maxProp,
+              messageId: "negativeMax",
+              data: { value: String(max) }
+            });
+          }
+          if (max !== void 0 && max === 0) {
+            context.report({ node: maxProp, messageId: "zeroMax" });
+          }
+          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) }
+            });
+          }
+        }
+      }
+    };
+  }
+});
+
+// ../eslint-plugin/src/rules/valid-children-config.ts
+var import_eslint_utils7 = __toESM(require_eslint_utils(), 1);
+var createRule7 = (0, import_eslint_utils7.RuleCreator)((name) => `https://praxis-kit.dev/eslint-rules/${name}`);
+var validChildrenConfig = createRule7({
+  name: "valid-children-config",
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Enforce cross-rule consistency of enforcement.children \u2014 detect positional conflicts and cardinality impossibilities."
+    },
+    messages: {
+      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.'
+    },
+    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 = [];
+        const lastPositionProps = [];
+        let onlyWithMinProp = null;
+        let rulesWithMinCount = 0;
+        for (const element of arr.elements) {
+          if (!element || element.type !== "ObjectExpression") continue;
+          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) {
+            rulesWithMinCount++;
+            if (position === "only" && positionProp && !onlyWithMinProp) {
+              onlyWithMinProp = positionProp;
+            }
+          }
+        }
+        for (const prop of firstPositionProps.slice(1)) {
+          context.report({ node: prop, messageId: "multipleFirst" });
+        }
+        for (const prop of lastPositionProps.slice(1)) {
+          context.report({ node: prop, messageId: "multipleLast" });
+        }
+        if (onlyWithMinProp && rulesWithMinCount > 1) {
+          context.report({
+            node: onlyWithMinProp,
+            messageId: "minSumExceedsCapacity",
+            data: { count: String(rulesWithMinCount - 1) }
+          });
+        }
+      }
+    };
+  }
+});
+
+// ../eslint-plugin/src/index.ts
+var 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: {}
+};
+var 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;
+var src_default = plugin;
+export {
+  src_default as default,
+  noDeadCompound,
+  noEnforcementWithoutStrict,
+  noInvalidDefault,
+  noInvalidHtmlNesting,
+  noRedundantRole,
+  plugin,
+  recommended,
+  validCardinality,
+  validChildrenConfig
+};