praxis-kit 3.1.1 → 4.0.0

package/dist/chunk-6RJN5B6L.js

@@ -1,2221 +0,0 @@
-// ../../lib/adapter-utils/src/define-component.ts
-function defineContractComponent(options) {
-  return (factory) => factory(options);
-}
-
-// ../../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-KKSHJDE7.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("recipeMap", 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 { recipeMap } = resolved;
-  if (recipeMap) {
-    for (const recipeKey in recipeMap) {
-      checkSelection(`preset "${recipeKey}"`, recipeMap[recipeKey]);
-    }
-  }
-  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, recipeKey) {
-  const { strict, recipeMap, variants, displayName } = options;
-  if (!strict) return;
-  const tag = label(displayName);
-  if (recipeKey !== void 0 && (!recipeMap || !Object.hasOwn(recipeMap, recipeKey))) {
-    report2(strict, `${tag} Unknown recipeKey "${recipeKey}" \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, recipe) {
-    const result = pipeline(tag, props, className, recipe);
-    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, recipe) {
-      if (process.env.NODE_ENV !== "production") {
-        validateRenderProps(resolved, props, recipe);
-      }
-      return classPipeline(tag, props, className, recipe);
-    },
-    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 baseResolved = resolveFactoryOptions(options);
-  const resolved = capabilities?.htmlPropNormalizersFn !== void 0 ? Object.freeze({
-    ...baseResolved,
-    htmlPropNormalizersFn: capabilities.htmlPropNormalizersFn
-  }) : baseResolved;
-  if (process.env.NODE_ENV !== "production") validateFactoryOptions(resolved);
-  const { pluginResult, classPipeline } = resolveClassPipeline(
-    options,
-    resolved,
-    resolved.strict,
-    capabilities
-  );
-  const allAriaRules = [
-    .../* @__PURE__ */ new Set([...capabilities?.htmlAriaRules ?? [], ...resolved.ariaRules ?? []])
-  ];
-  const engine = options.enforcement !== void 0 && capabilities?.AriaEngine ? new capabilities.AriaEngine(
-    resolved.strict,
-    allAriaRules.length ? { rules: allAriaRules } : 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-2NJ5XLOA.js
-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 COMPONENT_DEFAULT_TAG = /* @__PURE__ */ Symbol.for("praxis.component-default-tag");
-function getAsProp(child) {
-  if (!isObject(child) || !("props" in child)) return void 0;
-  const props = child.props;
-  if (!isObject(props)) return void 0;
-  const as = props.as;
-  return isString(as) && as !== "" ? as : void 0;
-}
-function getTag(child) {
-  if (!isObject(child) || !("type" in child)) return void 0;
-  const t = child.type;
-  if (isString(t)) return t;
-  if (typeof t === "function" || isObject(t)) {
-    const defaultTag = t[COMPONENT_DEFAULT_TAG];
-    if (!isString(defaultTag)) return void 0;
-    return getAsProp(child) ?? defaultTag;
-  }
-  return void 0;
-}
-function isTag(...args) {
-  if (isString(args[0])) {
-    const set2 = new Set(args);
-    return (child2) => {
-      const tag2 = getTag(child2);
-      return tag2 !== void 0 && set2.has(tag2);
-    };
-  }
-  const [child, ...tags] = args;
-  const set = new Set(tags);
-  const tag = getTag(child);
-  return tag !== void 0 && set.has(tag);
-}
-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 activeProps = ({
-  active,
-  "aria-current": ariaCurrent,
-  "data-active": dataActive
-}) => {
-  if (!active) return {};
-  return {
-    ...ariaCurrent === void 0 && {
-      "aria-current": "true"
-    },
-    ...dataActive === void 0 && {
-      "data-active": ""
-    }
-  };
-};
-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 expandedProps = ({
-  expanded,
-  "aria-expanded": ariaExpanded,
-  "data-expanded": dataExpanded
-}) => {
-  if (!expanded) return {};
-  return {
-    ...ariaExpanded === void 0 && {
-      "aria-expanded": "true"
-    },
-    ...dataExpanded === void 0 && {
-      "data-expanded": ""
-    }
-  };
-};
-var invalidProps = ({
-  invalid,
-  "aria-invalid": ariaInvalid,
-  "data-invalid": dataInvalid
-}) => {
-  if (!invalid) return {};
-  return {
-    ...ariaInvalid === void 0 && { "aria-invalid": "true" },
-    ...dataInvalid === void 0 && { "data-invalid": "" }
-  };
-};
-var loadingProps = ({
-  loading,
-  "aria-busy": ariaBusy,
-  "data-loading": dataLoading
-}) => {
-  if (!loading) return {};
-  return {
-    ...ariaBusy === void 0 && {
-      "aria-busy": "true"
-    },
-    ...dataLoading === void 0 && {
-      "data-loading": ""
-    }
-  };
-};
-var pressedProps = ({
-  pressed,
-  "aria-pressed": ariaPressed,
-  "data-pressed": dataPressed
-}) => {
-  if (!pressed) return {};
-  return {
-    ...ariaPressed === void 0 && {
-      "aria-pressed": "true"
-    },
-    ...dataPressed === void 0 && {
-      "data-pressed": ""
-    }
-  };
-};
-var readonlyProps = ({
-  readOnly,
-  "aria-readonly": ariaReadonly,
-  "data-readonly": dataReadonly
-}) => {
-  if (!readOnly) return {};
-  return {
-    ...ariaReadonly === void 0 && {
-      "aria-readonly": "true"
-    },
-    ...dataReadonly === void 0 && {
-      "data-readonly": ""
-    }
-  };
-};
-var selectedProps = ({
-  selected,
-  "aria-selected": ariaSelected,
-  "data-selected": dataSelected
-}) => {
-  if (!selected) return {};
-  return {
-    ...ariaSelected === void 0 && {
-      "aria-selected": "true"
-    },
-    ...dataSelected === void 0 && {
-      "data-selected": ""
-    }
-  };
-};
-var LANDMARK_TAG_SET = /* @__PURE__ */ new Set(["article", "aside", "footer", "header", "main", "nav"]);
-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 HTML_ARIA_RULES = [landmarkRoleRule];
-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 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
-};
-function buildEvaluatorMap() {
-  const map = /* @__PURE__ */ new Map();
-  for (const [tag, { children }] of Object.entries(htmlContracts)) {
-    if (children?.length) {
-      map.set(tag, new ChildrenEvaluator(children, "warn", `<${tag}>`));
-    }
-  }
-  return map;
-}
-var HTML_EVALUATORS = buildEvaluatorMap();
-function getHtmlChildrenEvaluator(tag) {
-  return typeof tag === "string" ? HTML_EVALUATORS.get(tag) : void 0;
-}
-var HTML_FORM_NORMALIZERS = /* @__PURE__ */ new Map([
-  ["button", [disabledProps]],
-  ["input", [disabledProps, readonlyProps, invalidProps]],
-  ["select", [disabledProps]],
-  ["textarea", [disabledProps, readonlyProps]],
-  ["fieldset", [disabledProps]],
-  ["optgroup", [disabledProps]]
-]);
-function getHtmlPropNormalizers(tag) {
-  return typeof tag === "string" ? HTML_FORM_NORMALIZERS.get(tag) : void 0;
-}
-function enforceAllowedAs(tag, allowedAs, strict, displayName) {
-  if (allowedAs.includes(tag)) return;
-  const component = displayName ? `<${displayName}>` : "component";
-  const allowed = allowedAs.map((t) => `"${String(t)}"`).join(", ");
-  const message = `${component}: "as" prop received "${String(tag)}" but only [${allowed}] are allowed.`;
-  if (strict === true || strict === "throw") {
-    throw new Error(message);
-  }
-  if (strict) {
-    console.warn(message);
-  }
-}
-
-// ../core/dist/chunk-3T4EM5FG.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;
-  #recipeMap;
-  #variantKeys;
-  #precomputedClasses;
-  #cache = /* @__PURE__ */ new Map();
-  constructor(cvaFn, recipeMap, variantKeys, precomputedClasses) {
-    this.#cvaFn = cvaFn ?? null;
-    this.#recipeMap = Object.freeze(recipeMap ?? {});
-    this.#variantKeys = variantKeys ?? null;
-    this.#precomputedClasses = precomputedClasses ?? null;
-  }
-  resolve({ props, recipe }) {
-    const normalizedKey = recipe ?? "__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, recipe);
-    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, recipe) {
-    if (!this.#cvaFn) return "";
-    if (!recipe) return this.#cvaFn(props);
-    const preset = this.#recipeMap[recipe];
-    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, recipe) {
-    if (this.#variantKeys !== null) {
-      let key2 = recipe;
-      for (const k of this.#variantKeys) {
-        if (k in props) key2 += `|${k}:${_VariantClassResolver.#serializeValue(props[k])}`;
-      }
-      return key2;
-    }
-    let key = recipe;
-    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.recipeMap,
-    variantKeys,
-    resolved.precomputedClasses
-  );
-  return function resolveClasses(tag, props, className, recipe) {
-    const staticClasses = staticResolver.resolve(tag, recipe !== void 0);
-    const variantClasses = variantResolver.resolve({ props, recipe });
-    if (!className)
-      return staticClasses && variantClasses ? `${staticClasses} ${variantClasses}` : staticClasses || variantClasses;
-    return cn(staticClasses, variantClasses, className);
-  };
-}
-
-// ../core/dist/index.js
-var FULL_CAPABILITIES = {
-  createClassPipeline,
-  AriaEngine: AriaPolicyEngine,
-  htmlAriaRules: HTML_ARIA_RULES,
-  htmlPropNormalizersFn: getHtmlPropNormalizers
-};
-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);
-  }
-};
-
-// ../../lib/primitive/src/utils/is-object.ts
-function isNull3(value) {
-  return value === null;
-}
-function isObject2(value) {
-  return !isNull3(value) && typeof value === "object";
-}
-
-// ../../lib/primitive/src/merge/constants.ts
-var EVENT_HANDLER_RE = /^on[A-Z]/;
-
-// ../../lib/primitive/src/merge/predicates.ts
-function isFunction(value) {
-  return typeof value === "function";
-}
-function isPlainObject(value) {
-  if (!isObject2(value)) return false;
-  const proto = Object.getPrototypeOf(value);
-  return proto === Object.prototype || proto === null;
-}
-
-// ../shared/src/constants/primitive/slot-name.ts
-var SLOT_NAME = "Slot";
-
-// ../../lib/adapter-utils/src/slot/policies.ts
-import { clsx as clsx2 } from "clsx";
-function chainHandlers(childHandler, slotHandler) {
-  return (...args) => {
-    childHandler(...args);
-    const event = args[0];
-    if (!(typeof event === "object" && event !== null && "defaultPrevented" in event && event.defaultPrevented)) {
-      slotHandler(...args);
-    }
-  };
-}
-function mergeClassNames(slot, child) {
-  return clsx2(slot, child);
-}
-function mergeStyles(slot, child) {
-  if (!isPlainObject(slot) || !isPlainObject(child)) return child;
-  return { ...slot, ...child };
-}
-var policyHandlers = {
-  chain: (slotVal, childVal) => chainHandlers(childVal, slotVal),
-  concat: (slotVal, childVal) => mergeClassNames(slotVal, childVal),
-  "shallow-merge": (slotVal, childVal) => mergeStyles(slotVal, childVal),
-  "child-wins": (_slotVal, childVal) => childVal
-};
-
-// ../../lib/adapter-utils/src/slot/merge-slot-props.ts
-function mergeSlotProps(slotProps, childProps) {
-  const merged = { ...slotProps };
-  for (const key in childProps) {
-    if (!Object.hasOwn(childProps, key)) continue;
-    merged[key] = applyMergePolicy(key, slotProps[key], childProps[key]);
-  }
-  return merged;
-}
-function classifyProp(key, slotVal, childVal) {
-  if (EVENT_HANDLER_RE.test(key) && isFunction(slotVal) && isFunction(childVal)) return "chain";
-  if (key === "className") return "concat";
-  if (key === "style") return "shallow-merge";
-  return "child-wins";
-}
-function applyMergePolicy(key, slotVal, childVal) {
-  return policyHandlers[classifyProp(key, slotVal, childVal)](slotVal, childVal);
-}
-
-// ../../adapters/react/src/shared/merge-refs.ts
-function mergeRefs(...refs) {
-  const active = refs.filter((r2) => r2 != null);
-  if (active.length === 0) return null;
-  if (active.length === 1) return active[0];
-  return (value) => {
-    for (const ref of active) {
-      if (typeof ref === "function") {
-        ref(value);
-      } else {
-        ref.current = value;
-      }
-    }
-  };
-}
-
-// ../../adapters/react/src/shared/slot/Slottable.tsx
-import { Fragment } from "react";
-import { jsx } from "react/jsx-runtime";
-function Slottable({ children }) {
-  return /* @__PURE__ */ jsx(Fragment, { children });
-}
-
-// ../../adapters/react/src/shared/slot/clone.ts
-import { cloneElement } from "react";
-function cloneWithProps(child, props, ref) {
-  return cloneElement(child, ref !== null ? { ...props, ref } : props);
-}
-
-// ../../adapters/react/src/shared/slot/invariant.ts
-function panic2(message) {
-  throw new Error(message);
-}
-function invariant(condition, message) {
-  if (!condition) panic2(message);
-}
-
-// ../../adapters/react/src/shared/slot/applySlot.ts
-import { isValidElement as isValidElement3 } from "react";
-
-// ../../adapters/react/src/shared/slot/extractSlottable.ts
-import { createElement, Fragment as Fragment2, isValidElement as isValidElement2 } from "react";
-
-// ../../adapters/react/src/shared/slot/predicates.ts
-import { isValidElement } from "react";
-function isSlottableElement(value) {
-  return isValidElement(value) && value.type === Slottable;
-}
-
-// ../../adapters/react/src/shared/slot/extractSlottable.ts
-function extractSlottable(children) {
-  const childrenArray = Array.isArray(children) ? children : [children];
-  const slottables = childrenArray.filter(isSlottableElement);
-  invariant(slottables.length <= 1, "Slot: multiple Slottable children are not allowed");
-  if (slottables.length === 0) {
-    return null;
-  }
-  const [slottable] = slottables;
-  invariant(slottable, "Missing Slottable element");
-  const child = slottable.props.children;
-  invariant(
-    child !== null && child !== void 0,
-    "Slottable expects exactly one React element child, received null"
-  );
-  invariant(
-    typeof child !== "string" && typeof child !== "number",
-    "Slottable expects exactly one React element child, received text content"
-  );
-  invariant(isValidElement2(child), "Slottable expects exactly one React element child");
-  invariant(child.type !== Fragment2, "Slottable child cannot be a Fragment");
-  const index = childrenArray.indexOf(slottable);
-  return {
-    child,
-    // Fragment wrapper: Slot owns no DOM node; ref composition happens only on the merge target.
-    rebuild(merged) {
-      const out = childrenArray.map((node, i) => i === index ? merged : node);
-      return createElement(Fragment2, null, ...out);
-    }
-  };
-}
-
-// ../../adapters/react/src/shared/slot/applySlot.ts
-function applySlot(children, slotProps, ref, cloneSlotChild) {
-  const extraction = extractSlottable(children);
-  if (extraction) {
-    const merged = cloneSlotChild({ child: extraction.child, slotProps, ref });
-    return extraction.rebuild(merged);
-  }
-  invariant(isValidElement3(children), "Slot: child must be a valid React element");
-  return cloneSlotChild({ child: children, slotProps, ref });
-}
-
-// ../../adapters/react/src/shared/slot/slot-validator.ts
-var SlotValidator2 = class extends SlotValidator {
-  constructor(name, strict) {
-    super(name, strict, "React element");
-  }
-};
-
-// ../../adapters/react/src/shared/build-runtime.ts
-function normalizeOptions(options, defaultSlot) {
-  return {
-    ...options,
-    slotComponent: options.slotComponent ?? defaultSlot,
-    ...resolveAdapterCommonOptions(options)
-  };
-}
-function buildRuntime(options, defaultSlot, normalizeChildren) {
-  const normalized = normalizeOptions(options, defaultSlot);
-  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,
-    slotComponent: normalized.slotComponent,
-    normalizeChildren,
-    slotValidator,
-    filterProps,
-    ...childrenEvaluator !== void 0 && { childrenEvaluator }
-  };
-}
-
-// ../shared/src/guards/children/component-id.ts
-var COMPONENT_ID2 = /* @__PURE__ */ Symbol.for("praxis.component-id");
-var COMPONENT_DEFAULT_TAG2 = /* @__PURE__ */ Symbol.for("praxis.component-default-tag");
-
-// ../../adapters/react/src/shared/apply-display-name.ts
-function applyDisplayName(component, name) {
-  const displayName = name ?? "PolymorphicComponent";
-  Object.assign(component, {
-    displayName,
-    [COMPONENT_ID2]: /* @__PURE__ */ Symbol.for(`praxis.component.${displayName}`)
-  });
-}
-
-// ../../adapters/react/src/shared/render.ts
-import { createElement as createElement2 } from "react";
-import { jsx as jsx2 } from "react/jsx-runtime";
-function buildDirectives(as, asChild) {
-  return {
-    ...as !== void 0 && { as },
-    ...asChild !== void 0 && { asChild }
-  };
-}
-function buildRenderState(tag, directives, props, className, children) {
-  const state = { tag, directives, props, className };
-  if (children !== void 0) state.children = children;
-  return state;
-}
-function resolveRenderState(runtime, props, filterProps) {
-  const { as, asChild, render: _render, children, className, recipe, ...rest } = props;
-  const tag = runtime.resolveTag(as);
-  if (runtime.options.allowedAs !== void 0 && as !== void 0) {
-    enforceAllowedAs(
-      tag,
-      runtime.options.allowedAs,
-      runtime.options.strict,
-      runtime.options.displayName
-    );
-  }
-  const mergedProps = runtime.resolveProps(rest);
-  const baseProps = runtime.options.normalizeFn ? runtime.options.normalizeFn(mergedProps) : mergedProps;
-  const htmlNormalizers = runtime.options.htmlPropNormalizersFn?.(tag);
-  const normalizedProps = htmlNormalizers?.length ? htmlNormalizers.reduce((acc, fn) => ({ ...acc, ...fn(acc) }), baseProps) : baseProps;
-  const resolvedClass = runtime.resolveClasses(tag, normalizedProps, className, recipe);
-  const filteredProps = applyFilter(normalizedProps, filterProps, runtime.options.variantKeys);
-  return buildRenderState(tag, buildDirectives(as, asChild), filteredProps, resolvedClass, children);
-}
-function warnDiscardedChildren(originalChildren, normalizedChildren, validator) {
-  if (!Array.isArray(originalChildren)) return;
-  const discarded = originalChildren.length - normalizedChildren.length;
-  if (discarded > 0) validator.warnDiscardedChildren(discarded);
-}
-function isSingleElementArray(arr) {
-  return arr.length === 1;
-}
-function resolveSlotChildren(children, normalized, validator) {
-  warnDiscardedChildren(children, normalized, validator);
-  if (isSingleElementArray(normalized)) {
-    return normalized[0];
-  }
-  if (normalized.length > 1 && normalized.some(isSlottableElement)) {
-    return normalized;
-  }
-  validator.assertSingleChild(normalized.length);
-  return null;
-}
-function validateSlotDirectives(directives, validator) {
-  const { as, asChild } = directives;
-  if (!asChild) return false;
-  if (as !== void 0) {
-    validator.assertExclusive();
-    return false;
-  }
-  return true;
-}
-function resolveSlotRender(state, getNormalized, validator) {
-  if (!validateSlotDirectives(state.directives, validator)) return null;
-  const child = resolveSlotChildren(state.children, getNormalized(), validator);
-  if (child === null) return null;
-  return { child };
-}
-function renderResolvedSlot(slotComponent, state, resolved, ref) {
-  return jsx2(slotComponent, {
-    ...state.props,
-    className: state.className,
-    ref,
-    children: resolved.child
-  });
-}
-function tryRenderAsChild(state, ref, slotComponent, getNormalized, validator) {
-  const resolved = resolveSlotRender(state, getNormalized, validator);
-  if (resolved === null) return null;
-  return renderResolvedSlot(slotComponent, state, resolved, ref);
-}
-function buildElementProps(props, className, ref, children) {
-  const { role, ...rest } = props;
-  return {
-    ...rest,
-    className,
-    ref,
-    ...children !== void 0 && { children },
-    ...isKnownAriaRole(role) && { role }
-  };
-}
-function renderIntrinsic(state, ref, runtime) {
-  const elementProps = buildElementProps(state.props, state.className, ref, state.children);
-  const domProps = typeof state.tag === "string" ? runtime.resolveAria(state.tag, elementProps).props : elementProps;
-  return createElement2(state.tag, domProps);
-}
-function render({
-  runtime,
-  props,
-  ref,
-  slotComponent,
-  normalizeChildren,
-  filterProps,
-  slotValidator,
-  childrenEvaluator
-}) {
-  const state = resolveRenderState(runtime, props, filterProps);
-  let cached;
-  const once = () => cached ??= normalizeChildren(state.children);
-  if (process.env.NODE_ENV !== "production") {
-    childrenEvaluator?.evaluate(once());
-    getHtmlChildrenEvaluator(state.tag)?.evaluate(once());
-  }
-  if (typeof props.render === "function") {
-    return props.render({ ...state.props, className: state.className, ref });
-  }
-  const slotResult = tryRenderAsChild(state, ref, slotComponent, once, slotValidator);
-  return slotResult ?? renderIntrinsic(state, ref, runtime);
-}
-
-// ../core/dist/contract.js
-function stateContract(props) {
-  return { props };
-}
-var activeContract = stateContract([activeProps]);
-var disabledContract = stateContract([disabledProps]);
-var expandedContract = stateContract([expandedProps]);
-var invalidContract = stateContract([invalidProps]);
-var loadingContract = stateContract([loadingProps]);
-var pressedContract = stateContract([pressedProps]);
-var readonlyContract = stateContract([readonlyProps]);
-var selectedContract = stateContract([selectedProps]);
-var CONTRACTED_CAPABILITIES = {
-  AriaEngine: AriaPolicyEngine,
-  htmlAriaRules: HTML_ARIA_RULES,
-  htmlPropNormalizersFn: getHtmlPropNormalizers
-};
-function createContractedPolymorphic(options = {}) {
-  return createPolymorphic(options, CONTRACTED_CAPABILITIES);
-}
-
-export {
-  createPolymorphic,
-  createContractedPolymorphic,
-  defineContractComponent,
-  buildEngines,
-  composeFilter,
-  isFunction,
-  isPlainObject,
-  SLOT_NAME,
-  mergeSlotProps,
-  mergeRefs,
-  cloneWithProps,
-  Slottable,
-  applySlot,
-  SlotValidator2 as SlotValidator,
-  buildRuntime,
-  COMPONENT_DEFAULT_TAG2 as COMPONENT_DEFAULT_TAG,
-  applyDisplayName,
-  render
-};