@purpur/library 9.9.0 → 9.10.0

package/dist/radio-button-group-D_F6kWD6.mjs

@@ -0,0 +1,2535 @@
+import { jsx as L, jsxs as Ie } from "react/jsx-runtime";
+import * as u from "react";
+import { createElement as Et, createContext as pn, useContext as gn, forwardRef as nt } from "react";
+import { c as At } from "./bind-CU-R61T-.mjs";
+import * as mn from "react-dom";
+import { H as hn } from "./heading-xwBuT_-9.mjs";
+const bn = () => {
+}, K = typeof document < "u" ? u.useLayoutEffect : bn, ue = {
+  ...u
+}, vt = {};
+function ee(e, t) {
+  const n = u.useRef(vt);
+  return n.current === vt && (n.current = e(t)), n;
+}
+const Te = ue.useInsertionEffect, yn = (
+  // React 17 doesn't have useInsertionEffect.
+  Te && // Preact replaces useInsertionEffect with useLayoutEffect and fires too late.
+  Te !== ue.useLayoutEffect ? Te : (e) => e()
+);
+function A(e) {
+  const t = ee(Rn).current;
+  return t.next = e, yn(t.effect), t.trampoline;
+}
+function Rn() {
+  const e = {
+    next: void 0,
+    callback: In,
+    trampoline: (...t) => e.callback?.(...t),
+    effect: () => {
+      e.callback = e.next;
+    }
+  };
+  return e;
+}
+function In() {
+  if (process.env.NODE_ENV !== "production")
+    throw (
+      /* minify-error-disabled */
+      new Error("Base UI: Cannot call an event handler while rendering.")
+    );
+}
+function En(e, t) {
+  return function(o, ...r) {
+    const i = new URL(e);
+    return i.searchParams.set("code", o.toString()), r.forEach((s) => i.searchParams.append("args[]", s)), `${t} error #${o}; visit ${i} for the full message.`;
+  };
+}
+const xe = En("https://base-ui.com/production-error", "Base UI");
+function W() {
+}
+const Ee = Object.freeze([]), Z = Object.freeze({}), ve = {
+  badInput: !1,
+  customError: !1,
+  patternMismatch: !1,
+  rangeOverflow: !1,
+  rangeUnderflow: !1,
+  stepMismatch: !1,
+  tooLong: !1,
+  tooShort: !1,
+  typeMismatch: !1,
+  valid: null,
+  valueMissing: !1
+}, vn = {
+  valid: null,
+  touched: !1,
+  dirty: !1,
+  filled: !1,
+  focused: !1
+}, Cn = {
+  disabled: !1,
+  ...vn
+}, me = {
+  valid(e) {
+    return e === null ? null : e ? {
+      "data-valid": ""
+    } : {
+      "data-invalid": ""
+    };
+  }
+}, xn = {
+  invalid: void 0,
+  name: void 0,
+  validityData: {
+    state: ve,
+    errors: [],
+    error: "",
+    value: "",
+    initialValue: null
+  },
+  setValidityData: W,
+  disabled: void 0,
+  setTouched: W,
+  setDirty: W,
+  setFilled: W,
+  setFocused: W,
+  validationMode: "onSubmit",
+  shouldValidateOnChange: () => !1,
+  state: Cn,
+  registerFieldControl: W,
+  validation: {
+    getValidationProps: (e, t = Z) => t,
+    inputRef: {
+      current: null
+    },
+    registeredInputs: /* @__PURE__ */ new Map(),
+    registerInput: W,
+    getInputControl: () => null,
+    commit: async () => {
+    },
+    change: W
+  }
+}, rt = /* @__PURE__ */ u.createContext(xn);
+process.env.NODE_ENV !== "production" && (rt.displayName = "FieldRootContext");
+function he(e = !0) {
+  const t = u.useContext(rt);
+  if (t.setValidityData === W && !e)
+    throw new Error(process.env.NODE_ENV !== "production" ? "Base UI: FieldRootContext is missing. Field parts must be placed within <Field.Root>." : xe(28));
+  return t;
+}
+const ot = /* @__PURE__ */ u.createContext(void 0);
+process.env.NODE_ENV !== "production" && (ot.displayName = "FieldsetRootContext");
+function Ve(e = !1) {
+  const t = u.useContext(ot);
+  if (!t && !e)
+    throw new Error(process.env.NODE_ENV !== "production" ? "Base UI: FieldsetRootContext is missing. Fieldset parts must be placed within <Fieldset.Root>." : xe(86));
+  return t;
+}
+const Ft = /* @__PURE__ */ u.createContext({
+  elementRef: {
+    current: null
+  },
+  formRef: {
+    current: {
+      fields: /* @__PURE__ */ new Map()
+    }
+  },
+  errors: {},
+  clearErrors: W,
+  validationMode: "onSubmit",
+  submitAttemptedRef: {
+    current: !1
+  }
+});
+process.env.NODE_ENV !== "production" && (Ft.displayName = "FormContext");
+function Se() {
+  return u.useContext(Ft);
+}
+let Ct = 0;
+function Nn(e, t = "mui") {
+  const [n, o] = u.useState(e), r = e || n;
+  return u.useEffect(() => {
+    n == null && (Ct += 1, o(`${t}-${Ct}`));
+  }, [n, t]), r;
+}
+const xt = ue.useId;
+function _n(e, t) {
+  if (xt !== void 0) {
+    const n = xt();
+    return e ?? `${t}-${n}`;
+  }
+  return Nn(e, t);
+}
+function ce(e) {
+  return _n(e, "base-ui");
+}
+const it = /* @__PURE__ */ u.createContext({
+  controlId: void 0,
+  registerControlId: W,
+  labelId: void 0,
+  setLabelId: W,
+  messageIds: [],
+  setMessageIds: W,
+  getDescriptionProps: (e) => e
+});
+process.env.NODE_ENV !== "production" && (it.displayName = "LabelableContext");
+function ie() {
+  return u.useContext(it);
+}
+const st = function(t) {
+  const n = ce(), o = t.controlId === void 0 ? n : t.controlId, [r, i] = u.useState(o), [s, f] = u.useState(t.labelId), [c, a] = u.useState([]), d = ee(() => /* @__PURE__ */ new Map()), {
+    messageIds: p
+  } = ie(), y = A((v, R) => {
+    const x = d.current;
+    if (R === void 0) {
+      x.delete(v);
+      return;
+    }
+    x.set(v, R), i((N) => {
+      if (x.size === 0)
+        return;
+      let T;
+      for (const l of x.values()) {
+        if (N !== void 0 && l === N)
+          return N;
+        T === void 0 && (T = l);
+      }
+      return T;
+    });
+  }), g = u.useCallback((v) => {
+    const R = v["aria-describedby"] ? v["aria-describedby"].split(" ") : [];
+    return R.push(...p, ...c), {
+      ...v,
+      "aria-describedby": Array.from(new Set(R)).join(" ") || void 0
+    };
+  }, [p, c]), m = u.useMemo(() => ({
+    controlId: r,
+    registerControlId: y,
+    labelId: s,
+    setLabelId: f,
+    messageIds: c,
+    setMessageIds: a,
+    getDescriptionProps: g
+  }), [r, y, s, f, c, a, g]);
+  return /* @__PURE__ */ L(it.Provider, {
+    value: m,
+    children: t.children
+  });
+};
+process.env.NODE_ENV !== "production" && (st.displayName = "LabelableProvider");
+function wn(e, t, n, o = !0, r) {
+  const [i, s] = u.useState(), f = ce(r ? `${r}-label` : void 0), c = e ?? t ?? i;
+  return K(() => {
+    const a = e || t || !o ? void 0 : Dn(n.current, f);
+    i !== a && s(a);
+  }), c;
+}
+function Dn(e, t) {
+  const n = Mn(e);
+  if (n)
+    return !n.id && t && (n.id = t), n.id || void 0;
+}
+function Mn(e) {
+  if (!e)
+    return;
+  const t = e.parentElement;
+  if (t && t.tagName === "LABEL")
+    return t;
+  const n = e.id;
+  if (n) {
+    const r = e.nextElementSibling;
+    if (r && r.htmlFor === n)
+      return r;
+  }
+  const o = e.labels;
+  return o && o[0];
+}
+function at() {
+  return typeof window < "u";
+}
+function Ne(e) {
+  var t;
+  return (e == null || (t = e.ownerDocument) == null ? void 0 : t.defaultView) || window;
+}
+function Pn(e) {
+  return at() ? e instanceof Element || e instanceof Ne(e).Element : !1;
+}
+function _e(e) {
+  return at() ? e instanceof HTMLElement || e instanceof Ne(e).HTMLElement : !1;
+}
+function On(e) {
+  return !at() || typeof ShadowRoot > "u" ? !1 : e instanceof ShadowRoot || e instanceof Ne(e).ShadowRoot;
+}
+function kn(e) {
+  return Ne(e).getComputedStyle(e);
+}
+function An(e = {}) {
+  const {
+    id: t,
+    implicit: n = !1,
+    controlRef: o
+  } = e, {
+    controlId: r,
+    registerControlId: i
+  } = ie(), s = ce(t), f = n ? r : void 0, c = ee(() => /* @__PURE__ */ Symbol()), a = u.useRef(!1), d = u.useRef(t != null), p = A(() => {
+    !a.current || i === W || (a.current = !1, i(c.current, void 0));
+  });
+  return K(() => {
+    if (i === W)
+      return;
+    let y;
+    if (n) {
+      const g = o?.current;
+      Pn(g) && g.closest("label") != null ? y = t ?? null : y = f ?? s;
+    } else if (t != null)
+      d.current = !0, y = t;
+    else if (d.current)
+      y = s;
+    else {
+      p();
+      return;
+    }
+    if (y === void 0) {
+      p();
+      return;
+    }
+    a.current = !0, i(c.current, y);
+  }, [t, o, f, i, n, s, c, p]), u.useEffect(() => p, [p]), r ?? s;
+}
+function Fn(e) {
+  return e?.ownerDocument || document;
+}
+function Vn(e, t) {
+  if (!e || !t)
+    return !1;
+  const n = t.getRootNode?.();
+  if (e.contains(t))
+    return !0;
+  if (n && On(n)) {
+    let o = t;
+    for (; o; ) {
+      if (e === o)
+        return !0;
+      o = o.parentNode || o.host;
+    }
+  }
+  return !1;
+}
+function Ke(e) {
+  return "composedPath" in e ? e.composedPath()[0] : e.target;
+}
+function Be(e, t) {
+  return t < 0 || t >= e.length;
+}
+function Sn(e, t) {
+  return Re(e.current, {
+    disabledIndices: t
+  });
+}
+function Ln(e, t) {
+  return Re(e.current, {
+    decrement: !0,
+    startingIndex: e.current.length,
+    disabledIndices: t
+  });
+}
+function Re(e, {
+  startingIndex: t = -1,
+  decrement: n = !1,
+  disabledIndices: o,
+  amount: r = 1
+} = {}) {
+  let i = t;
+  do
+    i += n ? -r : r;
+  while (i >= 0 && i <= e.length - 1 && Ge(e, i, o));
+  return i;
+}
+function Ge(e, t, n) {
+  if (typeof n == "function" ? n(t) : n?.includes(t) ?? !1)
+    return !0;
+  const r = e[t];
+  return r ? !Bn(r) || r.matches(":disabled") ? !0 : !n && (r.hasAttribute("disabled") || r.getAttribute("aria-disabled") === "true") : !1;
+}
+function Tn(e) {
+  return e.visibility === "hidden" || e.visibility === "collapse";
+}
+function Bn(e, t = e ? kn(e) : null) {
+  return !e || !e.isConnected || !t || Tn(t) ? !1 : typeof e.checkVisibility == "function" ? e.checkVisibility() : t.display !== "none" && t.display !== "contents";
+}
+function Vt(e, t) {
+  const n = ce(e);
+  return K(() => (t(n), () => {
+    t((o) => o === n ? void 0 : o);
+  }), [n, t]), n;
+}
+function $n(e = {}) {
+  const {
+    id: t,
+    fallbackControlId: n,
+    native: o = !1,
+    setLabelId: r,
+    focusControl: i
+  } = e, {
+    controlId: s,
+    setLabelId: f
+  } = ie(), c = A((g) => {
+    f(g), r?.(g);
+  }), a = Vt(t, c), d = s ?? n;
+  function p(g) {
+    if (i) {
+      i(g, d);
+      return;
+    }
+    if (!d)
+      return;
+    const m = Fn(g.currentTarget).getElementById(d);
+    _e(m) && Un(m);
+  }
+  function y(g) {
+    Ke(g.nativeEvent)?.closest("button,input,select,textarea") || (!g.defaultPrevented && g.detail > 1 && g.preventDefault(), !o && p(g));
+  }
+  return o ? {
+    id: a,
+    htmlFor: d ?? void 0,
+    onMouseDown: y
+  } : {
+    id: a,
+    onClick: y,
+    onPointerDown(g) {
+      g.preventDefault();
+    }
+  };
+}
+function Un(e) {
+  e.focus({
+    // Available from Chrome 144+ (January 2026).
+    // Safari and Firefox already support it.
+    focusVisible: !0
+  });
+}
+function Ce(e, t, n, o) {
+  const r = ee(St).current;
+  return Kn(r, e, t, n, o) && Lt(r, [e, t, n, o]), r.callback;
+}
+function Hn(e) {
+  const t = ee(St).current;
+  return Gn(t, e) && Lt(t, e), t.callback;
+}
+function St() {
+  return {
+    callback: null,
+    cleanup: null,
+    refs: []
+  };
+}
+function Kn(e, t, n, o, r) {
+  return e.refs[0] !== t || e.refs[1] !== n || e.refs[2] !== o || e.refs[3] !== r;
+}
+function Gn(e, t) {
+  return e.refs.length !== t.length || e.refs.some((n, o) => n !== t[o]);
+}
+function Lt(e, t) {
+  if (e.refs = t, t.every((n) => n == null)) {
+    e.callback = null;
+    return;
+  }
+  e.callback = (n) => {
+    if (e.cleanup && (e.cleanup(), e.cleanup = null), n != null) {
+      const o = Array(t.length).fill(null);
+      for (let r = 0; r < t.length; r += 1) {
+        const i = t[r];
+        if (i != null)
+          switch (typeof i) {
+            case "function": {
+              const s = i(n);
+              typeof s == "function" && (o[r] = s);
+              break;
+            }
+            case "object": {
+              i.current = n;
+              break;
+            }
+          }
+      }
+      e.cleanup = () => {
+        for (let r = 0; r < t.length; r += 1) {
+          const i = t[r];
+          if (i != null)
+            switch (typeof i) {
+              case "function": {
+                const s = o[r];
+                typeof s == "function" ? s() : i(null);
+                break;
+              }
+              case "object": {
+                i.current = null;
+                break;
+              }
+            }
+        }
+      };
+    }
+  };
+}
+const Wn = parseInt(u.version, 10);
+function jn(e) {
+  return Wn >= e;
+}
+function Nt(e) {
+  if (!/* @__PURE__ */ u.isValidElement(e))
+    return null;
+  const t = e, n = t.props;
+  return (jn(19) ? n?.ref : t.ref) ?? null;
+}
+function We(e, t) {
+  if (e && !t)
+    return e;
+  if (!e && t)
+    return t;
+  if (e || t)
+    return {
+      ...e,
+      ...t
+    };
+}
+let je;
+process.env.NODE_ENV !== "production" && (je = /* @__PURE__ */ new Set());
+function qn(...e) {
+  if (process.env.NODE_ENV !== "production") {
+    const t = e.join(" ");
+    je.has(t) || (je.add(t), console.warn(`Base UI: ${t}`));
+  }
+}
+function zn(e, t) {
+  const n = {};
+  for (const o in e) {
+    const r = e[o];
+    if (t?.hasOwnProperty(o)) {
+      const i = t[o](r);
+      i != null && Object.assign(n, i);
+      continue;
+    }
+    r === !0 ? n[`data-${o.toLowerCase()}`] = "" : r && (n[`data-${o.toLowerCase()}`] = r.toString());
+  }
+  return n;
+}
+function Yn(e, t) {
+  return typeof e == "function" ? e(t) : e;
+}
+function Xn(e, t) {
+  return typeof e == "function" ? e(t) : e;
+}
+const ut = {};
+function Le(e, t, n, o, r) {
+  if (!n && !o && !e)
+    return Ae(t);
+  let i = Ae(e);
+  return t && (i = Oe(i, t)), n && (i = Oe(i, n)), o && (i = Oe(i, o)), i;
+}
+function Zn(e) {
+  if (e.length === 0)
+    return ut;
+  if (e.length === 1)
+    return Ae(e[0]);
+  let t = Ae(e[0]);
+  for (let n = 1; n < e.length; n += 1)
+    t = Oe(t, e[n]);
+  return t;
+}
+function Ae(e) {
+  return ct(e) ? {
+    ...Bt(e, ut)
+  } : Jn(e);
+}
+function Oe(e, t) {
+  return ct(t) ? Bt(t, e) : Qn(e, t);
+}
+function Jn(e) {
+  const t = {
+    ...e
+  };
+  for (const n in t) {
+    const o = t[n];
+    Tt(n, o) && (t[n] = $t(o));
+  }
+  return t;
+}
+function Qn(e, t) {
+  if (!t)
+    return e;
+  for (const n in t) {
+    const o = t[n];
+    switch (n) {
+      case "style": {
+        e[n] = We(e.style, o);
+        break;
+      }
+      case "className": {
+        e[n] = Ut(e.className, o);
+        break;
+      }
+      default:
+        Tt(n, o) ? e[n] = er(e[n], o) : e[n] = o;
+    }
+  }
+  return e;
+}
+function Tt(e, t) {
+  const n = e.charCodeAt(0), o = e.charCodeAt(1), r = e.charCodeAt(2);
+  return n === 111 && o === 110 && r >= 65 && r <= 90 && (typeof t == "function" || typeof t > "u");
+}
+function ct(e) {
+  return typeof e == "function";
+}
+function Bt(e, t) {
+  return ct(e) ? e(t) : e ?? ut;
+}
+function er(e, t) {
+  return t ? e ? (...n) => {
+    const o = n[0];
+    if (Ht(o)) {
+      const i = o;
+      Fe(i);
+      const s = t(...n);
+      return i.baseUIHandlerPrevented || e?.(...n), s;
+    }
+    const r = t(...n);
+    return e?.(...n), r;
+  } : $t(t) : e;
+}
+function $t(e) {
+  return e && ((...t) => {
+    const n = t[0];
+    return Ht(n) && Fe(n), e(...t);
+  });
+}
+function Fe(e) {
+  return e.preventBaseUIHandler = () => {
+    e.baseUIHandlerPrevented = !0;
+  }, e;
+}
+function Ut(e, t) {
+  return t ? e ? t + " " + e : t : e;
+}
+function Ht(e) {
+  return e != null && typeof e == "object" && "nativeEvent" in e;
+}
+function te(e, t, n = {}) {
+  const o = t.render, r = tr(t, n);
+  if (n.enabled === !1)
+    return null;
+  const i = n.state ?? Z;
+  return sr(e, o, r, i);
+}
+function tr(e, t = {}) {
+  const {
+    className: n,
+    style: o,
+    render: r
+  } = e, {
+    state: i = Z,
+    ref: s,
+    props: f,
+    stateAttributesMapping: c,
+    enabled: a = !0
+  } = t, d = a ? Yn(n, i) : void 0, p = a ? Xn(o, i) : void 0, y = a ? zn(i, c) : Z, g = a && f ? nr(f) : void 0, m = a ? We(y, g) ?? {} : Z;
+  return typeof document < "u" && (a ? Array.isArray(s) ? m.ref = Hn([m.ref, Nt(r), ...s]) : m.ref = Ce(m.ref, Nt(r), s) : Ce(null, null)), a ? (d !== void 0 && (m.className = Ut(m.className, d)), p !== void 0 && (m.style = We(m.style, p)), m) : Z;
+}
+function nr(e) {
+  return Array.isArray(e) ? Zn(e) : Le(void 0, e);
+}
+const rr = /* @__PURE__ */ Symbol.for("react.lazy"), or = /^[A-Z][A-Za-z0-9$]*$/, ir = /[a-z]/;
+function sr(e, t, n, o) {
+  if (t) {
+    if (typeof t == "function")
+      return process.env.NODE_ENV !== "production" && ar(t), t(n, o);
+    const r = Le(n, t.props);
+    r.ref = n.ref;
+    let i = t;
+    if (i?.$$typeof === rr && (i = u.Children.toArray(t)[0]), process.env.NODE_ENV !== "production" && !/* @__PURE__ */ u.isValidElement(i))
+      throw new Error(["Base UI: The `render` prop was provided an invalid React element as `React.isValidElement(render)` is `false`.", "A valid React element must be provided to the `render` prop because it is cloned with props to replace the default element.", "https://base-ui.com/r/invalid-render-prop"].join(`
+`));
+    return /* @__PURE__ */ u.cloneElement(i, r);
+  }
+  if (e && typeof e == "string")
+    return ur(e, n);
+  throw new Error(process.env.NODE_ENV !== "production" ? "Base UI: Render element or function are not defined." : xe(8));
+}
+function ar(e) {
+  const t = e.name;
+  t.length !== 0 && or.test(t) && ir.test(t) && qn(`The \`render\` prop received a function named \`${t}\` that starts with an uppercase letter.`, "This usually means a React component was passed directly as `render={Component}`.", "Base UI calls `render` as a plain function, which can break the Rules of Hooks during reconciliation.", "If this is an intentional render callback, rename it to start with a lowercase letter.", "Use `render={<Component />}` or `render={(props) => <Component {...props} />}` instead.", "https://base-ui.com/r/invalid-render-prop");
+}
+function ur(e, t) {
+  return e === "button" ? /* @__PURE__ */ Et("button", {
+    type: "button",
+    ...t,
+    key: t.key
+  }) : e === "img" ? /* @__PURE__ */ Et("img", {
+    alt: "",
+    ...t,
+    key: t.key
+  }) : /* @__PURE__ */ u.createElement(e, t);
+}
+function Kt(e) {
+  u.useEffect(e, Ee);
+}
+const ye = 0;
+class lt {
+  static create() {
+    return new lt();
+  }
+  currentId = ye;
+  /**
+   * Executes `fn` after `delay`, clearing any previously scheduled call.
+   */
+  start(t, n) {
+    this.clear(), this.currentId = setTimeout(() => {
+      this.currentId = ye, n();
+    }, t);
+  }
+  isStarted() {
+    return this.currentId !== ye;
+  }
+  clear = () => {
+    this.currentId !== ye && (clearTimeout(this.currentId), this.currentId = ye);
+  };
+  disposeEffect = () => this.clear;
+}
+function cr() {
+  const e = ee(lt.create).current;
+  return Kt(e.disposeEffect), e;
+}
+function qe(e, t) {
+  return {
+    ...e,
+    state: {
+      ...e.state,
+      valid: !t && e.state.valid
+    }
+  };
+}
+const $e = Object.keys(ve);
+function Gt(e, t) {
+  return e.matches(":disabled") ? !1 : !t || e.form === t ? !0 : e.form === null && !e.hasAttribute("form");
+}
+function _t(e, t) {
+  let n = null;
+  for (const o of e.keys())
+    if (Gt(o, t)) {
+      if (!o.validity.valid)
+        return o;
+      n ??= o;
+    }
+  return n;
+}
+function wt(e, t) {
+  for (const n of t.keys())
+    n.setCustomValidity("");
+  e?.setCustomValidity("");
+}
+function lr(e) {
+  const {
+    elementRef: t,
+    formRef: n
+  } = Se(), {
+    setValidityData: o,
+    validate: r,
+    validityData: i,
+    validationDebounceTime: s,
+    invalid: f,
+    markedDirtyRef: c,
+    state: a,
+    shouldValidateOnChange: d,
+    registeredFieldIdRef: p
+  } = e, {
+    controlId: y,
+    getDescriptionProps: g
+  } = ie(), m = cr(), v = u.useRef(null), R = ee(() => /* @__PURE__ */ new Map()).current, x = u.useRef(0), N = u.useCallback((I, D) => (R.set(I, D), () => {
+    R.delete(I);
+  }), [R]), T = A(() => {
+    const I = _t(R, t.current);
+    return I && R.get(I)?.controlRef.current || null;
+  }), l = A(async (I, D = !1) => {
+    x.current += 1;
+    const G = x.current;
+    function b(S, _ = f) {
+      const V = p.current ?? y;
+      if (V == null)
+        return;
+      const k = n.current.fields.get(V);
+      if (!k)
+        return;
+      const B = qe(S, _);
+      n.current.fields.set(V, {
+        ...k,
+        validityData: B
+      });
+    }
+    function O(S, _) {
+      const V = {
+        value: I,
+        state: {
+          ...ve,
+          valid: !0
+        },
+        error: "",
+        errors: [],
+        initialValue: i.initialValue
+      };
+      wt(S, R), b(V, _), o(V);
+    }
+    const E = R.size > 0 ? _t(R, t.current) : v.current;
+    if (D) {
+      if (a.valid !== !1 || !E)
+        return;
+      const S = E.validity;
+      if (!S.valueMissing) {
+        O(E, !1);
+        return;
+      }
+      for (const _ of $e)
+        if (_ !== "valid" && _ !== "valueMissing" && _ !== "customError" && S[_])
+          return;
+    }
+    function H(S) {
+      const _ = $e.reduce((k, B) => (k[B] = S.validity[B], k), {});
+      let V = !1;
+      for (const k of $e)
+        if (k !== "valid") {
+          if (k === "valueMissing" && _[k])
+            V = !0;
+          else if (_[k])
+            return _;
+        }
+      return V && !c.current && (_.valid = !0, _.valueMissing = !1), _;
+    }
+    m.clear();
+    let F = null, $ = [];
+    const U = E ? H(E) : {
+      ...ve,
+      valid: !0
+    };
+    let Y;
+    const w = d();
+    if (E && E.validationMessage && !w)
+      Y = E.validationMessage, $ = [E.validationMessage];
+    else {
+      const S = Array.from(n.current.fields.values()).reduce((V, k) => (k.name && (V[k.name] = k.getValue()), V), {}), _ = r(I, S);
+      if (typeof _ == "object" && _ !== null && "then" in _) {
+        if (F = await _, G !== x.current)
+          return;
+      } else
+        F = _;
+      F !== null ? (U.valid = !1, U.customError = !0, Array.isArray(F) ? ($ = F, E?.setCustomValidity(F.join(`
+`))) : F && ($ = [F], E?.setCustomValidity(F))) : w && (wt(E, R), U.customError = !1, E && E.validationMessage ? (Y = E.validationMessage, $ = [E.validationMessage]) : (!E || E.validity.valid) && !U.valid && (U.valid = !0));
+    }
+    const M = {
+      value: I,
+      state: U,
+      error: Y ?? (Array.isArray(F) ? F[0] : F ?? ""),
+      errors: $,
+      initialValue: i.initialValue
+    };
+    b(M), o(M);
+  }), h = A((I) => {
+    m.clear();
+    const D = d();
+    D && I !== "" && s ? (x.current += 1, m.start(s, () => {
+      l(I);
+    })) : l(I, !D);
+  }), C = u.useCallback((I, D = {}) => Le(g(D), a.valid === !1 && !a.disabled && !I ? {
+    "aria-invalid": !0
+  } : Z), [g, a.disabled, a.valid]);
+  return u.useMemo(() => ({
+    getValidationProps: C,
+    inputRef: v,
+    registeredInputs: R,
+    registerInput: N,
+    getInputControl: T,
+    commit: l,
+    change: h
+  }), [C, R, N, T, l, h]);
+}
+function dr(e) {
+  const {
+    commit: t,
+    invalid: n,
+    markedDirtyRef: o,
+    name: r,
+    setRegisteredFieldName: i,
+    registeredFieldIdRef: s,
+    setValidityData: f,
+    validityData: c
+  } = e, {
+    formRef: a
+  } = Se(), d = u.useRef(null), p = u.useRef(null), y = u.useRef(!1), g = A(() => {
+    const l = p.current;
+    if (l)
+      return l.getValue ? l.getValue() : l.value;
+  });
+  function m(l) {
+    return l.value === void 0 ? g() : l.value;
+  }
+  const v = A(() => {
+    const l = p.current;
+    if (o.current = !0, !l) {
+      t(c.value);
+      return;
+    }
+    t(m(l));
+  });
+  function R() {
+    const l = p.current;
+    !l || !l.id || a.current.fields.set(l.id, {
+      getValue: g,
+      name: r ?? l.name,
+      controlRef: l.controlRef,
+      validityData: qe(c, n),
+      validate: v
+    });
+  }
+  function x(l = p.current?.id) {
+    l && a.current.fields.delete(l);
+  }
+  function N(l) {
+    if (y.current)
+      return;
+    y.current = !0;
+    const h = m(l);
+    f((C) => C.initialValue === h ? C : {
+      ...C,
+      initialValue: h
+    });
+  }
+  K(() => {
+    const l = p.current;
+    !l || !l.id || (i(r ? void 0 : l.name), a.current.fields.set(l.id, {
+      getValue: g,
+      name: r ?? l.name,
+      controlRef: l.controlRef,
+      validityData: qe(c, n),
+      validate: v
+    }));
+  }, [a, g, n, r, i, v, c]), K(() => {
+    const l = a.current.fields;
+    return () => {
+      const h = p.current?.id;
+      h && l.delete(h);
+    };
+  }, [a]);
+  const T = A((l, h) => {
+    if (!h) {
+      d.current === l && (d.current = null, x(), p.current = null, i(void 0), s.current = void 0);
+      return;
+    }
+    const C = p.current?.id;
+    d.current = l, p.current = h, r || i(h.name), s.current = h.id, C && C !== h.id && x(C), N(h), R();
+  });
+  return [v, T];
+}
+const Wt = /* @__PURE__ */ u.forwardRef(function(t, n) {
+  const {
+    errors: o,
+    validationMode: r,
+    submitAttemptedRef: i
+  } = Se(), {
+    render: s,
+    className: f,
+    validate: c,
+    validationDebounceTime: a = 0,
+    validationMode: d = r,
+    name: p,
+    disabled: y = !1,
+    invalid: g,
+    dirty: m,
+    touched: v,
+    actionsRef: R,
+    style: x,
+    ...N
+  } = t, T = Ve(!0)?.disabled, l = A(c || (() => null)), h = T || y, [C, I] = u.useState(!1), [D, G] = u.useState(!1), [b, O] = u.useState(!1), [E, H] = u.useState(!1), F = m ?? D, $ = v ?? C, U = u.useRef(F), Y = u.useRef(void 0), [w, M] = u.useState(), S = p ?? w;
+  K(() => {
+    m !== void 0 && (U.current = m);
+  }, [m]);
+  const _ = A((X) => {
+    m === void 0 && (X && (U.current = !0), G(X));
+  }), V = A((X) => {
+    v === void 0 && I(X);
+  }), k = A(() => d === "onChange" || d === "onSubmit" && i.current), B = S && Object.hasOwn(o, S) ? o[S] : null, J = !!(Array.isArray(B) ? B.length : B), q = g === !0 || J, [Q, oe] = u.useState({
+    state: ve,
+    error: "",
+    errors: [],
+    value: null,
+    initialValue: null
+  }), se = !q && (h ? null : Q.state.valid), ne = u.useMemo(() => ({
+    disabled: h,
+    touched: $,
+    dirty: F,
+    valid: se,
+    filled: b,
+    focused: E
+  }), [h, $, F, se, b, E]), ae = lr({
+    setValidityData: oe,
+    validate: l,
+    validityData: Q,
+    validationDebounceTime: a,
+    invalid: q,
+    markedDirtyRef: U,
+    state: ne,
+    shouldValidateOnChange: k,
+    registeredFieldIdRef: Y
+  }), [le, de] = dr({
+    commit: ae.commit,
+    invalid: q,
+    markedDirtyRef: U,
+    name: p,
+    setRegisteredFieldName: M,
+    registeredFieldIdRef: Y,
+    setValidityData: oe,
+    validityData: Q
+  });
+  u.useImperativeHandle(R, () => ({
+    validate: le
+  }), [le]);
+  const P = u.useMemo(() => ({
+    invalid: q,
+    name: S,
+    validityData: Q,
+    setValidityData: oe,
+    disabled: h,
+    setTouched: V,
+    setDirty: _,
+    setFilled: O,
+    setFocused: H,
+    validationMode: d,
+    shouldValidateOnChange: k,
+    state: ne,
+    registerFieldControl: de,
+    validation: ae
+  }), [q, S, Q, h, V, _, O, H, d, k, ne, de, ae]), z = te("div", t, {
+    ref: n,
+    state: ne,
+    props: N,
+    stateAttributesMapping: me
+  });
+  return /* @__PURE__ */ L(rt.Provider, {
+    value: P,
+    children: z
+  });
+});
+process.env.NODE_ENV !== "production" && (Wt.displayName = "FieldRootInner");
+const jt = /* @__PURE__ */ u.forwardRef(function(t, n) {
+  return /* @__PURE__ */ L(st, {
+    children: /* @__PURE__ */ L(Wt, {
+      ...t,
+      ref: n
+    })
+  });
+});
+process.env.NODE_ENV !== "production" && (jt.displayName = "FieldRoot");
+let ze;
+process.env.NODE_ENV !== "production" && (ze = /* @__PURE__ */ new Set());
+function ge(...e) {
+  if (process.env.NODE_ENV !== "production") {
+    const t = e.join(" ");
+    ze.has(t) || (ze.add(t), console.error(`Base UI: ${t}`));
+  }
+}
+const dt = /* @__PURE__ */ u.createContext({
+  disabled: !1
+});
+process.env.NODE_ENV !== "production" && (dt.displayName = "FieldItemContext");
+function ft() {
+  return u.useContext(dt);
+}
+const qt = /* @__PURE__ */ u.forwardRef(function(t, n) {
+  const {
+    render: o,
+    className: r,
+    style: i,
+    id: s,
+    nativeLabel: f = !0,
+    ...c
+  } = t, a = he(!1), d = ft(), {
+    labelId: p
+  } = ie(), y = {
+    ...a.state,
+    disabled: a.disabled || d.disabled
+  }, g = u.useRef(null), m = $n({
+    id: p ?? s,
+    native: f
+  });
+  return process.env.NODE_ENV !== "production" && u.useEffect(() => {
+    if (!g.current)
+      return;
+    const R = g.current.tagName === "LABEL";
+    if (f) {
+      if (!R) {
+        const x = ue.captureOwnerStack?.() || "";
+        ge(`<Field.Label> expected a <label> element because the \`nativeLabel\` prop is true. Rendering a non-<label> disables native label association, so \`htmlFor\` will not work. Use a real <label> in the \`render\` prop, or set \`nativeLabel\` to \`false\`.${x}`);
+      }
+    } else if (R) {
+      const x = ue.captureOwnerStack?.() || "";
+      ge(`<Field.Label> expected a non-<label> element because the \`nativeLabel\` prop is false. Rendering a <label> assumes native label behavior while Base UI treats it as non-native, which can cause unexpected pointer behavior. Use a non-<label> in the \`render\` prop, or set \`nativeLabel\` to \`true\`.${x}`);
+    }
+  }, [f]), te("label", t, {
+    ref: [n, g],
+    state: y,
+    props: [m, c],
+    stateAttributesMapping: me
+  });
+});
+process.env.NODE_ENV !== "production" && (qt.displayName = "FieldLabel");
+const we = null;
+let Dt = globalThis.requestAnimationFrame;
+class fr {
+  /* This implementation uses an array as a backing data-structure for frame callbacks.
+   * It allows `O(1)` callback cancelling by inserting a `null` in the array, though it
+   * never calls the native `cancelAnimationFrame` if there are no frames left. This can
+   * be much more efficient if there is a call pattern that alterns as
+   * "request-cancel-request-cancel-…".
+   * But in the case of "request-request-…-cancel-cancel-…", it leaves the final animation
+   * frame to run anyway. We turn that frame into a `O(1)` no-op via `callbacksCount`. */
+  callbacks = [];
+  callbacksCount = 0;
+  nextId = 1;
+  startId = 1;
+  isScheduled = !1;
+  tick = (t) => {
+    this.isScheduled = !1;
+    const n = this.callbacks, o = this.callbacksCount;
+    if (this.callbacks = [], this.callbacksCount = 0, this.startId = this.nextId, o > 0)
+      for (let r = 0; r < n.length; r += 1)
+        n[r]?.(t);
+  };
+  request(t) {
+    const n = this.nextId;
+    this.nextId += 1, this.callbacks.push(t), this.callbacksCount += 1;
+    const o = process.env.NODE_ENV !== "production" && Dt !== requestAnimationFrame && (Dt = requestAnimationFrame, !0);
+    return (!this.isScheduled || o) && (requestAnimationFrame(this.tick), this.isScheduled = !0), n;
+  }
+  cancel(t) {
+    const n = t - this.startId;
+    n < 0 || n >= this.callbacks.length || (this.callbacks[n] = null, this.callbacksCount -= 1);
+  }
+}
+let De = new fr();
+class re {
+  static create() {
+    return new re();
+  }
+  static request(t) {
+    return De.request(t);
+  }
+  static cancel(t) {
+    return De.cancel(t);
+  }
+  currentId = we;
+  /**
+   * Executes `fn` after `delay`, clearing any previously scheduled call.
+   */
+  request(t) {
+    this.cancel(), this.currentId = De.request(() => {
+      this.currentId = we, t();
+    });
+  }
+  cancel = () => {
+    this.currentId !== we && (De.cancel(this.currentId), this.currentId = we);
+  };
+  disposeEffect = () => this.cancel;
+}
+function pr() {
+  const e = ee(re.create).current;
+  return Kt(e.disposeEffect), e;
+}
+function gr(e) {
+  return e == null ? e : "current" in e ? e.current : e;
+}
+function mr(e, t = !1) {
+  const n = pr();
+  return A((o, r = null) => {
+    n.cancel();
+    const i = gr(e);
+    if (i == null)
+      return;
+    const s = i, f = () => {
+      mn.flushSync(o);
+    };
+    if (typeof s.getAnimations != "function" || globalThis.BASE_UI_ANIMATIONS_DISABLED) {
+      o();
+      return;
+    }
+    function c() {
+      Promise.all(s.getAnimations().map((a) => a.finished)).then(() => {
+        r?.aborted || f();
+      }, () => {
+        if (r?.aborted)
+          return;
+        if (s.getAnimations().some((d) => d.pending || d.playState !== "finished")) {
+          c();
+          return;
+        }
+        f();
+      });
+    }
+    if (t) {
+      const a = "data-starting-style";
+      if (!s.hasAttribute(a)) {
+        n.request(c);
+        return;
+      }
+      const d = new MutationObserver(() => {
+        s.hasAttribute(a) || (d.disconnect(), c());
+      });
+      d.observe(s, {
+        attributes: !0,
+        attributeFilter: [a]
+      }), r?.addEventListener("abort", () => d.disconnect(), {
+        once: !0
+      });
+      return;
+    }
+    n.request(c);
+  });
+}
+function hr(e) {
+  const {
+    enabled: t = !0,
+    open: n,
+    ref: o,
+    onComplete: r
+  } = e, i = A(r), s = mr(o, n);
+  u.useEffect(() => {
+    if (!t)
+      return;
+    const f = new AbortController();
+    return s(i, f.signal), () => {
+      f.abort();
+    };
+  }, [t, n, i, s]);
+}
+const br = {
+  "data-starting-style": ""
+}, yr = {
+  "data-ending-style": ""
+}, Rr = {
+  transitionStatus(e) {
+    return e === "starting" ? br : e === "ending" ? yr : null;
+  }
+};
+function Ir(e, t = !1, n = !1) {
+  const [o, r] = u.useState(e && t ? "idle" : void 0), [i, s] = u.useState(e);
+  return e && !i && (s(!0), r("starting")), !e && i && o !== "ending" && !n && r("ending"), !e && !i && o === "ending" && r(void 0), K(() => {
+    if (!e && i && o !== "ending" && n) {
+      const f = re.request(() => {
+        r("ending");
+      });
+      return () => {
+        re.cancel(f);
+      };
+    }
+  }, [e, i, o, n]), K(() => {
+    if (!e || t)
+      return;
+    const f = re.request(() => {
+      r(void 0);
+    });
+    return () => {
+      re.cancel(f);
+    };
+  }, [t, e]), K(() => {
+    if (!e || !t)
+      return;
+    e && i && o !== "idle" && r("starting");
+    const f = re.request(() => {
+      r("idle");
+    });
+    return () => {
+      re.cancel(f);
+    };
+  }, [t, e, i, o]), {
+    mounted: i,
+    setMounted: s,
+    transitionStatus: o
+  };
+}
+const zt = /* @__PURE__ */ u.forwardRef(function(t, n) {
+  const {
+    render: o,
+    id: r,
+    className: i,
+    style: s,
+    ...f
+  } = t, c = ce(r), a = he(!1), d = ft(), {
+    setMessageIds: p
+  } = ie(), y = {
+    ...a.state,
+    disabled: a.disabled || d.disabled
+  };
+  return K(() => {
+    if (c)
+      return p((m) => m.concat(c)), () => {
+        p((m) => m.filter((v) => v !== c));
+      };
+  }, [c, p]), te("p", t, {
+    ref: n,
+    state: y,
+    props: [{
+      id: c
+    }, f],
+    stateAttributesMapping: me
+  });
+});
+process.env.NODE_ENV !== "production" && (zt.displayName = "FieldDescription");
+function Er({
+  controlled: e,
+  default: t,
+  name: n,
+  state: o = "value"
+}) {
+  const {
+    current: r
+  } = u.useRef(e !== void 0), [i, s] = u.useState(t), f = r ? e : i;
+  if (process.env.NODE_ENV !== "production") {
+    u.useEffect(() => {
+      r !== (e !== void 0) && ge([`A component is changing the ${r ? "" : "un"}controlled ${o} state of ${n} to be ${r ? "un" : ""}controlled.`, "Elements should not switch from uncontrolled to controlled (or vice versa).", `Decide between using a controlled or uncontrolled ${n} element for the lifetime of the component.`, "The nature of the state is determined during the first render. It's considered controlled if the value is not `undefined`.", "More info: https://fb.me/react-controlled-components"].join(`
+`));
+    }, [o, n, e]);
+    const {
+      current: a
+    } = u.useRef(t);
+    u.useEffect(() => {
+      !r && Mt(a) !== Mt(t) && ge([`A component is changing the default ${o} state of an uncontrolled ${n} after being initialized. To suppress this warning opt to use a controlled ${n}.`].join(`
+`));
+    }, [t]);
+  }
+  const c = u.useCallback((a) => {
+    r || s(a);
+  }, []);
+  return [f, c];
+}
+function Mt(e) {
+  let t = 0;
+  const n = /* @__PURE__ */ new WeakMap();
+  try {
+    return JSON.stringify(e, function(i, s) {
+      if (!(i === "_owner" && this != null && typeof this == "object" && "$$typeof" in this)) {
+        if (typeof s == "bigint")
+          return `__bigint__:${s}`;
+        if (s !== null && typeof s == "object") {
+          const f = n.get(s);
+          if (f !== void 0)
+            return `__object__:${f}`;
+          n.set(s, t), t += 1;
+        }
+        return s;
+      }
+    }) ?? `__top__:${typeof e}`;
+  } catch {
+    return "__unserializable__";
+  }
+}
+function vr(e, t, n, o, r = !0, i) {
+  const {
+    registerFieldControl: s
+  } = he(), f = ee(() => /* @__PURE__ */ Symbol());
+  K(() => {
+    const c = f.current;
+    if (!r) {
+      s(c, void 0);
+      return;
+    }
+    s(c, {
+      controlRef: e,
+      getValue: o,
+      id: t,
+      name: i,
+      value: n
+    });
+  }, [e, r, o, t, i, s, f, n]), K(() => {
+    const c = f.current;
+    return () => {
+      s(c, void 0);
+    };
+  }, [s, f]);
+}
+const Cr = "none";
+function xr(e, t, n, o) {
+  let r = !1, i = !1;
+  const s = Z;
+  return {
+    reason: e,
+    event: t ?? new Event("base-ui"),
+    cancel() {
+      r = !0;
+    },
+    allowPropagation() {
+      i = !0;
+    },
+    get isCanceled() {
+      return r;
+    },
+    get isPropagationAllowed() {
+      return i;
+    },
+    trigger: n,
+    ...s
+  };
+}
+const Yt = /* @__PURE__ */ u.forwardRef(function(t, n) {
+  const {
+    render: o,
+    className: r,
+    style: i,
+    disabled: s = !1,
+    ...f
+  } = t, {
+    state: c,
+    disabled: a
+  } = he(!1), d = a || s, p = {
+    ...c,
+    disabled: d
+  }, y = u.useMemo(() => ({
+    disabled: d
+  }), [d]), g = te("div", t, {
+    ref: n,
+    state: p,
+    props: f,
+    stateAttributesMapping: me
+  });
+  return /* @__PURE__ */ L(st, {
+    children: /* @__PURE__ */ L(dt.Provider, {
+      value: y,
+      children: g
+    })
+  });
+});
+process.env.NODE_ENV !== "production" && (Yt.displayName = "FieldItem");
+const Xt = {
+  clipPath: "inset(50%)",
+  overflow: "hidden",
+  whiteSpace: "nowrap",
+  border: 0,
+  padding: 0,
+  width: 1,
+  height: 1,
+  margin: -1
+}, Nr = {
+  ...Xt,
+  position: "fixed",
+  top: 0,
+  left: 0
+}, _r = {
+  ...Xt,
+  position: "absolute"
+}, Ye = {
+  checked(e) {
+    return e ? {
+      "data-checked": ""
+    } : {
+      "data-unchecked": ""
+    };
+  },
+  ...Rr,
+  ...me
+};
+function ke(e, t, {
+  detail: n = 0
+} = {}) {
+  e.dispatchEvent(new (Ne(e)).PointerEvent("click", {
+    bubbles: !0,
+    cancelable: !0,
+    composed: !0,
+    detail: n,
+    shiftKey: t.shiftKey,
+    ctrlKey: t.ctrlKey,
+    altKey: t.altKey,
+    metaKey: t.metaKey
+  }));
+}
+const pt = /* @__PURE__ */ u.createContext(void 0);
+process.env.NODE_ENV !== "production" && (pt.displayName = "CompositeRootContext");
+function Zt(e = !1) {
+  const t = u.useContext(pt);
+  if (t === void 0 && !e)
+    throw new Error(process.env.NODE_ENV !== "production" ? "Base UI: CompositeRootContext is missing. Composite parts must be placed within <Composite.Root>." : xe(16));
+  return t;
+}
+function wr(e) {
+  const {
+    focusableWhenDisabled: t,
+    disabled: n,
+    composite: o = !1,
+    tabIndex: r = 0,
+    isNativeButton: i
+  } = e, s = o && t !== !1, f = o && t === !1;
+  return {
+    props: u.useMemo(() => {
+      const a = {
+        // allow Tabbing away from focusableWhenDisabled elements
+        onKeyDown(d) {
+          n && t && d.key !== "Tab" && d.preventDefault();
+        }
+      };
+      return o || (a.tabIndex = r, !i && n && (a.tabIndex = t ? r : -1)), (i && (t || s) || !i && n) && (a["aria-disabled"] = n), i && (!t || f) && (a.disabled = n), a;
+    }, [o, n, t, s, f, i, r])
+  };
+}
+function Dr(e = {}) {
+  const {
+    disabled: t = !1,
+    focusableWhenDisabled: n,
+    tabIndex: o = 0,
+    native: r = !0,
+    composite: i
+  } = e, s = u.useRef(null), f = Zt(!0), c = i ?? f !== void 0, {
+    props: a
+  } = wr({
+    focusableWhenDisabled: n,
+    disabled: t,
+    composite: c,
+    tabIndex: o,
+    isNativeButton: r
+  });
+  process.env.NODE_ENV !== "production" && u.useEffect(() => {
+    if (!s.current)
+      return;
+    const g = Me(s.current);
+    if (r) {
+      if (!g) {
+        const m = ue.captureOwnerStack?.() || "";
+        ge(`A component that acts as a button expected a native <button> because the \`nativeButton\` prop is true. Rendering a non-<button> removes native button semantics, which can impact forms and accessibility. Use a real <button> in the \`render\` prop, or set \`nativeButton\` to \`false\`.${m}`);
+      }
+    } else if (g) {
+      const m = ue.captureOwnerStack?.() || "";
+      ge(`A component that acts as a button expected a non-<button> because the \`nativeButton\` prop is false. Rendering a <button> keeps native behavior while Base UI applies non-native attributes and handlers, which can add unintended extra attributes (such as \`role\` or \`aria-disabled\`). Use a non-<button> in the \`render\` prop, or set \`nativeButton\` to \`true\`.${m}`);
+    }
+  }, [r]);
+  const d = u.useCallback(() => {
+    const g = s.current;
+    Me(g) && c && t && a.disabled === void 0 && g.disabled && (g.disabled = !1);
+  }, [t, a.disabled, c]);
+  K(d, [d]);
+  const p = u.useCallback((g = {}) => {
+    const {
+      onClick: m,
+      onMouseDown: v,
+      onKeyUp: R,
+      onKeyDown: x,
+      onPointerDown: N,
+      ...T
+    } = g;
+    return Le({
+      onClick(l) {
+        if (t) {
+          l.preventDefault();
+          return;
+        }
+        m?.(l);
+      },
+      onMouseDown(l) {
+        t || v?.(l);
+      },
+      onKeyDown(l) {
+        if (t || (Fe(l), x?.(l), l.baseUIHandlerPrevented))
+          return;
+        const h = l.target === l.currentTarget, C = l.currentTarget, I = Me(C), D = !r && Mr(C), G = h && (r ? I : !D), b = l.key === "Enter", O = l.key === " ", E = C.getAttribute("role"), H = E?.startsWith("menuitem") || E === "option" || E === "gridcell";
+        if (h && c && O) {
+          if (l.defaultPrevented && H)
+            return;
+          l.preventDefault(), (!r || I) && (l.preventBaseUIHandler(), ke(C, l));
+          return;
+        }
+        if (!G || r || !O && !b) {
+          h && D && O && l.preventDefault();
+          return;
+        }
+        l.defaultPrevented || (l.preventDefault(), b && (l.preventBaseUIHandler(), ke(C, l)));
+      },
+      onKeyUp(l) {
+        if (!t) {
+          if (Fe(l), R?.(l), l.target === l.currentTarget && r && c && Me(l.currentTarget) && l.key === " ") {
+            l.preventDefault();
+            return;
+          }
+          l.baseUIHandlerPrevented || l.target === l.currentTarget && !r && !c && !l.defaultPrevented && l.key === " " && (l.preventBaseUIHandler(), ke(l.currentTarget, l));
+        }
+      },
+      onPointerDown(l) {
+        if (t) {
+          l.preventDefault();
+          return;
+        }
+        N?.(l);
+      }
+    }, r ? {
+      type: "button"
+    } : {
+      role: "button"
+    }, a, T);
+  }, [t, a, c, r]), y = A((g) => {
+    s.current = g, d();
+  });
+  return {
+    getButtonProps: p,
+    buttonRef: y
+  };
+}
+function Me(e) {
+  return _e(e) && e.tagName === "BUTTON";
+}
+function Mr(e) {
+  return _e(e) && e.tagName === "A" && !!e.href;
+}
+const Jt = "data-composite-item-active", gt = /* @__PURE__ */ u.createContext({
+  register: () => {
+  },
+  unregister: () => {
+  },
+  subscribeMapChange: () => () => {
+  },
+  nextIndexRef: {
+    current: 0
+  }
+});
+process.env.NODE_ENV !== "production" && (gt.displayName = "CompositeListContext");
+function Pr() {
+  return u.useContext(gt);
+}
+function Or(e = {}) {
+  const {
+    guess: t,
+    label: n,
+    metadata: o,
+    textRef: r,
+    index: i
+  } = e, {
+    register: s,
+    unregister: f,
+    subscribeMapChange: c,
+    nextIndexRef: a
+  } = Pr(), d = u.useRef(-1), [p, y] = u.useState(i == null && t ? () => {
+    if (d.current === -1) {
+      const R = a.current;
+      a.current += 1, d.current = R;
+    }
+    return d.current;
+  } : -1), g = i ?? p, m = u.useRef(null), v = u.useCallback((R) => {
+    const x = m.current;
+    x && f(x), m.current = R, R && s(R, {
+      metadata: o ?? null,
+      index: i ?? null,
+      label: n,
+      textRef: r
+    });
+  }, [i, s, f, o, n, r]);
+  return K(() => {
+    if (i == null)
+      return c((R) => {
+        const x = m.current ? R.get(m.current)?.index : null;
+        x != null && y(x);
+      });
+  }, [i, c]), {
+    ref: v,
+    index: g
+  };
+}
+function kr(e = {}) {
+  const {
+    highlightItemOnHover: t,
+    highlightedIndex: n,
+    onHighlightedIndexChange: o
+  } = Zt(), {
+    ref: r,
+    index: i
+  } = Or(e), s = n === i, f = u.useRef(null), c = Ce(r, f);
+  return {
+    compositeProps: {
+      tabIndex: s ? 0 : -1,
+      onFocus() {
+        o(i);
+      },
+      onMouseMove() {
+        const d = f.current;
+        if (!t || !d)
+          return;
+        const p = d.hasAttribute("disabled") || d.ariaDisabled === "true";
+        !s && !p && d.focus();
+      }
+    },
+    compositeRef: c,
+    index: i
+  };
+}
+function Ar(e) {
+  const {
+    render: t,
+    className: n,
+    style: o,
+    state: r = Z,
+    props: i = Ee,
+    refs: s = Ee,
+    metadata: f,
+    stateAttributesMapping: c,
+    tag: a = "div",
+    ...d
+  } = e, {
+    compositeProps: p,
+    compositeRef: y
+  } = kr({
+    metadata: f
+  });
+  return te(a, e, {
+    state: r,
+    // The composite ref attaches first so an outer item wins when nested items share a DOM node.
+    ref: [y, ...s],
+    props: [p, ...i, d],
+    stateAttributesMapping: c
+  });
+}
+const mt = /* @__PURE__ */ u.createContext(void 0);
+process.env.NODE_ENV !== "production" && (mt.displayName = "RadioGroupContext");
+function Fr() {
+  return u.useContext(mt);
+}
+function Vr(e) {
+  if (e == null)
+    return "";
+  if (typeof e == "string")
+    return e;
+  try {
+    return JSON.stringify(e);
+  } catch {
+    return String(e);
+  }
+}
+const ht = /* @__PURE__ */ u.createContext(void 0);
+process.env.NODE_ENV !== "production" && (ht.displayName = "RadioRootContext");
+function Sr() {
+  const e = u.useContext(ht);
+  if (e === void 0)
+    throw new Error(process.env.NODE_ENV !== "production" ? "Base UI: RadioRootContext is missing. Radio parts must be placed within <Radio.Root>." : xe(52));
+  return e;
+}
+const Qt = /* @__PURE__ */ u.forwardRef(function(t, n) {
+  const {
+    render: o,
+    className: r,
+    disabled: i = !1,
+    readOnly: s = !1,
+    required: f = !1,
+    "aria-labelledby": c,
+    value: a,
+    inputRef: d,
+    nativeButton: p = !1,
+    id: y,
+    style: g,
+    ...m
+  } = t, v = Fr(), {
+    disabled: R,
+    readOnly: x,
+    required: N,
+    form: T,
+    checkedValue: l,
+    touched: h = !1,
+    validation: C,
+    name: I,
+    setCheckedValue: D = W,
+    setTouched: G = W,
+    registerInputRef: b = W
+  } = v ?? {}, {
+    setTouched: O,
+    setFilled: E,
+    state: H,
+    disabled: F
+  } = he(), $ = ft(), {
+    labelId: U,
+    getDescriptionProps: Y
+  } = ie(), w = F || $.disabled || R || i, M = x || s, S = N || f, _ = T, V = v ? l === a : a === "", k = u.useRef(null), B = u.useRef(null), J = C?.registerInput, q = u.useCallback((j) => J?.(j, {
+    controlRef: k,
+    value: void 0
+  }), [J]), Q = Ce(d, B, b, q);
+  K(() => {
+    B.current?.checked && E(!0);
+  }, [E]), K(() => {
+    if (B.current) {
+      if (w && V) {
+        b(null);
+        return;
+      }
+      b(B.current);
+    }
+  }, [V, w, b]);
+  const oe = ce(), se = An({
+    id: y,
+    implicit: !1,
+    controlRef: k
+  }), ne = p ? void 0 : se, ae = wn(c, U, B, !p, ne), le = {
+    role: "radio",
+    "aria-checked": V,
+    "aria-labelledby": ae,
+    [Jt]: V ? "" : void 0,
+    id: p ? se : oe,
+    onKeyDown(j) {
+      j.key === "Enter" && j.preventDefault();
+    },
+    onClick(j) {
+      if (j.defaultPrevented || w || M)
+        return;
+      j.preventDefault();
+      const be = B.current;
+      be && ke(be, j);
+    },
+    onFocus(j) {
+      j.defaultPrevented || w || M || !h || (B.current?.click(), G(!1));
+    }
+  }, {
+    getButtonProps: de,
+    buttonRef: P
+  } = Dr({
+    disabled: w,
+    native: p,
+    composite: !1
+  }), z = {
+    type: "radio",
+    ref: Q,
+    form: _,
+    id: ne,
+    name: I,
+    tabIndex: -1,
+    style: I ? _r : Nr,
+    "aria-hidden": !0,
+    ...a !== void 0 ? {
+      value: Vr(a)
+    } : Z,
+    disabled: w,
+    checked: V,
+    required: S,
+    readOnly: M,
+    onChange(j) {
+      if (j.nativeEvent.defaultPrevented || w || M || a === void 0)
+        return;
+      const be = xr(Cr, j.nativeEvent);
+      D(a, be), !be.isCanceled && O(!0);
+    },
+    onClick(j) {
+      j.stopPropagation();
+    },
+    onFocus() {
+      k.current?.focus();
+    }
+  }, X = u.useMemo(() => ({
+    ...H,
+    required: S,
+    disabled: w,
+    readOnly: M,
+    checked: V
+  }), [H, w, M, V, S]), dn = X, yt = v !== void 0, Rt = [n, k, P], It = [le, m, de, Y, C ? (j) => C.getValidationProps(w, j) : Z], fn = te("span", t, {
+    enabled: !yt,
+    state: X,
+    ref: Rt,
+    props: It,
+    stateAttributesMapping: Ye
+  });
+  return /* @__PURE__ */ Ie(ht.Provider, {
+    value: dn,
+    children: [yt ? /* @__PURE__ */ L(Ar, {
+      tag: "span",
+      render: o,
+      className: r,
+      style: g,
+      state: X,
+      refs: Rt,
+      props: It,
+      stateAttributesMapping: Ye
+    }) : fn, /* @__PURE__ */ L("input", {
+      ...z,
+      suppressHydrationWarning: !0
+    })]
+  });
+});
+process.env.NODE_ENV !== "production" && (Qt.displayName = "RadioRoot");
+const en = /* @__PURE__ */ u.forwardRef(function(t, n) {
+  const {
+    render: o,
+    className: r,
+    style: i,
+    keepMounted: s = !1,
+    ...f
+  } = t, c = Sr(), a = c.checked, {
+    mounted: d,
+    transitionStatus: p,
+    setMounted: y
+  } = Ir(a), g = {
+    ...c,
+    transitionStatus: p
+  }, m = u.useRef(null), v = s || d, R = te("span", t, {
+    ref: [n, m],
+    state: g,
+    props: f,
+    stateAttributesMapping: Ye
+  });
+  return hr({
+    open: a,
+    ref: m,
+    onComplete() {
+      a || y(!1);
+    }
+  }), v ? R : null;
+});
+process.env.NODE_ENV !== "production" && (en.displayName = "RadioIndicator");
+const tn = pn(null), Lr = () => {
+  const e = gn(tn);
+  if (!e)
+    throw new Error("RadioButtonGroupItem must be used within a RadioButtonGroup component");
+  return e;
+}, Tr = {
+  "purpur-radio-button-group-item": "_purpur-radio-button-group-item_1kvi3_1",
+  "purpur-radio-button-group-item__label": "_purpur-radio-button-group-item__label_1kvi3_10",
+  "purpur-radio-button-group-item__radio": "_purpur-radio-button-group-item__radio_1kvi3_29",
+  "purpur-radio-button-group-item__radio-container": "_purpur-radio-button-group-item__radio-container_1kvi3_47",
+  "purpur-radio-button-group-item__radio-indicator": "_purpur-radio-button-group-item__radio-indicator_1kvi3_94",
+  "purpur-radio-button-group-item__description": "_purpur-radio-button-group-item__description_1kvi3_114"
+}, fe = At.bind(Tr), pe = "purpur-radio-button-group-item", bt = nt(
+  ({ disabled: e, id: t, value: n, label: o, "data-testid": r, helperText: i, className: s }, f) => {
+    const c = Lr(), a = e || c.disabled;
+    return /* @__PURE__ */ Ie(
+      Yt,
+      {
+        disabled: a,
+        className: fe(s, `${pe}`),
+        "data-testid": r,
+        children: [
+          /* @__PURE__ */ Ie(
+            qt,
+            {
+              "data-testid": r ? `${r}-label` : void 0,
+              className: fe(`${pe}__label`),
+              "data-negative": c.negative,
+              children: [
+                /* @__PURE__ */ L("span", { className: fe(`${pe}__radio-container`), children: /* @__PURE__ */ L(
+                  Qt,
+                  {
+                    className: fe(`${pe}__radio`),
+                    "data-testid": r ? `${r}-radio` : void 0,
+                    "data-negative": c.negative,
+                    id: t,
+                    ref: f,
+                    value: n,
+                    children: /* @__PURE__ */ L(
+                      en,
+                      {
+                        className: fe(`${pe}__radio-indicator`),
+                        keepMounted: !0,
+                        "data-negative": c.negative
+                      }
+                    )
+                  }
+                ) }),
+                o
+              ]
+            }
+          ),
+          i && /* @__PURE__ */ L(
+            zt,
+            {
+              "data-testid": r && `${r}-helper-text`,
+              "data-negative": c.negative,
+              className: fe(`${pe}__description`),
+              dir: c.dir,
+              children: i
+            }
+          )
+        ]
+      },
+      `radio-item-${n}`
+    );
+  }
+);
+bt.displayName = "RadioButtonGroupItem";
+const nn = /* @__PURE__ */ u.forwardRef(function(t, n) {
+  const {
+    render: o,
+    className: r,
+    style: i,
+    disabled: s = !1,
+    ...f
+  } = t, [c, a] = u.useState(void 0), p = Ve(!0)?.disabled || s, g = te("fieldset", t, {
+    ref: n,
+    state: {
+      disabled: p
+    },
+    props: [{
+      "aria-labelledby": c,
+      disabled: p
+    }, f]
+  }), m = u.useMemo(() => ({
+    legendId: c,
+    setLegendId: a,
+    disabled: p
+  }), [c, a, p]);
+  return /* @__PURE__ */ L(ot.Provider, {
+    value: m,
+    children: g
+  });
+});
+process.env.NODE_ENV !== "production" && (nn.displayName = "FieldsetRoot");
+const rn = /* @__PURE__ */ u.forwardRef(function(t, n) {
+  const {
+    render: o,
+    className: r,
+    style: i,
+    id: s,
+    ...f
+  } = t, {
+    disabled: c,
+    setLegendId: a
+  } = Ve(), d = Vt(s, a);
+  return te("div", t, {
+    state: {
+      disabled: c
+    },
+    ref: n,
+    props: [{
+      id: d
+    }, f]
+  });
+});
+process.env.NODE_ENV !== "production" && (rn.displayName = "FieldsetLegend");
+const Xe = "ArrowUp", Ze = "ArrowDown", Je = "ArrowLeft", Qe = "ArrowRight", et = "Home", tt = "End", Br = /* @__PURE__ */ new Set([Xe, Ze, Je, Qe, et, tt]), on = "Shift", $r = [on, "Control", "Alt", "Meta"];
+function Ur(e) {
+  return _e(e) && e.tagName === "INPUT";
+}
+function Pt(e) {
+  return !!(Ur(e) && e.selectionStart != null || _e(e) && e.tagName === "TEXTAREA");
+}
+function Ot(e, t, n, o) {
+  if (!e || !t || !t.scrollTo)
+    return;
+  let r = e.scrollLeft, i = e.scrollTop;
+  const s = e.clientWidth < e.scrollWidth, f = e.clientHeight < e.scrollHeight;
+  if (s && o !== "vertical") {
+    const c = kt(e, t, "left"), a = Pe(e), d = Pe(t);
+    n === "ltr" && (c + t.offsetWidth + d.scrollMarginRight > e.scrollLeft + e.clientWidth - a.scrollPaddingRight ? r = c + t.offsetWidth + d.scrollMarginRight - e.clientWidth + a.scrollPaddingRight : c - d.scrollMarginLeft < e.scrollLeft + a.scrollPaddingLeft && (r = c - d.scrollMarginLeft - a.scrollPaddingLeft)), n === "rtl" && (c - d.scrollMarginLeft < e.scrollLeft + a.scrollPaddingLeft ? r = c - d.scrollMarginLeft - a.scrollPaddingLeft : c + t.offsetWidth + d.scrollMarginRight > e.scrollLeft + e.clientWidth - a.scrollPaddingRight && (r = c + t.offsetWidth + d.scrollMarginRight - e.clientWidth + a.scrollPaddingRight));
+  }
+  if (f && o !== "horizontal") {
+    const c = kt(e, t, "top"), a = Pe(e), d = Pe(t);
+    c - d.scrollMarginTop < e.scrollTop + a.scrollPaddingTop ? i = c - d.scrollMarginTop - a.scrollPaddingTop : c + t.offsetHeight + d.scrollMarginBottom > e.scrollTop + e.clientHeight - a.scrollPaddingBottom && (i = c + t.offsetHeight + d.scrollMarginBottom - e.clientHeight + a.scrollPaddingBottom);
+  }
+  e.scrollTo({
+    left: r,
+    top: i,
+    behavior: "auto"
+  });
+}
+function kt(e, t, n) {
+  const o = n === "left" ? "offsetLeft" : "offsetTop";
+  let r = 0;
+  for (; t.offsetParent && (r += t[o], t.offsetParent !== e); )
+    t = t.offsetParent;
+  return r;
+}
+function Pe(e) {
+  const t = getComputedStyle(e);
+  return {
+    scrollMarginTop: parseFloat(t.scrollMarginTop) || 0,
+    scrollMarginRight: parseFloat(t.scrollMarginRight) || 0,
+    scrollMarginBottom: parseFloat(t.scrollMarginBottom) || 0,
+    scrollMarginLeft: parseFloat(t.scrollMarginLeft) || 0,
+    scrollPaddingTop: parseFloat(t.scrollPaddingTop) || 0,
+    scrollPaddingRight: parseFloat(t.scrollPaddingRight) || 0,
+    scrollPaddingBottom: parseFloat(t.scrollPaddingBottom) || 0,
+    scrollPaddingLeft: parseFloat(t.scrollPaddingLeft) || 0
+  };
+}
+function Hr(e) {
+  const {
+    children: t,
+    elementsRef: n,
+    labelsRef: o,
+    onMapChange: r
+  } = e, i = A(r), [, s] = u.useState(!1), f = ee(Gr).current, c = ee(Kr).current, a = u.useRef(0), d = u.useRef(!0), p = u.useRef([]), y = u.useRef(null), g = A(() => {
+    d.current || (d.current = !0, s((h) => !h));
+  }), m = A((h, C) => {
+    c.set(h, C), g();
+  }), v = A((h) => {
+    c.delete(h), g();
+  }), R = A((h) => {
+    const C = /* @__PURE__ */ new Map();
+    return n.current.length = 0, o && (o.current.length = 0), h.forEach((I) => {
+      C.set(I.element, {
+        ...I.registration.metadata ?? {},
+        index: I.index
+      }), n.current[I.index] = I.element, o && (o.current[I.index] = I.registration.label !== void 0 ? I.registration.label : I.registration.textRef?.current?.textContent ?? I.element.textContent);
+    }), a.current = n.current.length, C;
+  });
+  function x(h) {
+    if (y.current?.disconnect(), y.current = null, typeof MutationObserver != "function" || h.length < 2)
+      return;
+    const C = new MutationObserver((D) => {
+      if (!qr(D))
+        return;
+      let G = null;
+      for (const b of h)
+        if (b.isConnected) {
+          if (G && sn(G, b) > 0) {
+            C.disconnect(), g();
+            return;
+          }
+          G = b;
+        }
+    });
+    y.current = C;
+    const I = /* @__PURE__ */ new Set();
+    for (let D = 1; D < h.length; D += 1) {
+      const G = jr(h[D - 1], h[D]);
+      G && I.add(G);
+    }
+    I.forEach((D) => C.observe(D, {
+      childList: !0
+    }));
+  }
+  const N = A(() => {
+    const [h, C] = Wr(c), I = R(h);
+    x(C), p.current = h, d.current = !1, f.forEach((D) => D(I)), i(I);
+  });
+  K(() => (d.current || R(p.current), () => {
+    n.current = [], o && (o.current = []);
+  }), [n, o, R]), K(() => {
+    d.current && N();
+  }), K(() => () => {
+    y.current?.disconnect(), d.current = !0;
+  }, []);
+  const T = A((h) => (f.add(h), () => {
+    f.delete(h);
+  })), l = u.useMemo(() => ({
+    register: m,
+    unregister: v,
+    subscribeMapChange: T,
+    nextIndexRef: a
+  }), [m, v, T, a]);
+  return /* @__PURE__ */ L(gt.Provider, {
+    value: l,
+    children: t
+  });
+}
+function Kr() {
+  return /* @__PURE__ */ new Map();
+}
+function Gr() {
+  return /* @__PURE__ */ new Set();
+}
+function Wr(e) {
+  const t = /* @__PURE__ */ new Set(), n = [], o = [];
+  e.forEach((i, s) => {
+    if (!s.isConnected)
+      return;
+    const f = i.index, c = {
+      index: f ?? -1,
+      element: s,
+      registration: i
+    };
+    f === null ? o.push(c) : f >= 0 && (t.add(f), n.push(c));
+  });
+  let r = 0;
+  return o.sort((i, s) => sn(i.element, s.element)), o.forEach((i) => {
+    for (; t.has(r); )
+      r += 1;
+    i.index = r, n.push(i), r += 1;
+  }), t.size > 0 && n.sort((i, s) => i.index - s.index), [n, o.map((i) => i.element)];
+}
+function jr(e, t) {
+  let n = e.parentElement;
+  for (; n && !n.contains(t); )
+    n = n.parentElement;
+  return n;
+}
+function qr(e) {
+  for (const t of e)
+    for (let n = 0; n < t.removedNodes.length; n += 1)
+      if (t.removedNodes[n].isConnected)
+        return !0;
+  return !1;
+}
+function sn(e, t) {
+  return e.compareDocumentPosition(t) & Node.DOCUMENT_POSITION_FOLLOWING ? -1 : 1;
+}
+function zr(e) {
+  return e == null || e.hasAttribute("disabled") || e.getAttribute("aria-disabled") === "true";
+}
+const Yr = [];
+function Xr(e) {
+  const {
+    loopFocus: t = !0,
+    orientation: n = "both",
+    grid: o,
+    onLoop: r,
+    direction: i,
+    highlightedIndex: s,
+    onHighlightedIndexChange: f,
+    rootRef: c,
+    enableHomeAndEndKeys: a = !1,
+    stopEventPropagation: d,
+    disabledIndices: p,
+    modifierKeys: y = Yr
+  } = e, [g, m] = u.useState(0), v = o != null, R = u.useRef(null), x = Ce(R, c), N = u.useRef([]), T = u.useRef(!1), l = s ?? g, h = A((b, O = !1) => {
+    if ((f ?? m)(b), O) {
+      const E = N.current[b];
+      Ot(R.current, E, i, n);
+    }
+  }), C = A((b) => {
+    if (b.size === 0 || T.current)
+      return;
+    T.current = !0;
+    const O = Array.from(b.keys()), E = O.find((F) => F?.hasAttribute(Jt)) ?? null, H = E ? b.get(E)?.index ?? -1 : -1;
+    if (H !== -1)
+      h(H);
+    else if (Ge(O, l, p)) {
+      const F = Re(O, {
+        disabledIndices: p
+      });
+      Be(O, F) || h(F);
+    }
+    Ot(R.current, E, i, n);
+  });
+  K(() => {
+    if (p == null || s != null || !T.current)
+      return;
+    const b = N.current;
+    if (Ge(b, l, p)) {
+      const O = Re(b, {
+        disabledIndices: p
+      });
+      Be(b, O) || h(O);
+    }
+  }, [p, s, l, N, h]);
+  const I = A((b, O, E) => r ? r(b, O, E, N) : E), D = A((b) => {
+    const O = b.key === et || b.key === tt;
+    if (!Br.has(b.key) || !a && O || Zr(b, y) || !R.current)
+      return;
+    const H = i === "rtl", F = H ? Je : Qe, $ = H ? Qe : Je, U = n === "vertical" ? Ze : F, Y = n === "vertical" ? Xe : $, w = Ke(b.nativeEvent);
+    if (w != null && Pt(w) && !zr(w)) {
+      const B = w.selectionStart, J = w.selectionEnd, q = w.value;
+      if (B == null || b.shiftKey || B !== J || b.key !== Y && B < q.length || b.key !== U && B > 0)
+        return;
+    }
+    let M = l;
+    const S = Sn(N, p), _ = Ln(N, p);
+    o != null && (M = o({
+      disabledIndices: p,
+      elementsRef: N,
+      event: b,
+      highlightedIndex: l,
+      loopFocus: t,
+      maxIndex: _,
+      minIndex: S,
+      onLoop: I,
+      orientation: n,
+      rtl: H
+    }));
+    const V = n !== "vertical" && b.key === F || n !== "horizontal" && b.key === Ze, k = n !== "vertical" && b.key === $ || n !== "horizontal" && b.key === Xe;
+    a && (b.key === et ? M = S : b.key === tt && (M = _)), M === l && (V || k) && (t && M === _ && V ? (M = S, r && (M = r(b, l, M, N))) : t && M === S && k ? (M = _, r && (M = r(b, l, M, N))) : M = Re(N.current, {
+      startingIndex: M,
+      decrement: k,
+      disabledIndices: p
+    })), M !== l && !Be(N.current, M) && (d && b.stopPropagation(), (v || O || V || k) && b.preventDefault(), h(M, !0), queueMicrotask(() => {
+      N.current[M]?.focus();
+    }));
+  });
+  return {
+    props: {
+      ref: x,
+      onFocus(b) {
+        const O = R.current, E = Ke(b.nativeEvent);
+        !O || E == null || !Pt(E) || E.setSelectionRange(0, E.value.length);
+      },
+      onKeyDown: D
+    },
+    highlightedIndex: l,
+    onHighlightedIndexChange: h,
+    elementsRef: N,
+    onMapChange: C,
+    relayKeyboardEvent: D
+  };
+}
+function Zr(e, t) {
+  for (const n of $r)
+    if (!t.includes(n) && e.getModifierState(n))
+      return !0;
+  return !1;
+}
+const an = /* @__PURE__ */ u.createContext(void 0);
+process.env.NODE_ENV !== "production" && (an.displayName = "DirectionContext");
+function Jr() {
+  return u.useContext(an)?.direction ?? "ltr";
+}
+function Qr(e) {
+  const {
+    render: t,
+    className: n,
+    style: o,
+    refs: r = Ee,
+    props: i = Ee,
+    state: s = Z,
+    stateAttributesMapping: f,
+    highlightedIndex: c,
+    onHighlightedIndexChange: a,
+    orientation: d,
+    grid: p,
+    loopFocus: y,
+    onLoop: g,
+    enableHomeAndEndKeys: m,
+    onMapChange: v,
+    stopEventPropagation: R = !0,
+    rootRef: x,
+    disabledIndices: N,
+    modifierKeys: T,
+    highlightItemOnHover: l = !1,
+    tag: h = "div",
+    ...C
+  } = e, I = Jr(), {
+    props: D,
+    highlightedIndex: G,
+    onHighlightedIndexChange: b,
+    elementsRef: O,
+    onMapChange: E,
+    relayKeyboardEvent: H
+  } = Xr({
+    grid: p,
+    loopFocus: y,
+    onLoop: g,
+    orientation: d,
+    highlightedIndex: c,
+    onHighlightedIndexChange: a,
+    rootRef: x,
+    stopEventPropagation: R,
+    enableHomeAndEndKeys: m,
+    direction: I,
+    disabledIndices: N,
+    modifierKeys: T
+  }), F = te(h, e, {
+    state: s,
+    ref: r,
+    props: [D, ...i, C],
+    stateAttributesMapping: f
+  }), $ = u.useMemo(() => ({
+    highlightedIndex: G,
+    onHighlightedIndexChange: b,
+    highlightItemOnHover: l,
+    relayKeyboardEvent: H
+  }), [G, b, l, H]);
+  return /* @__PURE__ */ L(pt.Provider, {
+    value: $,
+    children: /* @__PURE__ */ L(Hr, {
+      elementsRef: O,
+      onMapChange: (U) => {
+        v?.(U), E(U);
+      },
+      children: F
+    })
+  });
+}
+function eo(e, t) {
+  const n = u.useRef(e), o = A(t);
+  K(() => {
+    n.current !== e && o(n.current), n.current = e;
+  }, [e, o]);
+}
+const to = [on], un = /* @__PURE__ */ u.forwardRef(function(t, n) {
+  const {
+    render: o,
+    className: r,
+    disabled: i,
+    readOnly: s,
+    required: f,
+    onValueChange: c,
+    value: a,
+    defaultValue: d,
+    form: p,
+    name: y,
+    inputRef: g,
+    id: m,
+    style: v,
+    ...R
+  } = t, {
+    setTouched: x,
+    setFocused: N,
+    validationMode: T,
+    name: l,
+    disabled: h,
+    state: C,
+    validation: I,
+    setDirty: D,
+    setFilled: G,
+    validityData: b
+  } = he(), {
+    labelId: O
+  } = ie(), {
+    clearErrors: E,
+    elementRef: H
+  } = Se(), F = Ve(!0), $ = h || i, U = l ?? y, Y = ce(m), [w, M] = Er({
+    controlled: a,
+    default: d,
+    name: "RadioGroup",
+    state: "value"
+  }), [S, _] = u.useState(!1), V = A((P, z) => {
+    c?.(P, z), !z.isCanceled && M(P);
+  }), k = I.getInputControl, B = u.useMemo(() => ({
+    get current() {
+      return k();
+    }
+  }), [k]), J = u.useRef(null), q = u.useRef(null);
+  function Q(P) {
+    let z;
+    return g && (typeof g == "function" ? z = g(P) : g.current = P), J.current = P, z;
+  }
+  const oe = A((P) => {
+    if (!P || P.disabled)
+      return;
+    q.current || (q.current = P);
+    const z = J.current, X = P.checked || z == null || z.disabled ? Q(P) : void 0;
+    return () => {
+      q.current === P && (q.current = null), J.current === P ? X ? (X(), J.current = null) : Q(null) : X?.();
+    };
+  }), se = A(() => {
+    const P = H.current;
+    if (!P)
+      return w ?? null;
+    for (const z of I.registeredInputs.keys())
+      if (z.checked && Gt(z, P))
+        return w ?? null;
+    return null;
+  });
+  vr(B, Y, w ?? null, se, !$, y), eo(w, () => {
+    E(U), D(w !== b.initialValue), G(w != null), I.change(w);
+    const P = q.current;
+    w == null && P && !P.disabled && Q(P);
+  });
+  const ne = O ?? F?.legendId, ae = {
+    ...C,
+    disabled: $ ?? !1,
+    required: f ?? !1,
+    readOnly: s ?? !1
+  }, le = u.useMemo(() => ({
+    checkedValue: w,
+    disabled: $,
+    form: p,
+    validation: I,
+    name: U,
+    readOnly: s,
+    registerInputRef: oe,
+    required: f,
+    setCheckedValue: V,
+    setTouched: _,
+    touched: S
+  }), [w, $, p, I, U, s, oe, f, V, _, S]), de = {
+    id: m,
+    role: "radiogroup",
+    "aria-required": f || void 0,
+    "aria-disabled": $ || void 0,
+    "aria-readonly": s || void 0,
+    "aria-labelledby": ne,
+    onFocus() {
+      N(!0);
+    },
+    onBlur(P) {
+      Vn(P.currentTarget, P.relatedTarget) || (x(!0), N(!1), T === "onBlur" && I.commit(w));
+    },
+    onKeyDownCapture(P) {
+      P.key.startsWith("Arrow") && (_(!0), N(!0));
+    }
+  };
+  return /* @__PURE__ */ L(mt.Provider, {
+    value: le,
+    children: /* @__PURE__ */ L(Qr, {
+      render: o,
+      className: r,
+      style: v,
+      state: ae,
+      props: [de, R, (P) => I.getValidationProps($ ?? !1, P)],
+      refs: [n],
+      stateAttributesMapping: me,
+      enableHomeAndEndKeys: !1,
+      modifierKeys: to
+    })
+  });
+});
+process.env.NODE_ENV !== "production" && (un.displayName = "RadioGroup");
+const no = {
+  "purpur-radio-button-group": "_purpur-radio-button-group_1bn9s_1",
+  "purpur-radio-button-group__container": "_purpur-radio-button-group__container_1bn9s_7",
+  "purpur-radio-button-group__items-container": "_purpur-radio-button-group__items-container_1bn9s_12"
+}, Ue = At.bind(no), He = "purpur-radio-button-group", cn = nt(
+  ({
+    "data-testid": e,
+    "aria-label": t,
+    "aria-labelledby": n,
+    className: o,
+    items: r,
+    heading: i,
+    orientation: s = "vertical",
+    headingTag: f = "h2",
+    children: c,
+    name: a,
+    disabled: d,
+    negative: p,
+    dir: y,
+    required: g,
+    ...m
+  }, v) => {
+    if (!r?.length && !c)
+      return null;
+    const R = i ? {} : { "aria-label": t, "aria-labelledby": n };
+    return /* @__PURE__ */ L(tn.Provider, { value: { disabled: d, negative: p, dir: y }, children: /* @__PURE__ */ L(jt, { className: Ue(`${He}__container`), name: a, disabled: d, children: /* @__PURE__ */ Ie(
+      nn,
+      {
+        render: /* @__PURE__ */ L(
+          un,
+          {
+            ...m,
+            className: Ue(o, He),
+            required: g,
+            ...R,
+            "data-orientation": s,
+            "data-testid": e,
+            dir: y,
+            ref: v
+          }
+        ),
+        children: [
+          i && /* @__PURE__ */ L(
+            rn,
+            {
+              render: /* @__PURE__ */ Ie(
+                hn,
+                {
+                  tag: f,
+                  "data-testid": e ? `${e}-heading` : void 0,
+                  variant: "subsection-100",
+                  negative: p,
+                  children: [
+                    g && /* @__PURE__ */ L("span", { "aria-hidden": !0, children: "* " }),
+                    i
+                  ]
+                }
+              )
+            }
+          ),
+          /* @__PURE__ */ L("div", { className: Ue(`${He}__items-container`), children: r?.length ? r.map((x) => /* @__PURE__ */ L(bt, { ...x }, x.value)) : c })
+        ]
+      }
+    ) }) });
+  }
+);
+cn.displayName = "RadioButtonGroupRoot";
+const ao = ["ltr", "rtl"], uo = ["horizontal", "vertical"], ln = nt(
+  ({ children: e, ...t }, n) => /* @__PURE__ */ L(cn, { ref: n, ...t, children: e })
+);
+ln.Item = bt;
+ln.displayName = "RadioButtonGroup";
+export {
+  ao as R,
+  uo as a,
+  ln as b
+};
+//# sourceMappingURL=radio-button-group-D_F6kWD6.mjs.map