praxis-kit 1.1.0

package/dist/vue/index.js

@@ -0,0 +1,1922 @@
+// ../../adapters/vue/src/create-contract-component.ts
+import { computed, defineComponent as defineComponent2 } from "vue";
+
+// ../shared/src/guards/children/component-id.ts
+var COMPONENT_DEFAULT_TAG = /* @__PURE__ */ Symbol("praxis.component-default-tag");
+
+// ../../adapters/vue/src/apply-display-name.ts
+function applyDisplayName(component, name) {
+  Object.assign(component, { displayName: name ?? "PolymorphicComponent" });
+}
+
+// ../../lib/adapter-utils/src/apply-filter.ts
+function applyFilter(props, filterProps, variantKeys) {
+  const out = {};
+  for (const k in props) {
+    if (!Object.hasOwn(props, k)) continue;
+    if (filterProps(k, variantKeys)) continue;
+    out[k] = props[k];
+  }
+  return out;
+}
+
+// ../core/dist/chunk-US6MPMDF.js
+function makeResolveTag(defaultTag) {
+  return function tag(as) {
+    return as ?? defaultTag;
+  };
+}
+function assertNever(value) {
+  throw new Error(`Unexpected value: ${String(value)}`);
+}
+function r(e) {
+  var t, f, n = "";
+  if ("string" == typeof e || "number" == typeof e) n += e;
+  else if ("object" == typeof e) if (Array.isArray(e)) {
+    var o = e.length;
+    for (t = 0; t < o; t++) e[t] && (f = r(e[t])) && (n && (n += " "), n += f);
+  } else for (f in e) e[f] && (n && (n += " "), n += f);
+  return n;
+}
+function clsx() {
+  for (var e, t, f = 0, n = "", o = arguments.length; f < o; f++) (e = arguments[f]) && (t = r(e)) && (n && (n += " "), n += t);
+  return n;
+}
+function cn(...inputs) {
+  return clsx(...inputs);
+}
+function mergeProps(defaultProps, props) {
+  return {
+    ...defaultProps ?? {},
+    ...props
+  };
+}
+function isNull(value) {
+  return value === null;
+}
+function isObject(value) {
+  return !isNull(value) && typeof value === "object";
+}
+function isString(value) {
+  return typeof value === "string";
+}
+function isNumber(value) {
+  return typeof value === "number";
+}
+var EMPTY_VARIANT_KEYS = /* @__PURE__ */ new Set();
+function composeNormalizers(normalizers, fn) {
+  if (!normalizers?.length) return fn;
+  return ((props) => {
+    const patched = normalizers.reduce(
+      (acc, normalizer) => ({ ...acc, ...normalizer(acc) }),
+      props
+    );
+    return fn ? fn(patched) : patched;
+  });
+}
+function whenDefined(key, value) {
+  return value === void 0 ? {} : { [key]: value };
+}
+function resolveFactoryOptions(options = {}) {
+  const { styling, enforcement } = options;
+  const composedNormalizeFn = composeNormalizers(enforcement?.props, options.normalize);
+  const variantKeys = styling?.variants === void 0 ? EMPTY_VARIANT_KEYS : new Set(Object.keys(styling.variants));
+  return Object.freeze({
+    defaultTag: options.tag ?? "div",
+    strict: enforcement?.strict ?? false,
+    variantKeys,
+    ...whenDefined("displayName", options.name),
+    ...whenDefined("defaultProps", options.defaults),
+    ...whenDefined("baseClassName", styling?.base),
+    ...whenDefined("tagMap", styling?.tags),
+    ...whenDefined("presetMap", styling?.presets),
+    ...whenDefined("variants", styling?.variants),
+    ...whenDefined("defaultVariants", styling?.defaults),
+    ...whenDefined("compoundVariants", styling?.compounds),
+    ...whenDefined("normalizeFn", composedNormalizeFn),
+    ...whenDefined("ariaRules", enforcement?.aria),
+    ...whenDefined("childRules", enforcement?.children),
+    ...whenDefined("allowedAs", enforcement?.allowedAs),
+    ...whenDefined("precomputedClasses", styling?.precomputedClasses)
+  });
+}
+function report(strict, message) {
+  if (strict === false) return;
+  const mode = strict === true ? "throw" : strict;
+  if (mode === "throw") throw new Error(message);
+  console.warn(message);
+}
+function validateFactoryOptions(resolved) {
+  const { strict } = resolved;
+  if (strict === false) return;
+  const name = resolved.displayName ?? "Component";
+  const { variants } = resolved;
+  const checkSelection = (label2, selection) => {
+    const record = selection;
+    for (const dim in record) {
+      const value = record[dim];
+      if (value === void 0 || value === null) continue;
+      if (!variants || !Object.hasOwn(variants, dim)) {
+        report(strict, `${name}: ${label2} references unknown variant "${dim}".`);
+        continue;
+      }
+      const states = variants[dim];
+      const stateKey = String(value);
+      if (!Object.hasOwn(states, stateKey)) {
+        report(
+          strict,
+          `${name}: ${label2} sets "${dim}" to unknown value "${stateKey}" (valid: ${Object.keys(states).join(", ")}).`
+        );
+      }
+    }
+  };
+  const { presetMap } = resolved;
+  if (presetMap) {
+    for (const presetKey in presetMap) {
+      checkSelection(`preset "${presetKey}"`, presetMap[presetKey]);
+    }
+  }
+  if (resolved.defaultVariants) checkSelection("defaults", resolved.defaultVariants);
+}
+var warned = /* @__PURE__ */ new Set();
+var pendingAsyncWarns = /* @__PURE__ */ new Set();
+var asyncWarnScheduled = false;
+function flushAsyncWarns() {
+  asyncWarnScheduled = false;
+  const messages = [...pendingAsyncWarns];
+  pendingAsyncWarns.clear();
+  for (const msg of messages) {
+    console.warn(msg);
+  }
+}
+function report2(strict, message) {
+  if (!strict) return;
+  const mode = strict === true ? "throw" : strict;
+  if (mode === "throw") throw new Error(message);
+  if (mode === "async-warn") {
+    if (pendingAsyncWarns.has(message)) return;
+    pendingAsyncWarns.add(message);
+    if (!asyncWarnScheduled) {
+      asyncWarnScheduled = true;
+      queueMicrotask(flushAsyncWarns);
+    }
+    return;
+  }
+  if (warned.has(message)) return;
+  warned.add(message);
+  console.warn(message);
+}
+function label(name) {
+  return name ? `[${name}]` : "[createContractComponent]";
+}
+function validateRenderProps(options, props, presetKey) {
+  const { strict, presetMap, variants, displayName } = options;
+  if (!strict) return;
+  const tag = label(displayName);
+  if (presetKey !== void 0 && (!presetMap || !Object.hasOwn(presetMap, presetKey))) {
+    report2(strict, `${tag} Unknown presetKey "${presetKey}" \u2014 no preset with that name exists.`);
+  }
+  if (variants) {
+    for (const key in variants) {
+      if (!Object.hasOwn(props, key)) continue;
+      const value = props[key];
+      if (value === void 0 || value === null) continue;
+      const dim = variants[key];
+      if (dim && !Object.hasOwn(dim, String(value))) {
+        report2(
+          strict,
+          `${tag} Variant "${key}=${String(value)}" is not a defined value for the "${key}" dimension.`
+        );
+      }
+    }
+  }
+}
+function panic(message) {
+  throw new Error(message);
+}
+function describe(value) {
+  if (value === null) return "null";
+  if (Array.isArray(value)) return "array";
+  return typeof value;
+}
+function assertPluginShape(result) {
+  if (result === null || typeof result !== "object")
+    panic(
+      `[praxis-kit] Plugin factory must return an object with a 'pipeline' function. Got: ${result === null ? "null" : typeof result}.`
+    );
+  const plugin = result;
+  if (typeof plugin.pipeline !== "function")
+    panic(
+      `[praxis-kit] Plugin factory return value is missing a 'pipeline' function. Got pipeline: ${typeof plugin.pipeline}.`
+    );
+}
+function guardPipeline(pipeline) {
+  if (process.env.NODE_ENV === "production") return pipeline;
+  return function guardedPipeline(tag, props, className, variantKey) {
+    const result = pipeline(tag, props, className, variantKey);
+    if (typeof result !== "string")
+      panic(`[praxis-kit] Plugin pipeline must return a string. Got: ${describe(result)}.`);
+    return result;
+  };
+}
+var NOOP_CLASS_PIPELINE = (_tag, _props, className) => Array.isArray(className) ? className.join(" ") : className ?? "";
+function resolveClassPipeline(options, resolved, strict, capabilities) {
+  const factory = options.styling?.plugin;
+  if (!factory) {
+    const createClassPipeline2 = capabilities?.createClassPipeline;
+    const classPipeline2 = createClassPipeline2 ? createClassPipeline2(resolved) : NOOP_CLASS_PIPELINE;
+    return { pluginResult: void 0, classPipeline: classPipeline2 };
+  }
+  const pluginResult = factory(resolved, strict);
+  assertPluginShape(pluginResult);
+  const classPipeline = guardPipeline(pluginResult.pipeline);
+  return { pluginResult, classPipeline };
+}
+function createRuntimeMethods(resolved, classPipeline, engine) {
+  return {
+    resolveTag: makeResolveTag(resolved.defaultTag),
+    resolveProps(props) {
+      return mergeProps(resolved.defaultProps, props);
+    },
+    resolveClasses(tag, props, className, variantKey) {
+      if (process.env.NODE_ENV !== "production") {
+        validateRenderProps(resolved, props, variantKey);
+      }
+      return classPipeline(tag, props, className, variantKey);
+    },
+    resolveAria(tag, props) {
+      if (!engine) return { props };
+      const result = engine.validate(tag, props);
+      return { props: result.props };
+    }
+  };
+}
+function createRuntimeObject(methods, resolved, pluginResult) {
+  return pluginResult ? { ...methods, options: resolved, hasStyling: true, classPlugin: pluginResult } : { ...methods, options: resolved };
+}
+function createPolymorphic(options = {}, capabilities) {
+  const resolved = resolveFactoryOptions(options);
+  if (process.env.NODE_ENV !== "production") validateFactoryOptions(resolved);
+  const { pluginResult, classPipeline } = resolveClassPipeline(
+    options,
+    resolved,
+    resolved.strict,
+    capabilities
+  );
+  const engine = options.enforcement !== void 0 && capabilities?.AriaEngine ? new capabilities.AriaEngine(
+    resolved.strict,
+    resolved.ariaRules?.length ? { rules: resolved.ariaRules } : void 0
+  ) : null;
+  const methods = createRuntimeMethods(resolved, classPipeline, engine);
+  return createRuntimeObject(
+    methods,
+    resolved,
+    pluginResult
+  );
+}
+var KNOWN_ARIA_ROLES = [
+  "alert",
+  "alertdialog",
+  "application",
+  "article",
+  "banner",
+  "blockquote",
+  "button",
+  "caption",
+  "cell",
+  "checkbox",
+  "code",
+  "columnheader",
+  "combobox",
+  "complementary",
+  "contentinfo",
+  "definition",
+  "deletion",
+  "dialog",
+  "document",
+  "emphasis",
+  "feed",
+  "figure",
+  "form",
+  "generic",
+  "grid",
+  "gridcell",
+  "group",
+  "heading",
+  "img",
+  "insertion",
+  "link",
+  "list",
+  "listbox",
+  "listitem",
+  "log",
+  "main",
+  "marquee",
+  "math",
+  "menu",
+  "menubar",
+  "menuitem",
+  "menuitemcheckbox",
+  "menuitemradio",
+  "meter",
+  "navigation",
+  "none",
+  "note",
+  "option",
+  "paragraph",
+  "presentation",
+  "progressbar",
+  "radio",
+  "radiogroup",
+  "region",
+  "row",
+  "rowgroup",
+  "rowheader",
+  "scrollbar",
+  "search",
+  "searchbox",
+  "separator",
+  "slider",
+  "spinbutton",
+  "status",
+  "strong",
+  "subscript",
+  "superscript",
+  "switch",
+  "tab",
+  "table",
+  "tablist",
+  "tabpanel",
+  "term",
+  "textbox",
+  "time",
+  "timer",
+  "toolbar",
+  "tooltip",
+  "tree",
+  "treegrid",
+  "treeitem"
+];
+var KNOWN_ARIA_ROLES_SET = new Set(KNOWN_ARIA_ROLES);
+var GLOBAL_ARIA_ATTRIBUTES = /* @__PURE__ */ new Set([
+  "aria-atomic",
+  "aria-busy",
+  "aria-controls",
+  "aria-current",
+  "aria-describedby",
+  "aria-details",
+  "aria-disabled",
+  "aria-errormessage",
+  "aria-flowto",
+  "aria-hidden",
+  "aria-keyshortcuts",
+  "aria-label",
+  "aria-labelledby",
+  "aria-live",
+  "aria-owns",
+  "aria-relevant",
+  "aria-roledescription"
+]);
+var IMPLICIT_ROLE_RECORD = {
+  article: "article",
+  aside: "complementary",
+  footer: "contentinfo",
+  header: "banner",
+  main: "main",
+  nav: "navigation",
+  button: "button",
+  a: "link",
+  select: "listbox",
+  h1: "heading",
+  h2: "heading",
+  h3: "heading",
+  h4: "heading",
+  h5: "heading",
+  h6: "heading",
+  ul: "list",
+  ol: "list",
+  li: "listitem",
+  table: "table",
+  tr: "row",
+  td: "cell",
+  th: "columnheader"
+};
+var STRONG_ROLES = [
+  "main",
+  "navigation",
+  "complementary",
+  "contentinfo",
+  "banner"
+];
+var STANDALONE_ROLES = ["article"];
+var STRONG_ROLES_SET = new Set(STRONG_ROLES);
+var STANDALONE_ROLES_SET = new Set(STANDALONE_ROLES);
+var ROLE_RESTRICTED_ATTRIBUTES = /* @__PURE__ */ new Map([
+  [
+    "aria-activedescendant",
+    /* @__PURE__ */ new Set([
+      "application",
+      "combobox",
+      "grid",
+      "group",
+      "listbox",
+      "menu",
+      "menubar",
+      "radiogroup",
+      "spinbutton",
+      "tablist",
+      "toolbar",
+      "textbox",
+      "tree",
+      "treegrid"
+    ])
+  ],
+  ["aria-autocomplete", /* @__PURE__ */ new Set(["combobox", "searchbox", "textbox"])],
+  [
+    "aria-checked",
+    /* @__PURE__ */ new Set(["checkbox", "menuitemcheckbox", "option", "radio", "switch", "treeitem"])
+  ],
+  ["aria-colcount", /* @__PURE__ */ new Set(["grid", "table", "treegrid"])],
+  ["aria-colindex", /* @__PURE__ */ new Set(["cell", "columnheader", "gridcell", "row", "rowheader"])],
+  ["aria-colspan", /* @__PURE__ */ new Set(["cell", "columnheader", "gridcell", "rowheader"])],
+  [
+    "aria-expanded",
+    /* @__PURE__ */ new Set([
+      "button",
+      "combobox",
+      "gridcell",
+      "listbox",
+      "menuitem",
+      "menuitemcheckbox",
+      "menuitemradio",
+      "row",
+      "rowheader",
+      "tab",
+      "treeitem"
+    ])
+  ],
+  [
+    "aria-haspopup",
+    /* @__PURE__ */ new Set([
+      "button",
+      "combobox",
+      "gridcell",
+      "listbox",
+      "menuitem",
+      "menuitemcheckbox",
+      "menuitemradio",
+      "tab",
+      "treeitem"
+    ])
+  ],
+  ["aria-level", /* @__PURE__ */ new Set(["heading", "listitem", "row", "treeitem"])],
+  ["aria-modal", /* @__PURE__ */ new Set(["alertdialog", "dialog"])],
+  ["aria-multiline", /* @__PURE__ */ new Set(["textbox"])],
+  ["aria-multiselectable", /* @__PURE__ */ new Set(["grid", "listbox", "tablist", "tree", "treegrid"])],
+  [
+    "aria-orientation",
+    /* @__PURE__ */ new Set(["scrollbar", "select", "separator", "slider", "tablist", "toolbar", "tree"])
+  ],
+  ["aria-placeholder", /* @__PURE__ */ new Set(["searchbox", "textbox"])],
+  [
+    "aria-posinset",
+    /* @__PURE__ */ new Set([
+      "article",
+      "listitem",
+      "menuitem",
+      "menuitemcheckbox",
+      "menuitemradio",
+      "option",
+      "radio",
+      "row",
+      "tab"
+    ])
+  ],
+  ["aria-pressed", /* @__PURE__ */ new Set(["button"])],
+  [
+    "aria-readonly",
+    /* @__PURE__ */ new Set([
+      "combobox",
+      "grid",
+      "gridcell",
+      "listbox",
+      "radiogroup",
+      "slider",
+      "spinbutton",
+      "textbox",
+      "tree",
+      "treegrid"
+    ])
+  ],
+  [
+    "aria-required",
+    /* @__PURE__ */ new Set([
+      "combobox",
+      "gridcell",
+      "listbox",
+      "radiogroup",
+      "spinbutton",
+      "textbox",
+      "tree",
+      "treegrid"
+    ])
+  ],
+  ["aria-rowcount", /* @__PURE__ */ new Set(["grid", "table", "treegrid"])],
+  ["aria-rowindex", /* @__PURE__ */ new Set(["cell", "columnheader", "gridcell", "row", "rowheader"])],
+  ["aria-rowspan", /* @__PURE__ */ new Set(["cell", "columnheader", "gridcell", "rowheader"])],
+  [
+    "aria-selected",
+    /* @__PURE__ */ new Set(["columnheader", "gridcell", "option", "row", "rowheader", "tab", "treeitem"])
+  ],
+  [
+    "aria-setsize",
+    /* @__PURE__ */ new Set([
+      "article",
+      "listitem",
+      "menuitem",
+      "menuitemcheckbox",
+      "menuitemradio",
+      "option",
+      "radio",
+      "row",
+      "tab"
+    ])
+  ],
+  ["aria-sort", /* @__PURE__ */ new Set(["columnheader", "rowheader"])],
+  [
+    "aria-valuemax",
+    /* @__PURE__ */ new Set(["meter", "progressbar", "scrollbar", "separator", "slider", "spinbutton"])
+  ],
+  [
+    "aria-valuemin",
+    /* @__PURE__ */ new Set(["meter", "progressbar", "scrollbar", "separator", "slider", "spinbutton"])
+  ],
+  [
+    "aria-valuenow",
+    /* @__PURE__ */ new Set(["meter", "progressbar", "scrollbar", "separator", "slider", "spinbutton"])
+  ],
+  [
+    "aria-valuetext",
+    /* @__PURE__ */ new Set(["meter", "progressbar", "scrollbar", "separator", "slider", "spinbutton"])
+  ]
+]);
+function isUndefined(value) {
+  return value === void 0;
+}
+function isGlobalAriaAttribute(attr) {
+  return GLOBAL_ARIA_ATTRIBUTES.has(attr);
+}
+function isAriaAttributeValidForRole(attr, role) {
+  const allowedRoles = ROLE_RESTRICTED_ATTRIBUTES.get(attr);
+  if (isUndefined(allowedRoles)) return true;
+  if (isUndefined(role)) return false;
+  return allowedRoles.has(role);
+}
+function isStrongImplicitRole(tag) {
+  if (!(tag in IMPLICIT_ROLE_RECORD)) return false;
+  return STRONG_ROLES_SET.has(IMPLICIT_ROLE_RECORD[tag]);
+}
+function isStandaloneTag(tag) {
+  if (!(tag in IMPLICIT_ROLE_RECORD)) return false;
+  return STANDALONE_ROLES_SET.has(IMPLICIT_ROLE_RECORD[tag]);
+}
+function isKnownAriaRole(value) {
+  return isString(value) && KNOWN_ARIA_ROLES_SET.has(value);
+}
+
+// ../core/dist/chunk-7YNORQXK.js
+var COMPONENT_DEFAULT_TAG2 = /* @__PURE__ */ Symbol("praxis.component-default-tag");
+function resolveChildTag(child) {
+  if (!isObject(child) || !("type" in child)) return void 0;
+  const t = child.type;
+  if (isString(t)) return t;
+  if (isObject(t) && COMPONENT_DEFAULT_TAG2 in t) {
+    const defaultTag = t[COMPONENT_DEFAULT_TAG2];
+    if (!isString(defaultTag)) return void 0;
+    const props = child.props;
+    const as = isObject(props) && "as" in props ? props.as : void 0;
+    return isString(as) ? as : defaultTag;
+  }
+  return void 0;
+}
+function isTag(...tags) {
+  const set = new Set(tags);
+  return (child) => {
+    const tag = resolveChildTag(child);
+    return tag !== void 0 && set.has(tag);
+  };
+}
+function isOpenContent(...blockedTags) {
+  const set = new Set(blockedTags);
+  return (child) => isObject(child) && "type" in child && (!isString(child.type) || !set.has(child.type));
+}
+var METADATA_TAGS = ["script", "template"];
+var metadataMatch = isTag(...METADATA_TAGS);
+function metadata(name = "metadata") {
+  return { name, match: metadataMatch };
+}
+function firstOptional(name, tag) {
+  return { name, match: isTag(tag), cardinality: { max: 1 }, position: "first" };
+}
+function contract(children) {
+  return { strict: "warn", children };
+}
+function ariaContract(aria) {
+  return { strict: "warn", aria };
+}
+function firstChildContract(name, tag) {
+  return contract([firstOptional(name, tag), { name: "content", match: isOpenContent(tag) }]);
+}
+var VOID_TAGS = [
+  "area",
+  "base",
+  "br",
+  "col",
+  "embed",
+  "hr",
+  "img",
+  "input",
+  "link",
+  "meta",
+  "param",
+  "source",
+  "track",
+  "wbr"
+];
+var TEXT_ONLY_TAGS = ["option", "script", "style", "textarea", "title"];
+var LANDMARK_TAGS = ["article", "aside", "footer", "header", "main", "nav"];
+var listContract = contract([{ name: "list-item", match: isTag("li", ...METADATA_TAGS) }]);
+var tableContract = contract([
+  firstOptional("caption", "caption"),
+  { name: "colgroup", match: isTag("colgroup") },
+  { name: "thead", match: isTag("thead"), cardinality: { max: 1 } },
+  { name: "tbody", match: isTag("tbody") },
+  { name: "tfoot", match: isTag("tfoot"), cardinality: { max: 1 } },
+  { name: "table-row", match: isTag("tr", ...METADATA_TAGS) }
+]);
+var tableBodyContract = contract([
+  { name: "table-row", match: isTag("tr", ...METADATA_TAGS) }
+]);
+var tableRowContract = contract([
+  { name: "table-cell", match: isTag("td", "th", ...METADATA_TAGS) }
+]);
+var colgroupContract = contract([{ name: "column", match: isTag("col", "template") }]);
+var dlContract = contract([
+  { name: "term", match: isTag("dt") },
+  { name: "description", match: isTag("dd") },
+  { name: "group", match: isTag("div") },
+  metadata()
+]);
+var selectContract = contract([
+  { name: "option", match: isTag("option", "optgroup", "hr", ...METADATA_TAGS) }
+]);
+var optgroupContract = contract([
+  { name: "option", match: isTag("option", ...METADATA_TAGS) }
+]);
+var datalistContract = contract([
+  { name: "option", match: isTag("option", ...METADATA_TAGS) }
+]);
+var pictureContract = contract([
+  { name: "source", match: isTag("source", ...METADATA_TAGS) },
+  { name: "image", match: isTag("img"), cardinality: { min: 1, max: 1 }, position: "last" }
+]);
+var figureContract = contract([
+  { name: "caption", match: isTag("figcaption"), cardinality: { max: 1 } },
+  { name: "content", match: isOpenContent("figcaption") }
+]);
+var detailsContract = firstChildContract("summary", "summary");
+var fieldsetContract = firstChildContract("legend", "legend");
+var mediaContract = contract([
+  { name: "source", match: isTag("source") },
+  { name: "track", match: isTag("track") },
+  metadata(),
+  { name: "content", match: isOpenContent("source", "track", ...METADATA_TAGS) }
+]);
+var headContract = contract([
+  {
+    name: "metadata",
+    match: isTag("base", "link", "meta", "noscript", "script", "style", "template", "title")
+  }
+]);
+var htmlContract = contract([
+  { name: "head", match: isTag("head"), cardinality: { min: 1, max: 1 }, position: "first" },
+  { name: "body", match: isTag("body"), cardinality: { min: 1, max: 1 } }
+]);
+var voidContract = contract([]);
+var textOnlyContract = contract([
+  {
+    name: "text",
+    match: (child) => isString(child) || isNumber(child)
+  }
+]);
+var LANDMARK_TAG_SET = new Set(LANDMARK_TAGS);
+var removeLandmarkRoleOverride = {
+  kind: "removeRole",
+  apply: ({ props }) => {
+    if (!("role" in props)) return { applied: false, next: props };
+    const { role: _r, ...rest } = props;
+    return { applied: true, next: rest, previous: props };
+  }
+};
+function landmarkRoleRule({ tag, props, implicitRole }) {
+  if (!LANDMARK_TAG_SET.has(tag) || !implicitRole) return [];
+  const role = props.role;
+  if (!role || role === implicitRole) return [];
+  return [
+    {
+      valid: false,
+      fixable: true,
+      severity: "error",
+      fix: removeLandmarkRoleOverride,
+      message: `<${tag}> has a fixed landmark role="${implicitRole}". role="${role}" overrides it and confuses assistive technology. The override has been removed.`
+    }
+  ];
+}
+var landmarkContract = ariaContract([landmarkRoleRule]);
+var CONTRACT_GROUPS = [
+  [VOID_TAGS, voidContract],
+  [TEXT_ONLY_TAGS, textOnlyContract],
+  [LANDMARK_TAGS, landmarkContract],
+  [["ul", "ol", "menu"], listContract],
+  [["audio", "video"], mediaContract],
+  [["thead", "tbody", "tfoot"], tableBodyContract]
+];
+function contractMap(groups) {
+  return Object.fromEntries(
+    groups.flatMap(([tags, enforcement]) => tags.map((tag) => [tag, enforcement]))
+  );
+}
+var htmlContracts = {
+  ...contractMap(CONTRACT_GROUPS),
+  table: tableContract,
+  tr: tableRowContract,
+  colgroup: colgroupContract,
+  dl: dlContract,
+  select: selectContract,
+  optgroup: optgroupContract,
+  datalist: datalistContract,
+  picture: pictureContract,
+  figure: figureContract,
+  details: detailsContract,
+  fieldset: fieldsetContract,
+  head: headContract,
+  html: htmlContract
+};
+var IMPLICIT_ROLE_RECORD2 = {
+  article: "article",
+  aside: "complementary",
+  footer: "contentinfo",
+  header: "banner",
+  main: "main",
+  nav: "navigation",
+  button: "button",
+  a: "link",
+  select: "listbox",
+  h1: "heading",
+  h2: "heading",
+  h3: "heading",
+  h4: "heading",
+  h5: "heading",
+  h6: "heading",
+  ul: "list",
+  ol: "list",
+  li: "listitem",
+  table: "table",
+  tr: "row",
+  td: "cell",
+  th: "columnheader"
+};
+function getImplicitRole(tag) {
+  if (tag in IMPLICIT_ROLE_RECORD2) return IMPLICIT_ROLE_RECORD2[tag];
+  return void 0;
+}
+var pendingAsyncWarns2 = /* @__PURE__ */ new Set();
+var asyncWarnScheduled2 = false;
+function flushAsyncWarns2() {
+  asyncWarnScheduled2 = false;
+  const messages = [...pendingAsyncWarns2];
+  pendingAsyncWarns2.clear();
+  for (const msg of messages) {
+    console.warn(msg);
+  }
+}
+function scheduleAsyncWarn(message) {
+  if (pendingAsyncWarns2.has(message)) return;
+  pendingAsyncWarns2.add(message);
+  if (!asyncWarnScheduled2) {
+    asyncWarnScheduled2 = true;
+    queueMicrotask(flushAsyncWarns2);
+  }
+}
+var StrictBase = class {
+  strict;
+  constructor(strict) {
+    this.strict = strict;
+  }
+  violate(message) {
+    if (this.strict === true || this.strict === "throw") {
+      throw new Error(message);
+    }
+    this.warn(message);
+  }
+  // Always caps at console.warn — never throws. ARIA 'warning' violations route here
+  // so they surface even in strict='throw' mode without aborting a render.
+  warn(message) {
+    if (!this.strict) return;
+    if (this.strict === "async-warn") {
+      scheduleAsyncWarn(message);
+      return;
+    }
+    console.warn(message);
+  }
+  invariant(condition, message) {
+    if (!condition) {
+      this.violate(message);
+    }
+  }
+};
+function isNull2(value) {
+  return value === null;
+}
+var VALID = [{ valid: true }];
+function isIntrinsicTag(tag) {
+  return isString(tag);
+}
+function omitProp(obj, key) {
+  const { [key]: _, ...rest } = obj;
+  return rest;
+}
+var AriaPolicyEngine = class _AriaPolicyEngine extends StrictBase {
+  #extraRules;
+  #planCache = /* @__PURE__ */ new Map();
+  static #MAX_CACHE = 100;
+  // Memoized AriaFix objects keyed by attribute name — the ARIA attribute set is
+  // finite so this Map is bounded and avoids recreating closures on every cache miss.
+  static #removeAttributeFixCache = /* @__PURE__ */ new Map();
+  constructor(strict = "warn", options) {
+    super(strict);
+    this.#extraRules = options?.rules ?? [];
+  }
+  static #normalizeEmptyRole(tag, props) {
+    if (props.role !== "") return { normalized: false };
+    return {
+      normalized: true,
+      result: {
+        props: omitProp(props, "role"),
+        violations: [
+          {
+            message: `<${tag}> has an explicit empty role="". Omit the attribute instead.`,
+            tag,
+            role: "",
+            attribute: void 0,
+            severity: "warning",
+            phase: "evaluate"
+          }
+        ]
+      }
+    };
+  }
+  static #deriveContext(tag, props) {
+    if (!isIntrinsicTag(tag)) return { proceed: false, result: { props, violations: [] } };
+    const implicitRole = getImplicitRole(tag);
+    const hasExplicitLiveRole = !implicitRole && _AriaPolicyEngine.#LIVE_REGION_ROLES.has(props.role ?? "");
+    if (!implicitRole && !hasExplicitLiveRole)
+      return { proceed: false, result: { props, violations: [] } };
+    const normalized = _AriaPolicyEngine.#normalizeEmptyRole(tag, props);
+    if (normalized.normalized) return { proceed: false, result: normalized.result };
+    const effectiveRole = props.role ?? implicitRole;
+    return {
+      proceed: true,
+      tag,
+      implicitRole,
+      effectiveRole,
+      context: { tag, props, implicitRole, effectiveRole }
+    };
+  }
+  static #runRules(rules, context) {
+    const violations = [];
+    const fixes = [];
+    for (const rule of rules) {
+      for (const result of rule(context)) {
+        if (!result.valid) {
+          violations.push({
+            message: result.message ?? `Invalid role "${context.props.role}" on <${context.tag}>`,
+            tag: context.tag,
+            role: context.props.role,
+            attribute: result.attribute,
+            severity: result.severity,
+            phase: "evaluate"
+          });
+          if (result.fixable) fixes.push(result.fix);
+        }
+      }
+    }
+    return { violations, fixes };
+  }
+  static #getRules(context) {
+    return _AriaPolicyEngine.#hasRole(context.props) ? _AriaPolicyEngine.#pipeline : [_AriaPolicyEngine.#checkInvalidAriaAttributes];
+  }
+  static evaluate(tag, props) {
+    const derived = _AriaPolicyEngine.#deriveContext(tag, props);
+    if (!derived.proceed) return derived.result;
+    const { tag: narrowedTag, implicitRole, context } = derived;
+    const { violations, fixes } = _AriaPolicyEngine.#runRules(
+      _AriaPolicyEngine.#getRules(context),
+      context
+    );
+    const next = _AriaPolicyEngine.#applyFixes(narrowedTag, implicitRole, props, fixes);
+    return { props: next, violations };
+  }
+  static #evaluateWithRules(tag, props, extraRules) {
+    const derived = _AriaPolicyEngine.#deriveContext(tag, props);
+    if (!derived.proceed) return derived.result;
+    const { tag: narrowedTag, implicitRole, context } = derived;
+    const { violations, fixes } = _AriaPolicyEngine.#runRules(
+      [..._AriaPolicyEngine.#getRules(context), ...extraRules],
+      context
+    );
+    const next = _AriaPolicyEngine.#applyFixes(narrowedTag, implicitRole, props, fixes);
+    return { props: next, violations };
+  }
+  report(violations) {
+    for (const v of violations) {
+      if (v.severity === "error") this.violate(v.message);
+      else this.warn(v.message);
+    }
+  }
+  // Cache key covers only the aria-relevant subset of props (tag + role + aria-* attrs).
+  // Non-aria props (className, onClick, etc.) do not affect ARIA decisions and are excluded
+  // so cache hits survive re-renders that only change non-aria props.
+  // Note: #extraRules are NOT included in the key — each engine instance has its own Map,
+  // so two engines with different rules never share cache entries. If caching ever becomes
+  // static/shared, rule identity would need to be folded into the key.
+  static #createPlanKey(tag, props) {
+    if (!isIntrinsicTag(tag)) return null;
+    const parts = [tag];
+    if (typeof props.role === "string") parts.push(`role:${props.role}`);
+    const ariaEntries = [];
+    for (const k in props) {
+      if (!Object.hasOwn(props, k) || !k.startsWith("aria-")) continue;
+      const v = props[k];
+      if (!isString(v) && !isNumber(v) && typeof v !== "boolean") continue;
+      ariaEntries.push(`${k}:${String(v)}`);
+    }
+    if (ariaEntries.length > 0) parts.push(...ariaEntries.sort());
+    return parts.join("|");
+  }
+  static #computePlan(inputProps, resultProps) {
+    const removals = /* @__PURE__ */ new Set();
+    const updates = {};
+    for (const key in inputProps) {
+      if (Object.hasOwn(inputProps, key) && !(key in resultProps)) removals.add(key);
+    }
+    for (const key in resultProps) {
+      if (!Object.hasOwn(resultProps, key)) continue;
+      const resultVal = resultProps[key];
+      if (inputProps[key] !== resultVal) updates[key] = resultVal;
+    }
+    return { removals, updates };
+  }
+  static #applyPlan(props, removals, updates) {
+    const hasRemovals = removals.size > 0;
+    const hasUpdates = Object.keys(updates).length > 0;
+    if (!hasRemovals && !hasUpdates) return props;
+    const next = {};
+    for (const k in props) {
+      if (Object.hasOwn(props, k) && !removals.has(k)) next[k] = props[k];
+    }
+    Object.assign(next, updates);
+    return next;
+  }
+  validate(tag, props) {
+    const key = _AriaPolicyEngine.#createPlanKey(tag, props);
+    if (!isNull2(key)) {
+      const cached = this.#planCache.get(key);
+      if (cached !== void 0) {
+        this.#planCache.delete(key);
+        this.#planCache.set(key, cached);
+        if (cached.violations.length > 0) this.report(cached.violations);
+        return {
+          props: _AriaPolicyEngine.#applyPlan(props, cached.removals, cached.updates),
+          violations: cached.violations
+        };
+      }
+    }
+    const result = this.#extraRules.length ? _AriaPolicyEngine.#evaluateWithRules(tag, props, this.#extraRules) : _AriaPolicyEngine.evaluate(tag, props);
+    if (result.violations.length > 0) this.report(result.violations);
+    if (!isNull2(key)) {
+      const { removals, updates } = _AriaPolicyEngine.#computePlan(
+        props,
+        result.props
+      );
+      const plan = { removals, updates, violations: result.violations };
+      this.#planCache.set(key, plan);
+      if (this.#planCache.size > _AriaPolicyEngine.#MAX_CACHE) {
+        const lru = this.#planCache.keys().next().value;
+        if (lru !== void 0) this.#planCache.delete(lru);
+      }
+    }
+    return result;
+  }
+  static #hasRole(props) {
+    return isString(props.role) && props.role.length > 0;
+  }
+  static #applyFixes(tag, implicitRole, props, fixes) {
+    if (fixes.length === 0) return props;
+    const sorted = [...fixes].sort((a, b) => (a.priority ?? Infinity) - (b.priority ?? Infinity));
+    let next = props;
+    for (const { apply } of sorted) {
+      const effectiveRole = next.role ?? implicitRole;
+      const fixContext = { tag, implicitRole, effectiveRole, props: next };
+      const fixResult = apply(fixContext);
+      if (fixResult.applied) next = fixResult.next;
+    }
+    return next;
+  }
+  static #removeRole = {
+    kind: "removeRole",
+    apply: ({ props }) => {
+      if (!("role" in props)) return { applied: false, next: props };
+      return { applied: true, next: omitProp(props, "role"), previous: props };
+    }
+  };
+  static #makeRemoveAttributeFix(attr) {
+    const cached = _AriaPolicyEngine.#removeAttributeFixCache.get(attr);
+    if (cached) return cached;
+    const fix = {
+      kind: `removeAttribute:${attr}`,
+      apply: ({ props }) => {
+        if (!(attr in props)) return { applied: false, next: props };
+        return { applied: true, next: omitProp(props, attr), previous: props };
+      }
+    };
+    _AriaPolicyEngine.#removeAttributeFixCache.set(attr, fix);
+    return fix;
+  }
+  // Snapshot diagnostic model: all rules evaluate against the same (tag, props, implicitRole) snapshot.
+  static #pipeline = [
+    _AriaPolicyEngine.#checkInvalidRoleOverride,
+    _AriaPolicyEngine.#checkRedundantRole,
+    _AriaPolicyEngine.#checkStandaloneRegion,
+    _AriaPolicyEngine.#checkInvalidAriaAttributes,
+    _AriaPolicyEngine.#checkMissingLiveRegion,
+    _AriaPolicyEngine.#checkMissingAtomic,
+    _AriaPolicyEngine.#checkInvalidAriaRelevant
+  ];
+  static #checkInvalidRoleOverride({
+    tag,
+    props,
+    implicitRole
+  }) {
+    const role = props.role;
+    if (!implicitRole || !role || role === implicitRole) return VALID;
+    if (isStrongImplicitRole(tag) && role === "region") {
+      return [
+        {
+          valid: false,
+          fixable: true,
+          severity: "error",
+          fix: _AriaPolicyEngine.#removeRole,
+          message: `<${tag}> should not override its implicit role="${implicitRole}" with role="${role}".`
+        }
+      ];
+    }
+    return VALID;
+  }
+  static #checkRedundantRole({ tag, props, implicitRole }) {
+    const role = props.role;
+    if (!implicitRole || !role || role !== implicitRole) return VALID;
+    return [
+      {
+        valid: false,
+        fixable: true,
+        severity: "warning",
+        fix: _AriaPolicyEngine.#removeRole,
+        message: `<${tag}> already has implicit role="${implicitRole}". Avoid redundant role assignment.`
+      }
+    ];
+  }
+  static #checkStandaloneRegion({ tag, props, implicitRole }) {
+    const role = props.role;
+    if (role !== "region") return VALID;
+    if (!isStandaloneTag(tag)) return VALID;
+    return [
+      {
+        valid: false,
+        fixable: true,
+        severity: "error",
+        fix: _AriaPolicyEngine.#removeRole,
+        message: `<${tag}> is a self-contained element with implicit role="${implicitRole}". Assigning role="region" has been removed.`
+      }
+    ];
+  }
+  static #checkInvalidAriaAttributes({
+    tag,
+    props,
+    effectiveRole
+  }) {
+    const results = [];
+    for (const key in props) {
+      if (!Object.hasOwn(props, key)) continue;
+      if (!key.startsWith("aria-")) continue;
+      if (isGlobalAriaAttribute(key)) continue;
+      if (isAriaAttributeValidForRole(key, effectiveRole)) continue;
+      results.push({
+        valid: false,
+        severity: "warning",
+        fixable: true,
+        attribute: key,
+        message: `"${key}" is not valid on role="${effectiveRole ?? tag}". It will be removed.`,
+        fix: _AriaPolicyEngine.#makeRemoveAttributeFix(key)
+      });
+    }
+    return results;
+  }
+  // WAI-ARIA live region roles and their implied aria-live politeness values.
+  static #LIVE_REGION_ROLES = /* @__PURE__ */ new Map([
+    ["alert", "assertive"],
+    ["status", "polite"],
+    ["log", "polite"],
+    ["timer", "off"]
+  ]);
+  static #checkMissingLiveRegion({ effectiveRole, props }) {
+    if (!effectiveRole) return VALID;
+    const impliedLive = _AriaPolicyEngine.#LIVE_REGION_ROLES.get(effectiveRole);
+    if (!impliedLive) return VALID;
+    if ("aria-live" in props) return VALID;
+    const injectLive = {
+      kind: `injectLive:${effectiveRole}`,
+      apply: (ctx) => ({
+        applied: true,
+        next: { ...ctx.props, "aria-live": impliedLive },
+        previous: ctx.props
+      })
+    };
+    return [
+      {
+        valid: false,
+        fixable: true,
+        severity: "warning",
+        fix: injectLive,
+        message: `role="${effectiveRole}" implies aria-live="${impliedLive}" but it is missing. It has been injected.`
+      }
+    ];
+  }
+  static #checkMissingAtomic({ effectiveRole, props }) {
+    if (!effectiveRole || !_AriaPolicyEngine.#LIVE_REGION_ROLES.has(effectiveRole)) return VALID;
+    if ("aria-atomic" in props) return VALID;
+    return [
+      {
+        valid: false,
+        fixable: false,
+        severity: "warning",
+        message: `role="${effectiveRole}" is a live region. Consider setting aria-atomic="true" if the full region should be announced as a unit, or aria-atomic="false" if only changed nodes should be read.`
+      }
+    ];
+  }
+  static #VALID_RELEVANT_TOKENS = /* @__PURE__ */ new Set(["additions", "removals", "text", "all"]);
+  // Custom fix rules passed via `options.rules` must be pure functions of (tag, props) — the cache
+  // replays stored fixes against new prop objects, so fixes that close over external state will
+  // produce inconsistent results on cache hits.
+  static #normalizeRelevantAllFix = {
+    kind: "normalizeRelevantAll",
+    apply: ({ props: p }) => ({
+      applied: true,
+      next: { ...p, "aria-relevant": "all" },
+      previous: p
+    })
+  };
+  static #checkInvalidAriaRelevant({ props }) {
+    const relevant = props["aria-relevant"];
+    if (relevant === void 0) return VALID;
+    if (typeof relevant !== "string") return VALID;
+    const tokens = relevant.trim().split(/\s+/);
+    const invalid = tokens.filter((t) => !_AriaPolicyEngine.#VALID_RELEVANT_TOKENS.has(t));
+    if (invalid.length > 0) {
+      return [
+        {
+          valid: false,
+          fixable: true,
+          severity: "warning",
+          attribute: "aria-relevant",
+          message: `aria-relevant contains invalid token(s): ${invalid.map((t) => `"${t}"`).join(", ")}. Valid tokens are: additions, removals, text, all.`,
+          fix: _AriaPolicyEngine.#makeRemoveAttributeFix("aria-relevant")
+        }
+      ];
+    }
+    if (tokens.includes("all") && tokens.length > 1) {
+      return [
+        {
+          valid: false,
+          fixable: true,
+          severity: "warning",
+          attribute: "aria-relevant",
+          message: `aria-relevant includes "all" alongside other tokens. "all" supersedes additions, removals, and text \u2014 use aria-relevant="all" alone.`,
+          fix: _AriaPolicyEngine.#normalizeRelevantAllFix
+        }
+      ];
+    }
+    return VALID;
+  }
+};
+function getTypeName(value) {
+  if (value === null) return "null";
+  if (value === void 0) return "undefined";
+  const primitive = typeof value;
+  if (primitive !== "object") {
+    return primitive;
+  }
+  const name = value.constructor?.name;
+  return typeof name === "string" && name !== "Object" ? name : "object";
+}
+var MatchValidationErrorBuilder = class {
+  #prefix;
+  constructor(ctx = "") {
+    this.#prefix = ctx ? `${ctx}:
+` : "";
+  }
+  #template(typeName, index, prefix = "", suffix = "") {
+    const leadingStr = prefix ? `${prefix} ` : "";
+    const followingStr = suffix ? ` ${suffix}` : "";
+    return `${leadingStr}child "${typeName}" at index ${index}${followingStr}.`;
+  }
+  unexpectedChild(typeName, index) {
+    return this.#template(typeName, index, "unexpected");
+  }
+  multipleMatches(typeName, index, ruleNames) {
+    const quoted = ruleNames.map((n) => `"${n}"`);
+    return this.#template(
+      typeName,
+      index,
+      "",
+      `matches multiple child rules: ${quoted.join(" and ")}`
+    );
+  }
+  #format(errors) {
+    return this.#prefix + errors.join("\n");
+  }
+  toError(errors) {
+    if (errors.length === 0) {
+      return new Error(this.#prefix + "Unknown validation error.");
+    }
+    return new Error(this.#format(errors));
+  }
+};
+function normalizeCardinality(input, impliesSingleton) {
+  const min = input?.min ?? 0;
+  const max = input?.max ?? (impliesSingleton ? 1 : Infinity);
+  if (min === 0 && max === Infinity) {
+    return { kind: "unbounded" };
+  }
+  if (min > max) {
+    throw new RangeError(`normalizeChildRule: min (${min}) cannot exceed max (${max})`);
+  }
+  return {
+    kind: "bounded",
+    min,
+    max
+  };
+}
+function normalizeChildRule(rule) {
+  const position = rule.position ?? "any";
+  const impliesSingleton = position === "first" || position === "last";
+  return {
+    ...rule,
+    position,
+    cardinality: normalizeCardinality(rule.cardinality, impliesSingleton)
+  };
+}
+function getChildType(child) {
+  if (!isObject(child) || !("type" in child)) return void 0;
+  return child.type;
+}
+function buildPartialIndex(rules) {
+  const typeIndex = /* @__PURE__ */ new Map();
+  const duplicateTypes = /* @__PURE__ */ new Set();
+  const untypedIndices = [];
+  for (let ri = 0; ri < rules.length; ri++) {
+    const t = rules[ri].type;
+    if (t === void 0) {
+      untypedIndices.push(ri);
+    } else if (typeIndex.has(t)) {
+      duplicateTypes.add(t);
+    } else {
+      typeIndex.set(t, ri);
+    }
+  }
+  if (duplicateTypes.size > 0) {
+    for (const t of duplicateTypes) typeIndex.delete(t);
+    for (let ri = 0; ri < rules.length; ri++) {
+      if (duplicateTypes.has(rules[ri].type)) untypedIndices.push(ri);
+    }
+  }
+  return { typeIndex, untypedIndices };
+}
+var RuleMatcher = class {
+  #rules;
+  #typeIndex;
+  #untypedIndices;
+  constructor(rules) {
+    this.#rules = rules;
+    const { typeIndex, untypedIndices } = buildPartialIndex(rules);
+    this.#typeIndex = typeIndex;
+    this.#untypedIndices = untypedIndices;
+  }
+  match(children) {
+    const forward = /* @__PURE__ */ new Map();
+    const reverse = /* @__PURE__ */ new Map();
+    const unexpectedIndices = /* @__PURE__ */ new Set();
+    const ambiguousIndices = /* @__PURE__ */ new Set();
+    for (let ri = 0; ri < this.#rules.length; ri++) {
+      reverse.set(ri, /* @__PURE__ */ new Set());
+    }
+    for (const [ci, child] of children.entries()) {
+      const t = getChildType(child);
+      if (t !== void 0) {
+        const ri = this.#typeIndex.get(t);
+        if (ri !== void 0) {
+          let childEntry = forward.get(ci);
+          if (!childEntry) {
+            childEntry = /* @__PURE__ */ new Set();
+            forward.set(ci, childEntry);
+          }
+          childEntry.add(ri);
+          reverse.get(ri).add(ci);
+        }
+      }
+      for (const ri of this.#untypedIndices) {
+        if (!this.#rules[ri].match(child)) continue;
+        let childEntry = forward.get(ci);
+        if (!childEntry) {
+          childEntry = /* @__PURE__ */ new Set();
+          forward.set(ci, childEntry);
+        }
+        childEntry.add(ri);
+        reverse.get(ri).add(ci);
+      }
+      const entry = forward.get(ci);
+      if (!entry) {
+        unexpectedIndices.add(ci);
+      } else if (entry.size > 1) {
+        ambiguousIndices.add(ci);
+      }
+    }
+    return { matrix: { childToRules: { forward, reverse } }, unexpectedIndices, ambiguousIndices };
+  }
+};
+var RuleValidator = class _RuleValidator extends StrictBase {
+  #context;
+  constructor(context, strict) {
+    super(strict);
+    this.#context = context;
+  }
+  validate(rules, matrix, childCount) {
+    const firstIndex = 0;
+    const lastIndex = childCount - 1;
+    for (const [ri, rule] of rules.entries()) {
+      const matches = matrix.childToRules.reverse.get(ri);
+      const matchCount = matches.size;
+      this.#validateCardinality(rule, matchCount);
+      if (matchCount === 0) continue;
+      this.#validatePositions(rule, matches, firstIndex, lastIndex);
+    }
+  }
+  #validateCardinality(rule, matchCount) {
+    const { cardinality, name } = rule;
+    if (cardinality.kind !== "bounded") {
+      return;
+    }
+    const { min, max } = cardinality;
+    if (matchCount < min) {
+      this.violate(`${this.#context}: "${name}" requires at least ${min}.`);
+      return;
+    }
+    if (matchCount > max) {
+      this.violate(`${this.#context}: "${name}" allows at most ${max}.`);
+    }
+  }
+  #validatePositions(rule, matches, firstIndex, lastIndex) {
+    const { name, position } = rule;
+    for (const index of matches) {
+      if (_RuleValidator.#isValidPosition(index, position, firstIndex, lastIndex)) {
+        continue;
+      }
+      this.violate(`${this.#context}: "${name}" must be ${position}, got index ${index}`);
+    }
+  }
+  static #isValidPosition(matchIndex, position, firstIndex, lastIndex) {
+    switch (position) {
+      case "first":
+        return matchIndex === firstIndex;
+      case "last":
+        return matchIndex === lastIndex;
+      case "any":
+        return true;
+      default:
+        return assertNever(position);
+    }
+  }
+};
+var ChildrenEvaluator = class extends StrictBase {
+  #rules;
+  #ruleNames;
+  #matcher;
+  #ruleValidator;
+  #matchBuilder;
+  constructor(rules, strict = "warn", context = "Component") {
+    super(strict);
+    this.#rules = rules.map((r2) => normalizeChildRule(r2));
+    this.#ruleNames = this.#rules.map((r2) => r2.name);
+    for (const rule of this.#rules) {
+      const { name, position, cardinality } = rule;
+      if ((position === "first" || position === "last") && (cardinality.kind === "unbounded" || cardinality.max > 1)) {
+        throw new RangeError(
+          `ChildrenEvaluator [${context}]: rule "${name}" sets position="${position}" with an unbound or >1 max. position="first|last" implies max=1.`
+        );
+      }
+    }
+    this.#matcher = new RuleMatcher(this.#rules);
+    this.#ruleValidator = new RuleValidator(context, strict);
+    this.#matchBuilder = new MatchValidationErrorBuilder(context);
+  }
+  evaluate(children) {
+    if (!this.strict) return;
+    const { matrix, unexpectedIndices, ambiguousIndices } = this.#matcher.match(children);
+    this.#ruleValidator.validate(this.#rules, matrix, children.length);
+    if (unexpectedIndices.size === 0 && ambiguousIndices.size === 0) return;
+    const errors = [];
+    const violating = [...unexpectedIndices, ...ambiguousIndices].sort((a, b) => a - b);
+    for (const ci of violating) {
+      const typeName = getTypeName(children[ci]);
+      if (unexpectedIndices.has(ci)) {
+        errors.push(this.#matchBuilder.unexpectedChild(typeName, ci));
+      } else {
+        const matches = matrix.childToRules.forward.get(ci);
+        const names = [...matches].map((ri) => this.#ruleNames[ri] ?? `#${ri}`);
+        errors.push(this.#matchBuilder.multipleMatches(typeName, ci, names));
+      }
+    }
+    this.invariant(errors.length === 0, this.#matchBuilder.toError(errors).message);
+  }
+};
+var disabledProps = ({
+  disabled,
+  "aria-disabled": ariaDisabled,
+  "data-disabled": dataDisabled
+}) => {
+  if (!disabled) return {};
+  return {
+    ...ariaDisabled === void 0 && { "aria-disabled": "true" },
+    ...dataDisabled === void 0 && { "data-disabled": "" }
+  };
+};
+var invalidProps = ({
+  invalid,
+  "aria-invalid": ariaInvalid,
+  "data-invalid": dataInvalid
+}) => {
+  if (!invalid) return {};
+  return {
+    ...ariaInvalid === void 0 && { "aria-invalid": "true" },
+    ...dataInvalid === void 0 && { "data-invalid": "" }
+  };
+};
+
+// ../core/dist/chunk-RHOMAG5Q.js
+var falsyToString = (value) => typeof value === "boolean" ? `${value}` : value === 0 ? "0" : value;
+var cx = clsx;
+var cva = (base, config) => (props) => {
+  var _config_compoundVariants;
+  if ((config === null || config === void 0 ? void 0 : config.variants) == null) return cx(base, props === null || props === void 0 ? void 0 : props.class, props === null || props === void 0 ? void 0 : props.className);
+  const { variants, defaultVariants } = config;
+  const getVariantClassNames = Object.keys(variants).map((variant) => {
+    const variantProp = props === null || props === void 0 ? void 0 : props[variant];
+    const defaultVariantProp = defaultVariants === null || defaultVariants === void 0 ? void 0 : defaultVariants[variant];
+    if (variantProp === null) return null;
+    const variantKey = falsyToString(variantProp) || falsyToString(defaultVariantProp);
+    return variants[variant][variantKey];
+  });
+  const propsWithoutUndefined = props && Object.entries(props).reduce((acc, param) => {
+    let [key, value] = param;
+    if (value === void 0) {
+      return acc;
+    }
+    acc[key] = value;
+    return acc;
+  }, {});
+  const getCompoundVariantClassNames = config === null || config === void 0 ? void 0 : (_config_compoundVariants = config.compoundVariants) === null || _config_compoundVariants === void 0 ? void 0 : _config_compoundVariants.reduce((acc, param) => {
+    let { class: cvClass, className: cvClassName, ...compoundVariantOptions } = param;
+    return Object.entries(compoundVariantOptions).every((param2) => {
+      let [key, value] = param2;
+      return Array.isArray(value) ? value.includes({
+        ...defaultVariants,
+        ...propsWithoutUndefined
+      }[key]) : {
+        ...defaultVariants,
+        ...propsWithoutUndefined
+      }[key] === value;
+    }) ? [
+      ...acc,
+      cvClass,
+      cvClassName
+    ] : acc;
+  }, []);
+  return cx(base, getVariantClassNames, getCompoundVariantClassNames, props === null || props === void 0 ? void 0 : props.class, props === null || props === void 0 ? void 0 : props.className);
+};
+function cva2(base, config) {
+  const fn = cva(base, config);
+  return (props) => cn(fn(props));
+}
+var StaticClassResolver = class {
+  #baseClass;
+  #cache = /* @__PURE__ */ new Map();
+  #resolveTag;
+  constructor(baseClass, tagMap) {
+    this.#baseClass = Array.isArray(baseClass) ? baseClass.join(" ") : baseClass;
+    this.#resolveTag = tagMap ? (tag) => {
+      const extra = tagMap[tag];
+      if (!extra) return this.#baseClass;
+      const extraStr = Array.isArray(extra) ? extra.join(" ") : extra;
+      return `${this.#baseClass} ${extraStr}`;
+    } : () => this.#baseClass;
+  }
+  resolve(tag, skipTagMap = false) {
+    if (typeof tag !== "string" || skipTagMap) return this.#baseClass;
+    const cached = this.#cache.get(tag);
+    if (cached !== void 0) {
+      this.#cache.delete(tag);
+      this.#cache.set(tag, cached);
+      return cached;
+    }
+    const result = this.#resolveTag(tag);
+    this.#cache.set(tag, result);
+    if (this.#cache.size > 200) {
+      const lru = this.#cache.keys().next().value;
+      if (lru !== void 0) this.#cache.delete(lru);
+    }
+    return result;
+  }
+};
+var VariantClassResolver = class _VariantClassResolver {
+  #cvaFn;
+  #presetMap;
+  #variantKeys;
+  #precomputedClasses;
+  #cache = /* @__PURE__ */ new Map();
+  constructor(cvaFn, presetMap, variantKeys, precomputedClasses) {
+    this.#cvaFn = cvaFn ?? null;
+    this.#presetMap = Object.freeze(presetMap ?? {});
+    this.#variantKeys = variantKeys ?? null;
+    this.#precomputedClasses = precomputedClasses ?? null;
+  }
+  resolve({ props, variantKey }) {
+    const normalizedKey = variantKey ?? "__none__";
+    const cacheKey = this.#createCacheKey(props, normalizedKey);
+    if (this.#precomputedClasses !== null) {
+      const precomputed = this.#precomputedClasses[cacheKey];
+      if (precomputed !== void 0) return precomputed;
+    }
+    const cached = this.#cache.get(cacheKey);
+    if (cached !== void 0) {
+      this.#cache.delete(cacheKey);
+      this.#cache.set(cacheKey, cached);
+      return cached;
+    }
+    const result = this.#compute(props, variantKey);
+    this.#cache.set(cacheKey, result);
+    if (this.#cache.size > 1e3) {
+      const lru = this.#cache.keys().next().value;
+      if (lru !== void 0) this.#cache.delete(lru);
+    }
+    return result;
+  }
+  #compute(props, variantKey) {
+    if (!this.#cvaFn) return "";
+    if (!variantKey) return this.#cvaFn(props);
+    const preset = this.#presetMap[variantKey];
+    if (!preset) return this.#cvaFn(props);
+    return this.#cvaFn({ ...preset, ...props });
+  }
+  // When variantKeys is provided, only those keys are included in the cache key — non-variant
+  // props (className, id, etc.) produce identical CVA output and must not fragment the cache.
+  // Iterating #variantKeys directly (fixed Set insertion order) avoids Object.keys + filter + sort.
+  // String is built incrementally to avoid a parts[] array allocation on every render.
+  #createCacheKey(props, variantKey) {
+    if (this.#variantKeys !== null) {
+      let key2 = variantKey;
+      for (const k of this.#variantKeys) {
+        if (k in props) key2 += `|${k}:${_VariantClassResolver.#serializeValue(props[k])}`;
+      }
+      return key2;
+    }
+    let key = variantKey;
+    for (const k of Object.keys(props).sort()) {
+      key += `|${k}:${_VariantClassResolver.#serializeValue(props[k])}`;
+    }
+    return key;
+  }
+  static #serializeValue(value) {
+    if (value === void 0) return "u";
+    if (value === null) return "n";
+    if (typeof value === "boolean") return `b:${value}`;
+    if (typeof value === "string") return `s:${value}`;
+    return `x:${String(value)}`;
+  }
+};
+function createClassPipeline(resolved) {
+  const baseClass = resolved.baseClassName ?? "";
+  const cvaFn = resolved.variants ? cva2("", {
+    variants: resolved.variants,
+    defaultVariants: resolved.defaultVariants,
+    compoundVariants: resolved.compoundVariants
+  }) : null;
+  const variantKeys = resolved.variants ? new Set(Object.keys(resolved.variants)) : void 0;
+  const staticResolver = new StaticClassResolver(baseClass, resolved.tagMap);
+  const variantResolver = new VariantClassResolver(
+    cvaFn,
+    resolved.presetMap,
+    variantKeys,
+    resolved.precomputedClasses
+  );
+  return function resolveClasses(tag, props, className, variantKey) {
+    const staticClasses = staticResolver.resolve(tag, variantKey !== void 0);
+    const variantClasses = variantResolver.resolve({ props, variantKey });
+    if (!className)
+      return staticClasses && variantClasses ? `${staticClasses} ${variantClasses}` : staticClasses || variantClasses;
+    return cn(staticClasses, variantClasses, className);
+  };
+}
+
+// ../core/dist/index.js
+var FULL_CAPABILITIES = { createClassPipeline, AriaEngine: AriaPolicyEngine };
+function createPolymorphic2(options = {}) {
+  return createPolymorphic(options, FULL_CAPABILITIES);
+}
+
+// ../../lib/adapter-utils/src/build-core-runtime.ts
+var EMPTY_SET = /* @__PURE__ */ new Set();
+function buildCoreRuntime(normalized) {
+  const runtime = createPolymorphic2(normalized);
+  const ownedKeys = "classPlugin" in runtime ? runtime.classPlugin.ownedKeys ?? EMPTY_SET : EMPTY_SET;
+  return { runtime, ownedKeys };
+}
+
+// ../../lib/adapter-utils/src/build-engines.ts
+function buildEngines(strict, childRules, context) {
+  return childRules?.length ? { childrenEvaluator: new ChildrenEvaluator(childRules, strict, context) } : {};
+}
+
+// ../../lib/adapter-utils/src/compose-filter.ts
+function composeFilter(ownedKeys, filterProps) {
+  const defaultFilter = (key, variantKeys) => variantKeys.has(key) || ownedKeys.has(key);
+  if (!filterProps) {
+    return defaultFilter;
+  }
+  return (key, variantKeys) => defaultFilter(key, variantKeys) || filterProps(key, variantKeys);
+}
+
+// ../../lib/adapter-utils/src/resolve-adapter-common-options.ts
+function resolveAdapterCommonOptions(options, defaultName = "PolymorphicComponent", defaultStrict = "throw") {
+  return {
+    name: options.name ?? defaultName,
+    strict: options.enforcement?.strict ?? defaultStrict
+  };
+}
+
+// ../../lib/adapter-utils/src/slot-validator.ts
+var SlotValidator = class extends StrictBase {
+  #name;
+  #elementTerm;
+  constructor(name, strict, elementTerm) {
+    super(strict);
+    this.#name = name;
+    this.#elementTerm = elementTerm;
+  }
+  assertExclusive() {
+    this.violate(`${this.#name}: "as" and "asChild" are mutually exclusive`);
+  }
+  warnDiscardedChildren(count) {
+    const suffix = count === 1 ? "" : "ren";
+    this.warn(
+      `${this.#name}: asChild discarded ${count} non-element child${suffix} \u2014 only ${this.#elementTerm}s are valid asChild children.`
+    );
+  }
+  assertSingleChild(count) {
+    const msg = count === 0 ? `${this.#name}: asChild requires a ${this.#elementTerm} child` : `${this.#name}: asChild requires exactly one ${this.#elementTerm} child, got ${count}`;
+    this.violate(msg);
+  }
+};
+
+// ../../adapters/vue/src/slot/invariant.ts
+function panic2(message) {
+  throw new Error(message);
+}
+function invariant(condition, message) {
+  if (!condition) panic2(message);
+}
+
+// ../../adapters/vue/src/slot/slot-validator.ts
+var SlotValidator2 = class extends SlotValidator {
+  constructor(name, strict) {
+    super(name, strict, "VNode");
+  }
+};
+
+// ../../adapters/vue/src/slot/Slottable.ts
+import { defineComponent, h, Fragment } from "vue";
+var Slottable = defineComponent({
+  name: "Slottable",
+  setup(_, { slots }) {
+    return () => h(Fragment, null, slots.default?.());
+  }
+});
+
+// ../../adapters/vue/src/slot/extractSlottable.ts
+import { h as h2, Fragment as Fragment2 } from "vue";
+function isSlottableVNode(vnode) {
+  return vnode.type === Slottable;
+}
+function extractSlottable(children) {
+  const slottables = children.filter(isSlottableVNode);
+  invariant(slottables.length <= 1, "Slot: multiple Slottable children are not allowed");
+  if (slottables.length === 0) return null;
+  const [slottable] = slottables;
+  invariant(slottable !== void 0, "Slottable element is undefined");
+  const slots = slottable.children;
+  const defaultChildren = slots?.default?.() ?? [];
+  invariant(
+    defaultChildren.length === 1,
+    `Slottable expects exactly one VNode child, received ${defaultChildren.length}`
+  );
+  const child = defaultChildren[0];
+  invariant(child !== void 0, "Slottable child is undefined");
+  const index = children.indexOf(slottable);
+  return {
+    child,
+    rebuild(merged) {
+      const out = children.map((node, i) => i === index ? merged : node);
+      return h2(Fragment2, null, out);
+    }
+  };
+}
+
+// ../../adapters/vue/src/build-runtime.ts
+function normalizeOptions(options) {
+  return { ...options, ...resolveAdapterCommonOptions(options) };
+}
+function buildRuntime(options) {
+  const normalized = normalizeOptions(options);
+  const { runtime, ownedKeys } = buildCoreRuntime(normalized);
+  const slotValidator = new SlotValidator2(normalized.name, normalized.strict);
+  const { childrenEvaluator } = buildEngines(
+    normalized.strict,
+    normalized.enforcement?.children,
+    normalized.name
+  );
+  const filterProps = composeFilter(ownedKeys, normalized.filterProps);
+  return {
+    runtime,
+    slotValidator,
+    filterProps,
+    ...childrenEvaluator !== void 0 && { childrenEvaluator }
+  };
+}
+
+// ../../adapters/vue/src/render.ts
+import { cloneVNode, h as h3 } from "vue";
+
+// ../../adapters/vue/src/normalize-children.ts
+import { isVNode } from "vue";
+function normalizeChildren(slots) {
+  const raw = slots.default?.() ?? [];
+  const vnodes = raw.filter(isVNode);
+  return { vnodes, discarded: raw.length - vnodes.length };
+}
+
+// ../../adapters/vue/src/render.ts
+function buildDirectives(as, asChild) {
+  return {
+    ...as !== void 0 && { as },
+    ...asChild !== void 0 && { asChild }
+  };
+}
+function resolveRenderState(runtime, attrs, filterProps) {
+  const { as, asChild, class: className, variantKey, ...rest } = attrs;
+  const tag = runtime.resolveTag(as);
+  const mergedProps = runtime.resolveProps(rest);
+  const normalizedProps = runtime.options.normalizeFn ? runtime.options.normalizeFn(mergedProps) : mergedProps;
+  const resolvedClass = runtime.resolveClasses(
+    tag,
+    normalizedProps,
+    typeof className === "string" ? className : void 0,
+    typeof variantKey === "string" ? variantKey : void 0
+  );
+  const filteredProps = applyFilter(normalizedProps, filterProps, runtime.options.variantKeys);
+  return {
+    tag,
+    directives: buildDirectives(as, asChild),
+    className: resolvedClass,
+    props: filteredProps
+  };
+}
+function validateSlotDirectives(directives, validator) {
+  const { as, asChild } = directives;
+  if (!asChild) return false;
+  if (as !== void 0) {
+    validator.assertExclusive();
+    return false;
+  }
+  return true;
+}
+function tryRenderAsChild(state, children, discarded, validator) {
+  if (!validateSlotDirectives(state.directives, validator)) return null;
+  if (discarded > 0) validator.warnDiscardedChildren(discarded);
+  const extraction = extractSlottable(children);
+  if (extraction) {
+    const merged = cloneVNode(extraction.child, { ...state.props, class: state.className });
+    return extraction.rebuild(merged);
+  }
+  if (children.length === 1) {
+    const child = children[0];
+    if (child === void 0) return null;
+    return cloneVNode(child, { ...state.props, class: state.className });
+  }
+  validator.assertSingleChild(children.length);
+  return null;
+}
+var MULTI_WORD_EVENT_RE = /^on[A-Z][a-z]+[A-Z]/;
+function normalizeEventKeys(props) {
+  const out = {};
+  for (const k in props) {
+    out[MULTI_WORD_EVENT_RE.test(k) ? "on" + k.slice(2).toLowerCase() : k] = props[k];
+  }
+  return out;
+}
+function buildDomProps(runtime, props, className, tag) {
+  const { role, ...rest } = normalizeEventKeys(props);
+  const base = {
+    ...rest,
+    class: className,
+    ...isKnownAriaRole(role) && { role }
+  };
+  if (typeof tag !== "string") return base;
+  const validated = runtime.resolveAria(tag, base);
+  const {
+    className: _className,
+    ref: _ref,
+    children: _children,
+    ...validatedRest
+  } = validated.props;
+  return { ...validatedRest, class: className };
+}
+function render({
+  runtime,
+  attrs,
+  slots,
+  filterProps,
+  slotValidator,
+  childrenEvaluator,
+  resolvedState
+}) {
+  const state = resolvedState ?? resolveRenderState(runtime, attrs, filterProps);
+  const { vnodes: children, discarded } = normalizeChildren(slots);
+  if (process.env.NODE_ENV !== "production") childrenEvaluator?.evaluate(children);
+  const slotResult = tryRenderAsChild(state, children, discarded, slotValidator);
+  if (slotResult !== null) return slotResult;
+  const domProps = buildDomProps(runtime, state.props, state.className, state.tag);
+  return h3(state.tag, domProps, slots.default ? { default: slots.default } : void 0);
+}
+
+// ../../adapters/vue/src/create-contract-component.ts
+function createContractComponent(options) {
+  const bundle = buildRuntime(options);
+  const Component = defineComponent2({
+    name: options.name ?? "PolymorphicComponent",
+    // Without inheritAttrs: false Vue would double-bind attrs onto the root element
+    // before our render pipeline has a chance to filter, transform, and re-apply them.
+    inheritAttrs: false,
+    setup(_, { attrs, slots }) {
+      const resolvedState = computed(
+        () => resolveRenderState(bundle.runtime, attrs, bundle.filterProps)
+      );
+      return () => render({ ...bundle, attrs, slots, resolvedState: resolvedState.value });
+    }
+  });
+  applyDisplayName(Component, options.name);
+  if (typeof bundle.runtime.options.defaultTag === "string") {
+    Object.assign(Component, { [COMPONENT_DEFAULT_TAG]: bundle.runtime.options.defaultTag });
+  }
+  return Component;
+}
+
+// ../../adapters/vue/src/define-contract-component.ts
+function defineContractComponent(options) {
+  return (factory) => factory(options);
+}
+export {
+  Slottable,
+  createContractComponent,
+  defineContractComponent,
+  disabledProps,
+  invalidProps
+};