@tipp/ui 0.0.0

package/dist/ui-props/index.js

@@ -0,0 +1,686 @@
+import { g as Et } from "../_commonjsHelpers-DaMA6jEr.js";
+function Ft(r, e) {
+  for (var a = 0; a < e.length; a++) {
+    const o = e[a];
+    if (typeof o != "string" && !Array.isArray(o)) {
+      for (const t in o)
+        if (t !== "default" && !(t in r)) {
+          const y = Object.getOwnPropertyDescriptor(o, t);
+          y && Object.defineProperty(r, t, y.get ? y : {
+            enumerable: !0,
+            get: () => o[t]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(r, Symbol.toStringTag, { value: "Module" }));
+}
+var B = { exports: {} }, q = Object.defineProperty, Gt = Object.getOwnPropertyDescriptor, Tt = Object.getOwnPropertyNames, Ht = Object.prototype.hasOwnProperty, Jt = (r, e) => {
+  for (var a in e) q(r, a, { get: e[a], enumerable: !0 });
+}, St = (r, e, a, o) => {
+  if (e && typeof e == "object" || typeof e == "function") for (let t of Tt(e)) !Ht.call(r, t) && t !== a && q(r, t, { get: () => e[t], enumerable: !(o = Gt(e, t)) || o.enumerable });
+  return r;
+}, Kt = (r) => St(q({}, "__esModule", { value: !0 }), r), vr = {};
+Jt(vr, { breakpoints: () => Xt });
+var Qt = Kt(vr);
+const Xt = ["initial", "xs", "sm", "md", "lg", "xl"];
+var L = Object.defineProperty, Yt = Object.getOwnPropertyDescriptor, Ut = Object.getOwnPropertyNames, Zt = Object.prototype.hasOwnProperty, ea = (r, e) => {
+  for (var a in e) L(r, a, { get: e[a], enumerable: !0 });
+}, ra = (r, e, a, o) => {
+  if (e && typeof e == "object" || typeof e == "function") for (let t of Ut(e)) !Zt.call(r, t) && t !== a && L(r, t, { get: () => e[t], enumerable: !(o = Yt(e, t)) || o.enumerable });
+  return r;
+}, ta = (r) => ra(L({}, "__esModule", { value: !0 }), r), fr = {};
+ea(fr, { asChildPropDef: () => aa });
+var p = ta(fr);
+const aa = { asChild: { type: "boolean" } };
+var E = Object.defineProperty, oa = Object.getOwnPropertyDescriptor, sa = Object.getOwnPropertyNames, na = Object.prototype.hasOwnProperty, pa = (r, e) => {
+  for (var a in e) E(r, a, { get: e[a], enumerable: !0 });
+}, la = (r, e, a, o) => {
+  if (e && typeof e == "object" || typeof e == "function") for (let t of sa(e)) !na.call(r, t) && t !== a && E(r, t, { get: () => e[t], enumerable: !(o = oa(e, t)) || o.enumerable });
+  return r;
+}, ia = (r) => la(E({}, "__esModule", { value: !0 }), r), ur = {};
+pa(ur, { accentColorPropDef: () => fa, accentColors: () => F, colorPropDef: () => va, grayColors: () => ca });
+var l = ia(ur);
+const F = ["gray", "gold", "bronze", "brown", "yellow", "amber", "orange", "tomato", "red", "ruby", "crimson", "pink", "plum", "purple", "violet", "iris", "indigo", "blue", "cyan", "teal", "jade", "green", "grass", "lime", "mint", "sky"], ca = ["auto", "gray", "mauve", "slate", "sage", "olive", "sand"], va = { color: { type: "enum", values: F, default: void 0 } }, fa = { color: { type: "enum", values: F, default: "" } };
+var G = Object.defineProperty, ua = Object.getOwnPropertyDescriptor, $a = Object.getOwnPropertyNames, ya = Object.prototype.hasOwnProperty, ma = (r, e) => {
+  for (var a in e) G(r, a, { get: e[a], enumerable: !0 });
+}, ba = (r, e, a, o) => {
+  if (e && typeof e == "object" || typeof e == "function") for (let t of $a(e)) !ya.call(r, t) && t !== a && G(r, t, { get: () => e[t], enumerable: !(o = ua(e, t)) || o.enumerable });
+  return r;
+}, Pa = (r) => ba(G({}, "__esModule", { value: !0 }), r), $r = {};
+ma($r, { gapPropDefs: () => ga });
+var T = Pa($r);
+const M = ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9"], ga = { gap: { type: "enum | string", className: "rt-r-gap", customProperties: ["--gap"], values: M, responsive: !0 }, gapX: { type: "enum | string", className: "rt-r-cg", customProperties: ["--column-gap"], values: M, responsive: !0 }, gapY: { type: "enum | string", className: "rt-r-rg", customProperties: ["--row-gap"], values: M, responsive: !0 } };
+var H = Object.defineProperty, da = Object.getOwnPropertyDescriptor, Oa = Object.getOwnPropertyNames, Da = Object.prototype.hasOwnProperty, ja = (r, e) => {
+  for (var a in e) H(r, a, { get: e[a], enumerable: !0 });
+}, ha = (r, e, a, o) => {
+  if (e && typeof e == "object" || typeof e == "function") for (let t of Oa(e)) !Da.call(r, t) && t !== a && H(r, t, { get: () => e[t], enumerable: !(o = da(e, t)) || o.enumerable });
+  return r;
+}, wa = (r) => ha(H({}, "__esModule", { value: !0 }), r), yr = {};
+ja(yr, { heightPropDefs: () => Na });
+var O = wa(yr);
+const Na = { height: { type: "string", className: "rt-r-h", customProperties: ["--height"], responsive: !0 }, minHeight: { type: "string", className: "rt-r-min-h", customProperties: ["--min-height"], responsive: !0 }, maxHeight: { type: "string", className: "rt-r-max-h", customProperties: ["--max-height"], responsive: !0 } };
+var J = Object.defineProperty, _a = Object.getOwnPropertyDescriptor, xa = Object.getOwnPropertyNames, Ca = Object.prototype.hasOwnProperty, za = (r, e) => {
+  for (var a in e) J(r, a, { get: e[a], enumerable: !0 });
+}, Ma = (r, e, a, o) => {
+  if (e && typeof e == "object" || typeof e == "function") for (let t of xa(e)) !Ca.call(r, t) && t !== a && J(r, t, { get: () => e[t], enumerable: !(o = _a(e, t)) || o.enumerable });
+  return r;
+}, ka = (r) => Ma(J({}, "__esModule", { value: !0 }), r), mr = {};
+za(mr, { highContrastPropDef: () => Wa });
+var i = ka(mr);
+const Wa = { highContrast: { type: "boolean", className: "rt-high-contrast", default: void 0 } };
+var S = Object.defineProperty, Ra = Object.getOwnPropertyDescriptor, Ia = Object.getOwnPropertyNames, Va = Object.prototype.hasOwnProperty, Aa = (r, e) => {
+  for (var a in e) S(r, a, { get: e[a], enumerable: !0 });
+}, Ba = (r, e, a, o) => {
+  if (e && typeof e == "object" || typeof e == "function") for (let t of Ia(e)) !Va.call(r, t) && t !== a && S(r, t, { get: () => e[t], enumerable: !(o = Ra(e, t)) || o.enumerable });
+  return r;
+}, qa = (r) => Ba(S({}, "__esModule", { value: !0 }), r), br = {};
+Aa(br, { paddingPropDefs: () => La });
+var C = qa(br);
+const b = ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9"], La = { p: { type: "enum | string", className: "rt-r-p", customProperties: ["--p"], values: b, responsive: !0 }, px: { type: "enum | string", className: "rt-r-px", customProperties: ["--pl", "--pr"], values: b, responsive: !0 }, py: { type: "enum | string", className: "rt-r-py", customProperties: ["--pt", "--pb"], values: b, responsive: !0 }, pt: { type: "enum | string", className: "rt-r-pt", customProperties: ["--pt"], values: b, responsive: !0 }, pr: { type: "enum | string", className: "rt-r-pr", customProperties: ["--pr"], values: b, responsive: !0 }, pb: { type: "enum | string", className: "rt-r-pb", customProperties: ["--pb"], values: b, responsive: !0 }, pl: { type: "enum | string", className: "rt-r-pl", customProperties: ["--pl"], values: b, responsive: !0 } };
+var K = Object.defineProperty, Ea = Object.getOwnPropertyDescriptor, Fa = Object.getOwnPropertyNames, Ga = Object.prototype.hasOwnProperty, Ta = (r, e) => {
+  for (var a in e) K(r, a, { get: e[a], enumerable: !0 });
+}, Ha = (r, e, a, o) => {
+  if (e && typeof e == "object" || typeof e == "function") for (let t of Fa(e)) !Ga.call(r, t) && t !== a && K(r, t, { get: () => e[t], enumerable: !(o = Ea(e, t)) || o.enumerable });
+  return r;
+}, Ja = (r) => Ha(K({}, "__esModule", { value: !0 }), r), Pr = {};
+Ta(Pr, { widthPropDefs: () => Sa });
+var f = Ja(Pr);
+const Sa = { width: { type: "string", className: "rt-r-w", customProperties: ["--width"], responsive: !0 }, minWidth: { type: "string", className: "rt-r-min-w", customProperties: ["--min-width"], responsive: !0 }, maxWidth: { type: "string", className: "rt-r-max-w", customProperties: ["--max-width"], responsive: !0 } };
+var Q = Object.defineProperty, Ka = Object.getOwnPropertyDescriptor, Qa = Object.getOwnPropertyNames, Xa = Object.prototype.hasOwnProperty, Ya = (r, e) => {
+  for (var a in e) Q(r, a, { get: e[a], enumerable: !0 });
+}, Ua = (r, e, a, o) => {
+  if (e && typeof e == "object" || typeof e == "function") for (let t of Qa(e)) !Xa.call(r, t) && t !== a && Q(r, t, { get: () => e[t], enumerable: !(o = Ka(e, t)) || o.enumerable });
+  return r;
+}, Za = (r) => Ua(Q({}, "__esModule", { value: !0 }), r), gr = {};
+Ya(gr, { layoutPropDefs: () => po });
+var eo = Za(gr), ro = C, to = O, ao = f;
+const k = ["visible", "hidden", "clip", "scroll", "auto"], oo = ["static", "relative", "absolute", "fixed", "sticky"], h = ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "-1", "-2", "-3", "-4", "-5", "-6", "-7", "-8", "-9"], so = ["0", "1"], no = ["0", "1"], po = { ...ro.paddingPropDefs, ...ao.widthPropDefs, ...to.heightPropDefs, position: { type: "enum", className: "rt-r-position", values: oo, responsive: !0 }, inset: { type: "enum | string", className: "rt-r-inset", customProperties: ["--inset"], values: h, responsive: !0 }, top: { type: "enum | string", className: "rt-r-top", customProperties: ["--top"], values: h, responsive: !0 }, right: { type: "enum | string", className: "rt-r-right", customProperties: ["--right"], values: h, responsive: !0 }, bottom: { type: "enum | string", className: "rt-r-bottom", customProperties: ["--bottom"], values: h, responsive: !0 }, left: { type: "enum | string", className: "rt-r-left", customProperties: ["--left"], values: h, responsive: !0 }, overflow: { type: "enum", className: "rt-r-overflow", values: k, responsive: !0 }, overflowX: { type: "enum", className: "rt-r-ox", values: k, responsive: !0 }, overflowY: { type: "enum", className: "rt-r-oy", values: k, responsive: !0 }, flexBasis: { type: "string", className: "rt-r-fb", customProperties: ["--flex-basis"], responsive: !0 }, flexShrink: { type: "enum | string", className: "rt-r-fs", customProperties: ["--flex-shrink"], values: so, responsive: !0 }, flexGrow: { type: "enum | string", className: "rt-r-fg", customProperties: ["--flex-grow"], values: no, responsive: !0 }, gridColumn: { type: "string", className: "rt-r-gc", customProperties: ["--grid-column"], responsive: !0 }, gridColumnStart: { type: "string", className: "rt-r-gcs", customProperties: ["--grid-column-start"], responsive: !0 }, gridColumnEnd: { type: "string", className: "rt-r-gce", customProperties: ["--grid-column-end"], responsive: !0 }, gridRow: { type: "string", className: "rt-r-gr", customProperties: ["--grid-row"], responsive: !0 }, gridRowStart: { type: "string", className: "rt-r-grs", customProperties: ["--grid-row-start"], responsive: !0 }, gridRowEnd: { type: "string", className: "rt-r-gre", customProperties: ["--grid-row-end"], responsive: !0 } };
+var X = Object.defineProperty, lo = Object.getOwnPropertyDescriptor, io = Object.getOwnPropertyNames, co = Object.prototype.hasOwnProperty, vo = (r, e) => {
+  for (var a in e) X(r, a, { get: e[a], enumerable: !0 });
+}, fo = (r, e, a, o) => {
+  if (e && typeof e == "object" || typeof e == "function") for (let t of io(e)) !co.call(r, t) && t !== a && X(r, t, { get: () => e[t], enumerable: !(o = lo(e, t)) || o.enumerable });
+  return r;
+}, uo = (r) => fo(X({}, "__esModule", { value: !0 }), r), dr = {};
+vo(dr, { leadingTrimPropDef: () => yo });
+var w = uo(dr);
+const $o = ["normal", "start", "end", "both"], yo = { trim: { type: "enum", className: "rt-r-lt", values: $o, responsive: !0 } };
+var Y = Object.defineProperty, mo = Object.getOwnPropertyDescriptor, bo = Object.getOwnPropertyNames, Po = Object.prototype.hasOwnProperty, go = (r, e) => {
+  for (var a in e) Y(r, a, { get: e[a], enumerable: !0 });
+}, Oo = (r, e, a, o) => {
+  if (e && typeof e == "object" || typeof e == "function") for (let t of bo(e)) !Po.call(r, t) && t !== a && Y(r, t, { get: () => e[t], enumerable: !(o = mo(e, t)) || o.enumerable });
+  return r;
+}, Do = (r) => Oo(Y({}, "__esModule", { value: !0 }), r), Or = {};
+go(Or, { marginPropDefs: () => ho });
+var jo = Do(Or);
+const P = ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "-1", "-2", "-3", "-4", "-5", "-6", "-7", "-8", "-9"], ho = { m: { type: "enum | string", values: P, responsive: !0, className: "rt-r-m", customProperties: ["--m"] }, mx: { type: "enum | string", values: P, responsive: !0, className: "rt-r-mx", customProperties: ["--ml", "--mr"] }, my: { type: "enum | string", values: P, responsive: !0, className: "rt-r-my", customProperties: ["--mt", "--mb"] }, mt: { type: "enum | string", values: P, responsive: !0, className: "rt-r-mt", customProperties: ["--mt"] }, mr: { type: "enum | string", values: P, responsive: !0, className: "rt-r-mr", customProperties: ["--mr"] }, mb: { type: "enum | string", values: P, responsive: !0, className: "rt-r-mb", customProperties: ["--mb"] }, ml: { type: "enum | string", values: P, responsive: !0, className: "rt-r-ml", customProperties: ["--ml"] } };
+var U = Object.defineProperty, wo = Object.getOwnPropertyDescriptor, No = Object.getOwnPropertyNames, _o = Object.prototype.hasOwnProperty, xo = (r, e) => {
+  for (var a in e) U(r, a, { get: e[a], enumerable: !0 });
+}, Co = (r, e, a, o) => {
+  if (e && typeof e == "object" || typeof e == "function") for (let t of No(e)) !_o.call(r, t) && t !== a && U(r, t, { get: () => e[t], enumerable: !(o = wo(e, t)) || o.enumerable });
+  return r;
+}, zo = (r) => Co(U({}, "__esModule", { value: !0 }), r), Dr = {};
+xo(Dr, { radii: () => jr, radiusPropDef: () => Mo });
+var c = zo(Dr);
+const jr = ["none", "small", "medium", "large", "full"], Mo = { radius: { type: "enum", values: jr, default: void 0 } };
+var Z = Object.defineProperty, ko = Object.getOwnPropertyDescriptor, Wo = Object.getOwnPropertyNames, Ro = Object.prototype.hasOwnProperty, Io = (r, e) => {
+  for (var a in e) Z(r, a, { get: e[a], enumerable: !0 });
+}, Vo = (r, e, a, o) => {
+  if (e && typeof e == "object" || typeof e == "function") for (let t of Wo(e)) !Ro.call(r, t) && t !== a && Z(r, t, { get: () => e[t], enumerable: !(o = ko(e, t)) || o.enumerable });
+  return r;
+}, Ao = (r) => Vo(Z({}, "__esModule", { value: !0 }), r), hr = {};
+Io(hr, { textAlignPropDef: () => qo });
+var ee = Ao(hr);
+const Bo = ["left", "center", "right"], qo = { align: { type: "enum", className: "rt-r-ta", values: Bo, responsive: !0 } };
+var re = Object.defineProperty, Lo = Object.getOwnPropertyDescriptor, Eo = Object.getOwnPropertyNames, Fo = Object.prototype.hasOwnProperty, Go = (r, e) => {
+  for (var a in e) re(r, a, { get: e[a], enumerable: !0 });
+}, To = (r, e, a, o) => {
+  if (e && typeof e == "object" || typeof e == "function") for (let t of Eo(e)) !Fo.call(r, t) && t !== a && re(r, t, { get: () => e[t], enumerable: !(o = Lo(e, t)) || o.enumerable });
+  return r;
+}, Ho = (r) => To(re({}, "__esModule", { value: !0 }), r), wr = {};
+Go(wr, { textWrapPropDef: () => So });
+var u = Ho(wr);
+const Jo = ["wrap", "nowrap", "pretty", "balance"], So = { wrap: { type: "enum", className: "rt-r-tw", values: Jo, responsive: !0 } };
+var te = Object.defineProperty, Ko = Object.getOwnPropertyDescriptor, Qo = Object.getOwnPropertyNames, Xo = Object.prototype.hasOwnProperty, Yo = (r, e) => {
+  for (var a in e) te(r, a, { get: e[a], enumerable: !0 });
+}, Uo = (r, e, a, o) => {
+  if (e && typeof e == "object" || typeof e == "function") for (let t of Qo(e)) !Xo.call(r, t) && t !== a && te(r, t, { get: () => e[t], enumerable: !(o = Ko(e, t)) || o.enumerable });
+  return r;
+}, Zo = (r) => Uo(te({}, "__esModule", { value: !0 }), r), Nr = {};
+Yo(Nr, { truncatePropDef: () => es });
+var $ = Zo(Nr);
+const es = { truncate: { type: "boolean", className: "rt-truncate" } };
+var ae = Object.defineProperty, rs = Object.getOwnPropertyDescriptor, ts = Object.getOwnPropertyNames, as = Object.prototype.hasOwnProperty, os = (r, e) => {
+  for (var a in e) ae(r, a, { get: e[a], enumerable: !0 });
+}, ss = (r, e, a, o) => {
+  if (e && typeof e == "object" || typeof e == "function") for (let t of ts(e)) !as.call(r, t) && t !== a && ae(r, t, { get: () => e[t], enumerable: !(o = rs(e, t)) || o.enumerable });
+  return r;
+}, ns = (r) => ss(ae({}, "__esModule", { value: !0 }), r), _r = {};
+os(_r, { weightPropDef: () => ls });
+var D = ns(_r);
+const ps = ["light", "regular", "medium", "bold"], ls = { weight: { type: "enum", className: "rt-r-weight", values: ps, responsive: !0 } };
+var oe = Object.defineProperty, is = Object.getOwnPropertyDescriptor, cs = Object.getOwnPropertyNames, vs = Object.prototype.hasOwnProperty, fs = (r, e) => {
+  for (var a in e) oe(r, a, { get: e[a], enumerable: !0 });
+}, us = (r, e, a, o) => {
+  if (e && typeof e == "object" || typeof e == "function") for (let t of cs(e)) !vs.call(r, t) && t !== a && oe(r, t, { get: () => e[t], enumerable: !(o = is(e, t)) || o.enumerable });
+  return r;
+}, $s = (r) => us(oe({}, "__esModule", { value: !0 }), r), xr = {};
+fs(xr, { dialogContentPropDefs: () => Ps });
+var Cr = $s(xr), ys = p, W = f, ms = O;
+const bs = ["1", "2", "3", "4"], Ps = { ...ys.asChildPropDef, align: { type: "enum", className: "rt-r-align", values: ["start", "center"], default: "center" }, size: { type: "enum", className: "rt-r-size", values: bs, default: "3", responsive: !0 }, width: W.widthPropDefs.width, minWidth: W.widthPropDefs.minWidth, maxWidth: { ...W.widthPropDefs.maxWidth, default: "600px" }, ...ms.heightPropDefs };
+var se = Object.defineProperty, gs = Object.getOwnPropertyDescriptor, ds = Object.getOwnPropertyNames, Os = Object.prototype.hasOwnProperty, Ds = (r, e) => {
+  for (var a in e) se(r, a, { get: e[a], enumerable: !0 });
+}, js = (r, e, a, o) => {
+  if (e && typeof e == "object" || typeof e == "function") for (let t of ds(e)) !Os.call(r, t) && t !== a && se(r, t, { get: () => e[t], enumerable: !(o = gs(e, t)) || o.enumerable });
+  return r;
+}, hs = (r) => js(se({}, "__esModule", { value: !0 }), r), zr = {};
+Ds(zr, { alertDialogContentPropDefs: () => Ns.dialogContentPropDefs });
+var ws = hs(zr), Ns = Cr, ne = Object.defineProperty, _s = Object.getOwnPropertyDescriptor, xs = Object.getOwnPropertyNames, Cs = Object.prototype.hasOwnProperty, zs = (r, e) => {
+  for (var a in e) ne(r, a, { get: e[a], enumerable: !0 });
+}, Ms = (r, e, a, o) => {
+  if (e && typeof e == "object" || typeof e == "function") for (let t of xs(e)) !Cs.call(r, t) && t !== a && ne(r, t, { get: () => e[t], enumerable: !(o = _s(e, t)) || o.enumerable });
+  return r;
+}, ks = (r) => Ms(ne({}, "__esModule", { value: !0 }), r), Mr = {};
+zs(Mr, { avatarPropDefs: () => Ls });
+var Ws = ks(Mr), Rs = p, Is = l, Vs = i, As = c;
+const Bs = ["1", "2", "3", "4", "5", "6", "7", "8", "9"], qs = ["solid", "soft"], Ls = { ...Rs.asChildPropDef, size: { type: "enum", className: "rt-r-size", values: Bs, default: "3", responsive: !0 }, variant: { type: "enum", className: "rt-variant", values: qs, default: "soft" }, ...Is.accentColorPropDef, ...Vs.highContrastPropDef, ...As.radiusPropDef, fallback: { type: "ReactNode", required: !0 } };
+var pe = Object.defineProperty, Es = Object.getOwnPropertyDescriptor, Fs = Object.getOwnPropertyNames, Gs = Object.prototype.hasOwnProperty, Ts = (r, e) => {
+  for (var a in e) pe(r, a, { get: e[a], enumerable: !0 });
+}, Hs = (r, e, a, o) => {
+  if (e && typeof e == "object" || typeof e == "function") for (let t of Fs(e)) !Gs.call(r, t) && t !== a && pe(r, t, { get: () => e[t], enumerable: !(o = Es(e, t)) || o.enumerable });
+  return r;
+}, Js = (r) => Hs(pe({}, "__esModule", { value: !0 }), r), kr = {};
+Ts(kr, { badgePropDefs: () => en });
+var Ss = Js(kr), Ks = p, Qs = l, Xs = i, Ys = c;
+const Us = ["1", "2", "3"], Zs = ["solid", "soft", "surface", "outline"], en = { ...Ks.asChildPropDef, size: { type: "enum", className: "rt-r-size", values: Us, default: "1", responsive: !0 }, variant: { type: "enum", className: "rt-variant", values: Zs, default: "soft" }, ...Qs.accentColorPropDef, ...Xs.highContrastPropDef, ...Ys.radiusPropDef };
+var le = Object.defineProperty, rn = Object.getOwnPropertyDescriptor, tn = Object.getOwnPropertyNames, an = Object.prototype.hasOwnProperty, on = (r, e) => {
+  for (var a in e) le(r, a, { get: e[a], enumerable: !0 });
+}, sn = (r, e, a, o) => {
+  if (e && typeof e == "object" || typeof e == "function") for (let t of tn(e)) !an.call(r, t) && t !== a && le(r, t, { get: () => e[t], enumerable: !(o = rn(e, t)) || o.enumerable });
+  return r;
+}, nn = (r) => sn(le({}, "__esModule", { value: !0 }), r), Wr = {};
+on(Wr, { blockquotePropDefs: () => mn });
+var pn = nn(Wr), ln = p, cn = l, vn = i, fn = u, un = $, $n = D;
+const yn = ["1", "2", "3", "4", "5", "6", "7", "8", "9"], mn = { ...ln.asChildPropDef, size: { type: "enum", className: "rt-r-size", values: yn, responsive: !0 }, ...$n.weightPropDef, ...cn.colorPropDef, ...vn.highContrastPropDef, ...un.truncatePropDef, ...fn.textWrapPropDef };
+var ie = Object.defineProperty, bn = Object.getOwnPropertyDescriptor, Pn = Object.getOwnPropertyNames, gn = Object.prototype.hasOwnProperty, dn = (r, e) => {
+  for (var a in e) ie(r, a, { get: e[a], enumerable: !0 });
+}, On = (r, e, a, o) => {
+  if (e && typeof e == "object" || typeof e == "function") for (let t of Pn(e)) !gn.call(r, t) && t !== a && ie(r, t, { get: () => e[t], enumerable: !(o = bn(e, t)) || o.enumerable });
+  return r;
+}, Dn = (r) => On(ie({}, "__esModule", { value: !0 }), r), Rr = {};
+dn(Rr, { boxPropDefs: () => _n });
+var jn = Dn(Rr), hn = p;
+const wn = ["div", "span"], Nn = ["none", "inline", "inline-block", "block"], _n = { as: { type: "enum", values: wn, default: "div" }, ...hn.asChildPropDef, display: { type: "enum", className: "rt-r-display", values: Nn, responsive: !0 } };
+var ce = Object.defineProperty, xn = Object.getOwnPropertyDescriptor, Cn = Object.getOwnPropertyNames, zn = Object.prototype.hasOwnProperty, Mn = (r, e) => {
+  for (var a in e) ce(r, a, { get: e[a], enumerable: !0 });
+}, kn = (r, e, a, o) => {
+  if (e && typeof e == "object" || typeof e == "function") for (let t of Cn(e)) !zn.call(r, t) && t !== a && ce(r, t, { get: () => e[t], enumerable: !(o = xn(e, t)) || o.enumerable });
+  return r;
+}, Wn = (r) => kn(ce({}, "__esModule", { value: !0 }), r), Ir = {};
+Mn(Ir, { baseButtonPropDefs: () => Ln });
+var Vr = Wn(Ir), Rn = p, In = l, Vn = i, An = c;
+const Bn = ["1", "2", "3", "4"], qn = ["classic", "solid", "soft", "surface", "outline", "ghost"], Ln = { ...Rn.asChildPropDef, size: { type: "enum", className: "rt-r-size", values: Bn, default: "2", responsive: !0 }, variant: { type: "enum", className: "rt-variant", values: qn, default: "solid" }, ...In.accentColorPropDef, ...Vn.highContrastPropDef, ...An.radiusPropDef, loading: { type: "boolean", className: "rt-loading", default: !1 } };
+var ve = Object.defineProperty, En = Object.getOwnPropertyDescriptor, Fn = Object.getOwnPropertyNames, Gn = Object.prototype.hasOwnProperty, Tn = (r, e) => {
+  for (var a in e) ve(r, a, { get: e[a], enumerable: !0 });
+}, Hn = (r, e, a, o) => {
+  if (e && typeof e == "object" || typeof e == "function") for (let t of Fn(e)) !Gn.call(r, t) && t !== a && ve(r, t, { get: () => e[t], enumerable: !(o = En(e, t)) || o.enumerable });
+  return r;
+}, Jn = (r) => Hn(ve({}, "__esModule", { value: !0 }), r), Ar = {};
+Tn(Ar, { buttonPropDefs: () => Kn.baseButtonPropDefs });
+var Sn = Jn(Ar), Kn = Vr, fe = Object.defineProperty, Qn = Object.getOwnPropertyDescriptor, Xn = Object.getOwnPropertyNames, Yn = Object.prototype.hasOwnProperty, Un = (r, e) => {
+  for (var a in e) fe(r, a, { get: e[a], enumerable: !0 });
+}, Zn = (r, e, a, o) => {
+  if (e && typeof e == "object" || typeof e == "function") for (let t of Xn(e)) !Yn.call(r, t) && t !== a && fe(r, t, { get: () => e[t], enumerable: !(o = Qn(e, t)) || o.enumerable });
+  return r;
+}, ep = (r) => Zn(fe({}, "__esModule", { value: !0 }), r), Br = {};
+Un(Br, { calloutRootPropDefs: () => pp });
+var rp = ep(Br), tp = p, ap = l, op = i;
+const sp = ["1", "2", "3"], np = ["soft", "surface", "outline"], pp = { ...tp.asChildPropDef, size: { type: "enum", className: "rt-r-size", values: sp, default: "2", responsive: !0 }, variant: { type: "enum", className: "rt-variant", values: np, default: "soft" }, ...ap.accentColorPropDef, ...op.highContrastPropDef };
+var ue = Object.defineProperty, lp = Object.getOwnPropertyDescriptor, ip = Object.getOwnPropertyNames, cp = Object.prototype.hasOwnProperty, vp = (r, e) => {
+  for (var a in e) ue(r, a, { get: e[a], enumerable: !0 });
+}, fp = (r, e, a, o) => {
+  if (e && typeof e == "object" || typeof e == "function") for (let t of ip(e)) !cp.call(r, t) && t !== a && ue(r, t, { get: () => e[t], enumerable: !(o = lp(e, t)) || o.enumerable });
+  return r;
+}, up = (r) => fp(ue({}, "__esModule", { value: !0 }), r), qr = {};
+vp(qr, { cardPropDefs: () => Pp });
+var $p = up(qr), yp = p;
+const mp = ["1", "2", "3", "4", "5"], bp = ["surface", "classic", "ghost"], Pp = { ...yp.asChildPropDef, size: { type: "enum", className: "rt-r-size", values: mp, default: "1", responsive: !0 }, variant: { type: "enum", className: "rt-variant", values: bp, default: "surface" } };
+var $e = Object.defineProperty, gp = Object.getOwnPropertyDescriptor, dp = Object.getOwnPropertyNames, Op = Object.prototype.hasOwnProperty, Dp = (r, e) => {
+  for (var a in e) $e(r, a, { get: e[a], enumerable: !0 });
+}, jp = (r, e, a, o) => {
+  if (e && typeof e == "object" || typeof e == "function") for (let t of dp(e)) !Op.call(r, t) && t !== a && $e(r, t, { get: () => e[t], enumerable: !(o = gp(e, t)) || o.enumerable });
+  return r;
+}, hp = (r) => jp($e({}, "__esModule", { value: !0 }), r), Lr = {};
+Dp(Lr, { gridPropDefs: () => Er });
+var ye = hp(Lr), wp = p, Np = T;
+const _p = ["div", "span"], xp = ["none", "inline-grid", "grid"], Cp = ["1", "2", "3", "4", "5", "6", "7", "8", "9"], zp = ["1", "2", "3", "4", "5", "6", "7", "8", "9"], Mp = ["row", "column", "dense", "row-dense", "column-dense"], kp = ["start", "center", "end", "baseline", "stretch"], Wp = ["start", "center", "end", "between"], Er = { as: { type: "enum", values: _p, default: "div" }, ...wp.asChildPropDef, display: { type: "enum", className: "rt-r-display", values: xp, responsive: !0 }, columns: { type: "enum | string", className: "rt-r-gtc", customProperties: ["--grid-template-columns"], values: Cp, parseValue: pr, responsive: !0 }, rows: { type: "enum | string", className: "rt-r-gtr", customProperties: ["--grid-template-rows"], values: zp, parseValue: pr, responsive: !0 }, flow: { type: "enum", className: "rt-r-gaf", values: Mp, responsive: !0 }, align: { type: "enum", className: "rt-r-ai", values: kp, responsive: !0 }, justify: { type: "enum", className: "rt-r-jc", values: Wp, parseValue: Rp, responsive: !0 }, ...Np.gapPropDefs };
+function pr(r) {
+  return Er.columns.values.includes(r) ? r : r != null && r.match(/^\d+$/) ? `repeat(${r}, minmax(0, 1fr))` : r;
+}
+function Rp(r) {
+  return r === "between" ? "space-between" : r;
+}
+var me = Object.defineProperty, Ip = Object.getOwnPropertyDescriptor, Vp = Object.getOwnPropertyNames, Ap = Object.prototype.hasOwnProperty, Bp = (r, e) => {
+  for (var a in e) me(r, a, { get: e[a], enumerable: !0 });
+}, qp = (r, e, a, o) => {
+  if (e && typeof e == "object" || typeof e == "function") for (let t of Vp(e)) !Ap.call(r, t) && t !== a && me(r, t, { get: () => e[t], enumerable: !(o = Ip(e, t)) || o.enumerable });
+  return r;
+}, Lp = (r) => qp(me({}, "__esModule", { value: !0 }), r), Fr = {};
+Bp(Fr, { checkboxCardsRootPropDefs: () => Sp });
+var Ep = Lp(Fr), Fp = p, Gp = l, Tp = i, lr = ye;
+const Hp = ["1", "2", "3"], Jp = ["surface", "classic"], Sp = { ...Fp.asChildPropDef, size: { type: "enum", className: "rt-r-size", values: Hp, default: "2", responsive: !0 }, variant: { type: "enum", className: "rt-variant", values: Jp, default: "surface" }, ...Gp.colorPropDef, ...Tp.highContrastPropDef, columns: { ...lr.gridPropDefs.columns, default: "repeat(auto-fit, minmax(200px, 1fr))" }, gap: { ...lr.gridPropDefs.gap, default: "4" } };
+var be = Object.defineProperty, Kp = Object.getOwnPropertyDescriptor, Qp = Object.getOwnPropertyNames, Xp = Object.prototype.hasOwnProperty, Yp = (r, e) => {
+  for (var a in e) be(r, a, { get: e[a], enumerable: !0 });
+}, Up = (r, e, a, o) => {
+  if (e && typeof e == "object" || typeof e == "function") for (let t of Qp(e)) !Xp.call(r, t) && t !== a && be(r, t, { get: () => e[t], enumerable: !(o = Kp(e, t)) || o.enumerable });
+  return r;
+}, Zp = (r) => Up(be({}, "__esModule", { value: !0 }), r), Gr = {};
+Yp(Gr, { baseCheckboxPropDefs: () => ol });
+var Tr = Zp(Gr), el = l, rl = i;
+const tl = ["1", "2", "3"], al = ["classic", "surface", "soft"], ol = { size: { type: "enum", className: "rt-r-size", values: tl, default: "2", responsive: !0 }, variant: { type: "enum", className: "rt-variant", values: al, default: "surface" }, ...el.colorPropDef, ...rl.highContrastPropDef };
+var Pe = Object.defineProperty, sl = Object.getOwnPropertyDescriptor, nl = Object.getOwnPropertyNames, pl = Object.prototype.hasOwnProperty, ll = (r, e) => {
+  for (var a in e) Pe(r, a, { get: e[a], enumerable: !0 });
+}, il = (r, e, a, o) => {
+  if (e && typeof e == "object" || typeof e == "function") for (let t of nl(e)) !pl.call(r, t) && t !== a && Pe(r, t, { get: () => e[t], enumerable: !(o = sl(e, t)) || o.enumerable });
+  return r;
+}, cl = (r) => il(Pe({}, "__esModule", { value: !0 }), r), Hr = {};
+ll(Hr, { checkboxGroupRootPropDefs: () => $l });
+var vl = cl(Hr), fl = p, ul = Tr;
+const $l = { ...fl.asChildPropDef, ...ul.baseCheckboxPropDefs };
+var ge = Object.defineProperty, yl = Object.getOwnPropertyDescriptor, ml = Object.getOwnPropertyNames, bl = Object.prototype.hasOwnProperty, Pl = (r, e) => {
+  for (var a in e) ge(r, a, { get: e[a], enumerable: !0 });
+}, gl = (r, e, a, o) => {
+  if (e && typeof e == "object" || typeof e == "function") for (let t of ml(e)) !bl.call(r, t) && t !== a && ge(r, t, { get: () => e[t], enumerable: !(o = yl(e, t)) || o.enumerable });
+  return r;
+}, dl = (r) => gl(ge({}, "__esModule", { value: !0 }), r), Jr = {};
+Pl(Jr, { checkboxPropDefs: () => Dl.baseCheckboxPropDefs });
+var Ol = dl(Jr), Dl = Tr, de = Object.defineProperty, jl = Object.getOwnPropertyDescriptor, hl = Object.getOwnPropertyNames, wl = Object.prototype.hasOwnProperty, Nl = (r, e) => {
+  for (var a in e) de(r, a, { get: e[a], enumerable: !0 });
+}, _l = (r, e, a, o) => {
+  if (e && typeof e == "object" || typeof e == "function") for (let t of hl(e)) !wl.call(r, t) && t !== a && de(r, t, { get: () => e[t], enumerable: !(o = jl(e, t)) || o.enumerable });
+  return r;
+}, xl = (r) => _l(de({}, "__esModule", { value: !0 }), r), Sr = {};
+Nl(Sr, { codePropDefs: () => Bl });
+var Cl = xl(Sr), zl = p, Ml = l, kl = i, Wl = u, Rl = $, Il = D;
+const Vl = ["1", "2", "3", "4", "5", "6", "7", "8", "9"], Al = ["solid", "soft", "outline", "ghost"], Bl = { ...zl.asChildPropDef, size: { type: "enum", className: "rt-r-size", values: Vl, responsive: !0 }, variant: { type: "enum", className: "rt-variant", values: Al, default: "soft" }, ...Il.weightPropDef, ...Ml.accentColorPropDef, ...kl.highContrastPropDef, ...Rl.truncatePropDef, ...Wl.textWrapPropDef };
+var Oe = Object.defineProperty, ql = Object.getOwnPropertyDescriptor, Ll = Object.getOwnPropertyNames, El = Object.prototype.hasOwnProperty, Fl = (r, e) => {
+  for (var a in e) Oe(r, a, { get: e[a], enumerable: !0 });
+}, Gl = (r, e, a, o) => {
+  if (e && typeof e == "object" || typeof e == "function") for (let t of Ll(e)) !El.call(r, t) && t !== a && Oe(r, t, { get: () => e[t], enumerable: !(o = ql(e, t)) || o.enumerable });
+  return r;
+}, Tl = (r) => Gl(Oe({}, "__esModule", { value: !0 }), r), Kr = {};
+Fl(Kr, { containerPropDefs: () => Xl });
+var Hl = Tl(Kr), Jl = p;
+const Sl = ["1", "2", "3", "4"], Kl = ["none", "initial"], Ql = ["left", "center", "right"], Xl = { ...Jl.asChildPropDef, size: { type: "enum", className: "rt-r-size", values: Sl, default: "4", responsive: !0 }, display: { type: "enum", className: "rt-r-display", values: Kl, parseValue: Yl, responsive: !0 }, align: { type: "enum", className: "rt-r-ai", values: Ql, parseValue: Ul, responsive: !0 } };
+function Yl(r) {
+  return r === "initial" ? "flex" : r;
+}
+function Ul(r) {
+  return r === "left" ? "start" : r === "right" ? "end" : r;
+}
+var De = Object.defineProperty, Zl = Object.getOwnPropertyDescriptor, ei = Object.getOwnPropertyNames, ri = Object.prototype.hasOwnProperty, ti = (r, e) => {
+  for (var a in e) De(r, a, { get: e[a], enumerable: !0 });
+}, ai = (r, e, a, o) => {
+  if (e && typeof e == "object" || typeof e == "function") for (let t of ei(e)) !ri.call(r, t) && t !== a && De(r, t, { get: () => e[t], enumerable: !(o = Zl(e, t)) || o.enumerable });
+  return r;
+}, oi = (r) => ai(De({}, "__esModule", { value: !0 }), r), Qr = {};
+ti(Qr, { baseMenuCheckboxItemPropDefs: () => vi, baseMenuContentPropDefs: () => ii, baseMenuItemPropDefs: () => ci, baseMenuRadioItemPropDefs: () => fi });
+var Xr = oi(Qr), si = p, z = l, ni = i;
+const pi = ["1", "2"], li = ["solid", "soft"], ii = { size: { type: "enum", className: "rt-r-size", values: pi, default: "2", responsive: !0 }, variant: { type: "enum", className: "rt-variant", values: li, default: "solid" }, ...z.colorPropDef, ...ni.highContrastPropDef }, ci = { ...si.asChildPropDef, ...z.colorPropDef, shortcut: { type: "string" } }, vi = { ...z.colorPropDef, shortcut: { type: "string" } }, fi = { ...z.colorPropDef };
+var je = Object.defineProperty, ui = Object.getOwnPropertyDescriptor, $i = Object.getOwnPropertyNames, yi = Object.prototype.hasOwnProperty, mi = (r, e) => {
+  for (var a in e) je(r, a, { get: e[a], enumerable: !0 });
+}, bi = (r, e, a, o) => {
+  if (e && typeof e == "object" || typeof e == "function") for (let t of $i(e)) !yi.call(r, t) && t !== a && je(r, t, { get: () => e[t], enumerable: !(o = ui(e, t)) || o.enumerable });
+  return r;
+}, Pi = (r) => bi(je({}, "__esModule", { value: !0 }), r), Yr = {};
+mi(Yr, { contextMenuCheckboxItemPropDefs: () => _.baseMenuCheckboxItemPropDefs, contextMenuContentPropDefs: () => _.baseMenuContentPropDefs, contextMenuItemPropDefs: () => _.baseMenuItemPropDefs, contextMenuRadioItemPropDefs: () => _.baseMenuRadioItemPropDefs });
+var gi = Pi(Yr), _ = Xr, he = Object.defineProperty, di = Object.getOwnPropertyDescriptor, Oi = Object.getOwnPropertyNames, Di = Object.prototype.hasOwnProperty, ji = (r, e) => {
+  for (var a in e) he(r, a, { get: e[a], enumerable: !0 });
+}, hi = (r, e, a, o) => {
+  if (e && typeof e == "object" || typeof e == "function") for (let t of Oi(e)) !Di.call(r, t) && t !== a && he(r, t, { get: () => e[t], enumerable: !(o = di(e, t)) || o.enumerable });
+  return r;
+}, wi = (r) => hi(he({}, "__esModule", { value: !0 }), r), Ur = {};
+ji(Ur, { dataListItemPropDefs: () => Ii, dataListLabelPropDefs: () => Vi, dataListRootPropDefs: () => Ri });
+var Ni = wi(Ur), _i = l, xi = i, Ci = w, zi = f;
+const Mi = ["start", "center", "end", "baseline", "stretch"], ki = ["horizontal", "vertical"], Wi = ["1", "2", "3"], Ri = { orientation: { type: "enum", className: "rt-r-orientation", values: ki, default: "horizontal", responsive: !0 }, size: { type: "enum", className: "rt-r-size", values: Wi, default: "2", responsive: !0 }, trim: { ...Ci.leadingTrimPropDef.trim, className: "rt-r-trim" } }, Ii = { align: { type: "enum", className: "rt-r-ai", values: Mi, responsive: !0 } }, Vi = { ...zi.widthPropDefs, ..._i.colorPropDef, ...xi.highContrastPropDef };
+var we = Object.defineProperty, Ai = Object.getOwnPropertyDescriptor, Bi = Object.getOwnPropertyNames, qi = Object.prototype.hasOwnProperty, Li = (r, e) => {
+  for (var a in e) we(r, a, { get: e[a], enumerable: !0 });
+}, Ei = (r, e, a, o) => {
+  if (e && typeof e == "object" || typeof e == "function") for (let t of Bi(e)) !qi.call(r, t) && t !== a && we(r, t, { get: () => e[t], enumerable: !(o = Ai(e, t)) || o.enumerable });
+  return r;
+}, Fi = (r) => Ei(we({}, "__esModule", { value: !0 }), r), Zr = {};
+Li(Zr, { dropdownMenuCheckboxItemPropDefs: () => x.baseMenuCheckboxItemPropDefs, dropdownMenuContentPropDefs: () => x.baseMenuContentPropDefs, dropdownMenuItemPropDefs: () => x.baseMenuItemPropDefs, dropdownMenuRadioItemPropDefs: () => x.baseMenuRadioItemPropDefs });
+var Gi = Fi(Zr), x = Xr, Ne = Object.defineProperty, Ti = Object.getOwnPropertyDescriptor, Hi = Object.getOwnPropertyNames, Ji = Object.prototype.hasOwnProperty, Si = (r, e) => {
+  for (var a in e) Ne(r, a, { get: e[a], enumerable: !0 });
+}, Ki = (r, e, a, o) => {
+  if (e && typeof e == "object" || typeof e == "function") for (let t of Hi(e)) !Ji.call(r, t) && t !== a && Ne(r, t, { get: () => e[t], enumerable: !(o = Ti(e, t)) || o.enumerable });
+  return r;
+}, Qi = (r) => Ki(Ne({}, "__esModule", { value: !0 }), r), et = {};
+Si(et, { emPropDefs: () => ec });
+var Xi = Qi(et), Yi = p, Ui = u, Zi = $;
+const ec = { ...Yi.asChildPropDef, ...Zi.truncatePropDef, ...Ui.textWrapPropDef };
+var _e = Object.defineProperty, rc = Object.getOwnPropertyDescriptor, tc = Object.getOwnPropertyNames, ac = Object.prototype.hasOwnProperty, oc = (r, e) => {
+  for (var a in e) _e(r, a, { get: e[a], enumerable: !0 });
+}, sc = (r, e, a, o) => {
+  if (e && typeof e == "object" || typeof e == "function") for (let t of tc(e)) !ac.call(r, t) && t !== a && _e(r, t, { get: () => e[t], enumerable: !(o = rc(e, t)) || o.enumerable });
+  return r;
+}, nc = (r) => sc(_e({}, "__esModule", { value: !0 }), r), rt = {};
+oc(rt, { flexPropDefs: () => yc });
+var tt = nc(rt), pc = p, lc = T;
+const ic = ["div", "span"], cc = ["none", "inline-flex", "flex"], vc = ["row", "column", "row-reverse", "column-reverse"], fc = ["start", "center", "end", "baseline", "stretch"], uc = ["start", "center", "end", "between"], $c = ["nowrap", "wrap", "wrap-reverse"], yc = { as: { type: "enum", values: ic, default: "div" }, ...pc.asChildPropDef, display: { type: "enum", className: "rt-r-display", values: cc, responsive: !0 }, direction: { type: "enum", className: "rt-r-fd", values: vc, responsive: !0 }, align: { type: "enum", className: "rt-r-ai", values: fc, responsive: !0 }, justify: { type: "enum", className: "rt-r-jc", values: uc, parseValue: mc, responsive: !0 }, wrap: { type: "enum", className: "rt-r-fw", values: $c, responsive: !0 }, ...lc.gapPropDefs };
+function mc(r) {
+  return r === "between" ? "space-between" : r;
+}
+var xe = Object.defineProperty, bc = Object.getOwnPropertyDescriptor, Pc = Object.getOwnPropertyNames, gc = Object.prototype.hasOwnProperty, dc = (r, e) => {
+  for (var a in e) xe(r, a, { get: e[a], enumerable: !0 });
+}, Oc = (r, e, a, o) => {
+  if (e && typeof e == "object" || typeof e == "function") for (let t of Pc(e)) !gc.call(r, t) && t !== a && xe(r, t, { get: () => e[t], enumerable: !(o = bc(e, t)) || o.enumerable });
+  return r;
+}, Dc = (r) => Oc(xe({}, "__esModule", { value: !0 }), r), at = {};
+dc(at, { headingPropDefs: () => Rc });
+var jc = Dc(at), hc = p, wc = l, Nc = i, _c = w, xc = ee, Cc = u, zc = $, Mc = D;
+const kc = ["h1", "h2", "h3", "h4", "h5", "h6"], Wc = ["1", "2", "3", "4", "5", "6", "7", "8", "9"], Rc = { as: { type: "enum", values: kc, default: "h1" }, ...hc.asChildPropDef, size: { type: "enum", className: "rt-r-size", values: Wc, default: "6", responsive: !0 }, ...Mc.weightPropDef, ...xc.textAlignPropDef, ..._c.leadingTrimPropDef, ...zc.truncatePropDef, ...Cc.textWrapPropDef, ...wc.colorPropDef, ...Nc.highContrastPropDef };
+var Ce = Object.defineProperty, Ic = Object.getOwnPropertyDescriptor, Vc = Object.getOwnPropertyNames, Ac = Object.prototype.hasOwnProperty, Bc = (r, e) => {
+  for (var a in e) Ce(r, a, { get: e[a], enumerable: !0 });
+}, qc = (r, e, a, o) => {
+  if (e && typeof e == "object" || typeof e == "function") for (let t of Vc(e)) !Ac.call(r, t) && t !== a && Ce(r, t, { get: () => e[t], enumerable: !(o = Ic(e, t)) || o.enumerable });
+  return r;
+}, Lc = (r) => qc(Ce({}, "__esModule", { value: !0 }), r), ot = {};
+Bc(ot, { hoverCardContentPropDefs: () => Hc });
+var Ec = Lc(ot), Fc = p, Gc = O, R = f;
+const Tc = ["1", "2", "3"], Hc = { ...Fc.asChildPropDef, size: { type: "enum", className: "rt-r-size", values: Tc, default: "2", responsive: !0 }, width: R.widthPropDefs.width, minWidth: R.widthPropDefs.minWidth, maxWidth: { ...R.widthPropDefs.maxWidth, default: "480px" }, ...Gc.heightPropDefs };
+var ze = Object.defineProperty, Jc = Object.getOwnPropertyDescriptor, Sc = Object.getOwnPropertyNames, Kc = Object.prototype.hasOwnProperty, Qc = (r, e) => {
+  for (var a in e) ze(r, a, { get: e[a], enumerable: !0 });
+}, Xc = (r, e, a, o) => {
+  if (e && typeof e == "object" || typeof e == "function") for (let t of Sc(e)) !Kc.call(r, t) && t !== a && ze(r, t, { get: () => e[t], enumerable: !(o = Jc(e, t)) || o.enumerable });
+  return r;
+}, Yc = (r) => Xc(ze({}, "__esModule", { value: !0 }), r), st = {};
+Qc(st, { iconButtonPropDefs: () => Zc.baseButtonPropDefs });
+var Uc = Yc(st), Zc = Vr, Me = Object.defineProperty, ev = Object.getOwnPropertyDescriptor, rv = Object.getOwnPropertyNames, tv = Object.prototype.hasOwnProperty, av = (r, e) => {
+  for (var a in e) Me(r, a, { get: e[a], enumerable: !0 });
+}, ov = (r, e, a, o) => {
+  if (e && typeof e == "object" || typeof e == "function") for (let t of rv(e)) !tv.call(r, t) && t !== a && Me(r, t, { get: () => e[t], enumerable: !(o = ev(e, t)) || o.enumerable });
+  return r;
+}, sv = (r) => ov(Me({}, "__esModule", { value: !0 }), r), nt = {};
+av(nt, { insetPropDefs: () => cv });
+var nv = sv(nt), pv = p;
+const lv = ["all", "x", "y", "top", "bottom", "left", "right"], iv = ["border-box", "padding-box"], g = ["current", "0"], cv = { ...pv.asChildPropDef, side: { type: "enum", className: "rt-r-side", values: lv, default: "all", responsive: !0 }, clip: { type: "enum", className: "rt-r-clip", values: iv, default: "border-box", responsive: !0 }, p: { type: "enum", className: "rt-r-p", values: g, parseValue: d, responsive: !0 }, px: { type: "enum", className: "rt-r-px", values: g, parseValue: d, responsive: !0 }, py: { type: "enum", className: "rt-r-py", values: g, parseValue: d, responsive: !0 }, pt: { type: "enum", className: "rt-r-pt", values: g, parseValue: d, responsive: !0 }, pr: { type: "enum", className: "rt-r-pr", values: g, parseValue: d, responsive: !0 }, pb: { type: "enum", className: "rt-r-pb", values: g, parseValue: d, responsive: !0 }, pl: { type: "enum", className: "rt-r-pl", values: g, parseValue: d, responsive: !0 } };
+function d(r) {
+  return r === "current" ? "inset" : r;
+}
+var ke = Object.defineProperty, vv = Object.getOwnPropertyDescriptor, fv = Object.getOwnPropertyNames, uv = Object.prototype.hasOwnProperty, $v = (r, e) => {
+  for (var a in e) ke(r, a, { get: e[a], enumerable: !0 });
+}, yv = (r, e, a, o) => {
+  if (e && typeof e == "object" || typeof e == "function") for (let t of fv(e)) !uv.call(r, t) && t !== a && ke(r, t, { get: () => e[t], enumerable: !(o = vv(e, t)) || o.enumerable });
+  return r;
+}, mv = (r) => yv(ke({}, "__esModule", { value: !0 }), r), pt = {};
+$v(pt, { kbdPropDefs: () => dv });
+var bv = mv(pt), Pv = p;
+const gv = ["1", "2", "3", "4", "5", "6", "7", "8", "9"], dv = { ...Pv.asChildPropDef, size: { type: "enum", className: "rt-r-size", values: gv, responsive: !0 } };
+var We = Object.defineProperty, Ov = Object.getOwnPropertyDescriptor, Dv = Object.getOwnPropertyNames, jv = Object.prototype.hasOwnProperty, hv = (r, e) => {
+  for (var a in e) We(r, a, { get: e[a], enumerable: !0 });
+}, wv = (r, e, a, o) => {
+  if (e && typeof e == "object" || typeof e == "function") for (let t of Dv(e)) !jv.call(r, t) && t !== a && We(r, t, { get: () => e[t], enumerable: !(o = Ov(e, t)) || o.enumerable });
+  return r;
+}, Nv = (r) => wv(We({}, "__esModule", { value: !0 }), r), lt = {};
+hv(lt, { linkPropDefs: () => Av });
+var _v = Nv(lt), xv = p, Cv = l, zv = i, Mv = w, kv = u, Wv = $, Rv = D;
+const Iv = ["1", "2", "3", "4", "5", "6", "7", "8", "9"], Vv = ["auto", "always", "hover", "none"], Av = { ...xv.asChildPropDef, size: { type: "enum", className: "rt-r-size", values: Iv, responsive: !0 }, ...Rv.weightPropDef, ...Mv.leadingTrimPropDef, ...Wv.truncatePropDef, ...kv.textWrapPropDef, underline: { type: "enum", className: "rt-underline", values: Vv, default: "auto" }, ...Cv.accentColorPropDef, ...zv.highContrastPropDef };
+var Re = Object.defineProperty, Bv = Object.getOwnPropertyDescriptor, qv = Object.getOwnPropertyNames, Lv = Object.prototype.hasOwnProperty, Ev = (r, e) => {
+  for (var a in e) Re(r, a, { get: e[a], enumerable: !0 });
+}, Fv = (r, e, a, o) => {
+  if (e && typeof e == "object" || typeof e == "function") for (let t of qv(e)) !Lv.call(r, t) && t !== a && Re(r, t, { get: () => e[t], enumerable: !(o = Bv(e, t)) || o.enumerable });
+  return r;
+}, Gv = (r) => Fv(Re({}, "__esModule", { value: !0 }), r), it = {};
+Ev(it, { popoverContentPropDefs: () => Kv });
+var Tv = Gv(it), Hv = p, Jv = O, I = f;
+const Sv = ["1", "2", "3", "4"], Kv = { ...Hv.asChildPropDef, size: { type: "enum", className: "rt-r-size", values: Sv, default: "2", responsive: !0 }, width: I.widthPropDefs.width, minWidth: I.widthPropDefs.minWidth, maxWidth: { ...I.widthPropDefs.maxWidth, default: "480px" }, ...Jv.heightPropDefs };
+var Ie = Object.defineProperty, Qv = Object.getOwnPropertyDescriptor, Xv = Object.getOwnPropertyNames, Yv = Object.prototype.hasOwnProperty, Uv = (r, e) => {
+  for (var a in e) Ie(r, a, { get: e[a], enumerable: !0 });
+}, Zv = (r, e, a, o) => {
+  if (e && typeof e == "object" || typeof e == "function") for (let t of Xv(e)) !Yv.call(r, t) && t !== a && Ie(r, t, { get: () => e[t], enumerable: !(o = Qv(e, t)) || o.enumerable });
+  return r;
+}, ef = (r) => Zv(Ie({}, "__esModule", { value: !0 }), r), ct = {};
+Uv(ct, { progressPropDefs: () => pf });
+var rf = ef(ct), tf = l, af = i, of = c;
+const sf = ["1", "2", "3"], nf = ["classic", "surface", "soft"], pf = { size: { type: "enum", className: "rt-r-size", values: sf, default: "2", responsive: !0 }, variant: { type: "enum", className: "rt-variant", values: nf, default: "surface" }, ...tf.colorPropDef, ...af.highContrastPropDef, ...of.radiusPropDef, duration: { type: "string" } };
+var Ve = Object.defineProperty, lf = Object.getOwnPropertyDescriptor, cf = Object.getOwnPropertyNames, vf = Object.prototype.hasOwnProperty, ff = (r, e) => {
+  for (var a in e) Ve(r, a, { get: e[a], enumerable: !0 });
+}, uf = (r, e, a, o) => {
+  if (e && typeof e == "object" || typeof e == "function") for (let t of cf(e)) !vf.call(r, t) && t !== a && Ve(r, t, { get: () => e[t], enumerable: !(o = lf(e, t)) || o.enumerable });
+  return r;
+}, $f = (r) => uf(Ve({}, "__esModule", { value: !0 }), r), vt = {};
+ff(vt, { quotePropDefs: () => gf });
+var yf = $f(vt), mf = p, bf = u, Pf = $;
+const gf = { ...mf.asChildPropDef, ...Pf.truncatePropDef, ...bf.textWrapPropDef };
+var Ae = Object.defineProperty, df = Object.getOwnPropertyDescriptor, Of = Object.getOwnPropertyNames, Df = Object.prototype.hasOwnProperty, jf = (r, e) => {
+  for (var a in e) Ae(r, a, { get: e[a], enumerable: !0 });
+}, hf = (r, e, a, o) => {
+  if (e && typeof e == "object" || typeof e == "function") for (let t of Of(e)) !Df.call(r, t) && t !== a && Ae(r, t, { get: () => e[t], enumerable: !(o = df(e, t)) || o.enumerable });
+  return r;
+}, wf = (r) => hf(Ae({}, "__esModule", { value: !0 }), r), ft = {};
+jf(ft, { baseRadioPropDefs: () => Mf });
+var Nf = wf(ft), _f = l, xf = i;
+const Cf = ["1", "2", "3"], zf = ["classic", "surface", "soft"], Mf = { size: { type: "enum", className: "rt-r-size", values: Cf, default: "2", responsive: !0 }, variant: { type: "enum", className: "rt-variant", values: zf, default: "surface" }, ..._f.colorPropDef, ...xf.highContrastPropDef };
+var Be = Object.defineProperty, kf = Object.getOwnPropertyDescriptor, Wf = Object.getOwnPropertyNames, Rf = Object.prototype.hasOwnProperty, If = (r, e) => {
+  for (var a in e) Be(r, a, { get: e[a], enumerable: !0 });
+}, Vf = (r, e, a, o) => {
+  if (e && typeof e == "object" || typeof e == "function") for (let t of Wf(e)) !Rf.call(r, t) && t !== a && Be(r, t, { get: () => e[t], enumerable: !(o = kf(e, t)) || o.enumerable });
+  return r;
+}, Af = (r) => Vf(Be({}, "__esModule", { value: !0 }), r), ut = {};
+If(ut, { radioPropDefs: () => qf.baseRadioPropDefs });
+var Bf = Af(ut), qf = Nf, qe = Object.defineProperty, Lf = Object.getOwnPropertyDescriptor, Ef = Object.getOwnPropertyNames, Ff = Object.prototype.hasOwnProperty, Gf = (r, e) => {
+  for (var a in e) qe(r, a, { get: e[a], enumerable: !0 });
+}, Tf = (r, e, a, o) => {
+  if (e && typeof e == "object" || typeof e == "function") for (let t of Ef(e)) !Ff.call(r, t) && t !== a && qe(r, t, { get: () => e[t], enumerable: !(o = Lf(e, t)) || o.enumerable });
+  return r;
+}, Hf = (r) => Tf(qe({}, "__esModule", { value: !0 }), r), $t = {};
+Gf($t, { radioCardsRootPropDefs: () => Uf });
+var Jf = Hf($t), Sf = p, Kf = l, Qf = i, ir = ye;
+const Xf = ["1", "2", "3"], Yf = ["surface", "classic"], Uf = { ...Sf.asChildPropDef, size: { type: "enum", className: "rt-r-size", values: Xf, default: "2", responsive: !0 }, variant: { type: "enum", className: "rt-variant", values: Yf, default: "surface" }, ...Kf.colorPropDef, ...Qf.highContrastPropDef, columns: { ...ir.gridPropDefs.columns, default: "repeat(auto-fit, minmax(160px, 1fr))" }, gap: { ...ir.gridPropDefs.gap, default: "4" } };
+var Le = Object.defineProperty, Zf = Object.getOwnPropertyDescriptor, eu = Object.getOwnPropertyNames, ru = Object.prototype.hasOwnProperty, tu = (r, e) => {
+  for (var a in e) Le(r, a, { get: e[a], enumerable: !0 });
+}, au = (r, e, a, o) => {
+  if (e && typeof e == "object" || typeof e == "function") for (let t of eu(e)) !ru.call(r, t) && t !== a && Le(r, t, { get: () => e[t], enumerable: !(o = Zf(e, t)) || o.enumerable });
+  return r;
+}, ou = (r) => au(Le({}, "__esModule", { value: !0 }), r), yt = {};
+tu(yt, { radioGroupRootPropDefs: () => vu });
+var su = ou(yt), nu = p, pu = l, lu = i;
+const iu = ["1", "2", "3"], cu = ["classic", "surface", "soft"], vu = { ...nu.asChildPropDef, size: { type: "enum", className: "rt-r-size", values: iu, default: "2", responsive: !0 }, variant: { type: "enum", className: "rt-variant", values: cu, default: "surface" }, ...pu.colorPropDef, ...lu.highContrastPropDef };
+var Ee = Object.defineProperty, fu = Object.getOwnPropertyDescriptor, uu = Object.getOwnPropertyNames, $u = Object.prototype.hasOwnProperty, yu = (r, e) => {
+  for (var a in e) Ee(r, a, { get: e[a], enumerable: !0 });
+}, mu = (r, e, a, o) => {
+  if (e && typeof e == "object" || typeof e == "function") for (let t of uu(e)) !$u.call(r, t) && t !== a && Ee(r, t, { get: () => e[t], enumerable: !(o = fu(e, t)) || o.enumerable });
+  return r;
+}, bu = (r) => mu(Ee({}, "__esModule", { value: !0 }), r), mt = {};
+yu(mt, { scrollAreaPropDefs: () => ju });
+var Pu = bu(mt), gu = p, du = c;
+const Ou = ["1", "2", "3"], Du = ["vertical", "horizontal", "both"], ju = { ...gu.asChildPropDef, size: { type: "enum", className: "rt-r-size", values: Ou, default: "1", responsive: !0 }, ...du.radiusPropDef, scrollbars: { type: "enum", values: Du, default: "both" } };
+var Fe = Object.defineProperty, hu = Object.getOwnPropertyDescriptor, wu = Object.getOwnPropertyNames, Nu = Object.prototype.hasOwnProperty, _u = (r, e) => {
+  for (var a in e) Fe(r, a, { get: e[a], enumerable: !0 });
+}, xu = (r, e, a, o) => {
+  if (e && typeof e == "object" || typeof e == "function") for (let t of wu(e)) !Nu.call(r, t) && t !== a && Fe(r, t, { get: () => e[t], enumerable: !(o = hu(e, t)) || o.enumerable });
+  return r;
+}, Cu = (r) => xu(Fe({}, "__esModule", { value: !0 }), r), bt = {};
+_u(bt, { sectionPropDefs: () => Ru });
+var zu = Cu(bt), Mu = p;
+const ku = ["1", "2", "3", "4"], Wu = ["none", "initial"], Ru = { ...Mu.asChildPropDef, size: { type: "enum", className: "rt-r-size", values: ku, default: "3", responsive: !0 }, display: { type: "enum", className: "rt-r-display", values: Wu, parseValue: Iu, responsive: !0 } };
+function Iu(r) {
+  return r === "initial" ? "block" : r;
+}
+var Ge = Object.defineProperty, Vu = Object.getOwnPropertyDescriptor, Au = Object.getOwnPropertyNames, Bu = Object.prototype.hasOwnProperty, qu = (r, e) => {
+  for (var a in e) Ge(r, a, { get: e[a], enumerable: !0 });
+}, Lu = (r, e, a, o) => {
+  if (e && typeof e == "object" || typeof e == "function") for (let t of Au(e)) !Bu.call(r, t) && t !== a && Ge(r, t, { get: () => e[t], enumerable: !(o = Vu(e, t)) || o.enumerable });
+  return r;
+}, Eu = (r) => Lu(Ge({}, "__esModule", { value: !0 }), r), Pt = {};
+qu(Pt, { segmentedControlRootPropDefs: () => Ju });
+var Fu = Eu(Pt), Gu = c;
+const Tu = ["1", "2", "3"], Hu = ["surface", "classic"], Ju = { size: { type: "enum", className: "rt-r-size", values: Tu, default: "2", responsive: !0 }, variant: { type: "enum", className: "rt-variant", values: Hu, default: "surface" }, ...Gu.radiusPropDef };
+var Te = Object.defineProperty, Su = Object.getOwnPropertyDescriptor, Ku = Object.getOwnPropertyNames, Qu = Object.prototype.hasOwnProperty, Xu = (r, e) => {
+  for (var a in e) Te(r, a, { get: e[a], enumerable: !0 });
+}, Yu = (r, e, a, o) => {
+  if (e && typeof e == "object" || typeof e == "function") for (let t of Ku(e)) !Qu.call(r, t) && t !== a && Te(r, t, { get: () => e[t], enumerable: !(o = Su(e, t)) || o.enumerable });
+  return r;
+}, Uu = (r) => Yu(Te({}, "__esModule", { value: !0 }), r), gt = {};
+Xu(gt, { selectContentPropDefs: () => p$, selectRootPropDefs: () => a$, selectTriggerPropDefs: () => s$ });
+var Zu = Uu(gt), dt = l, e$ = i, r$ = c;
+const t$ = ["1", "2", "3"], a$ = { size: { type: "enum", className: "rt-r-size", values: t$, default: "2", responsive: !0 } }, o$ = ["classic", "surface", "soft", "ghost"], s$ = { variant: { type: "enum", className: "rt-variant", values: o$, default: "surface" }, ...dt.colorPropDef, ...r$.radiusPropDef, placeholder: { type: "string" } }, n$ = ["solid", "soft"], p$ = { variant: { type: "enum", className: "rt-variant", values: n$, default: "solid" }, ...dt.colorPropDef, ...e$.highContrastPropDef };
+var He = Object.defineProperty, l$ = Object.getOwnPropertyDescriptor, i$ = Object.getOwnPropertyNames, c$ = Object.prototype.hasOwnProperty, v$ = (r, e) => {
+  for (var a in e) He(r, a, { get: e[a], enumerable: !0 });
+}, f$ = (r, e, a, o) => {
+  if (e && typeof e == "object" || typeof e == "function") for (let t of i$(e)) !c$.call(r, t) && t !== a && He(r, t, { get: () => e[t], enumerable: !(o = l$(e, t)) || o.enumerable });
+  return r;
+}, u$ = (r) => f$(He({}, "__esModule", { value: !0 }), r), Ot = {};
+v$(Ot, { separatorPropDefs: () => P$ });
+var $$ = u$(Ot), y$ = l;
+const m$ = ["horizontal", "vertical"], b$ = ["1", "2", "3", "4"], P$ = { orientation: { type: "enum", className: "rt-r-orientation", values: m$, default: "horizontal", responsive: !0 }, size: { type: "enum", className: "rt-r-size", values: b$, default: "1", responsive: !0 }, color: { ...y$.colorPropDef.color, default: "gray" }, decorative: { type: "boolean", default: !0 } };
+var Je = Object.defineProperty, g$ = Object.getOwnPropertyDescriptor, d$ = Object.getOwnPropertyNames, O$ = Object.prototype.hasOwnProperty, D$ = (r, e) => {
+  for (var a in e) Je(r, a, { get: e[a], enumerable: !0 });
+}, j$ = (r, e, a, o) => {
+  if (e && typeof e == "object" || typeof e == "function") for (let t of d$(e)) !O$.call(r, t) && t !== a && Je(r, t, { get: () => e[t], enumerable: !(o = g$(e, t)) || o.enumerable });
+  return r;
+}, h$ = (r) => j$(Je({}, "__esModule", { value: !0 }), r), Dt = {};
+D$(Dt, { skeletonPropDefs: () => x$ });
+var w$ = h$(Dt), N$ = O, _$ = f;
+const x$ = { loading: { type: "boolean", default: !0 }, ..._$.widthPropDefs, ...N$.heightPropDefs };
+var Se = Object.defineProperty, C$ = Object.getOwnPropertyDescriptor, z$ = Object.getOwnPropertyNames, M$ = Object.prototype.hasOwnProperty, k$ = (r, e) => {
+  for (var a in e) Se(r, a, { get: e[a], enumerable: !0 });
+}, W$ = (r, e, a, o) => {
+  if (e && typeof e == "object" || typeof e == "function") for (let t of z$(e)) !M$.call(r, t) && t !== a && Se(r, t, { get: () => e[t], enumerable: !(o = C$(e, t)) || o.enumerable });
+  return r;
+}, R$ = (r) => W$(Se({}, "__esModule", { value: !0 }), r), jt = {};
+k$(jt, { sliderPropDefs: () => E$ });
+var I$ = R$(jt), V$ = l, A$ = i, B$ = c;
+const q$ = ["1", "2", "3"], L$ = ["classic", "surface", "soft"], E$ = { size: { type: "enum", className: "rt-r-size", values: q$, default: "2", responsive: !0 }, variant: { type: "enum", className: "rt-variant", values: L$, default: "surface" }, ...V$.colorPropDef, ...A$.highContrastPropDef, ...B$.radiusPropDef };
+var Ke = Object.defineProperty, F$ = Object.getOwnPropertyDescriptor, G$ = Object.getOwnPropertyNames, T$ = Object.prototype.hasOwnProperty, H$ = (r, e) => {
+  for (var a in e) Ke(r, a, { get: e[a], enumerable: !0 });
+}, J$ = (r, e, a, o) => {
+  if (e && typeof e == "object" || typeof e == "function") for (let t of G$(e)) !T$.call(r, t) && t !== a && Ke(r, t, { get: () => e[t], enumerable: !(o = F$(e, t)) || o.enumerable });
+  return r;
+}, S$ = (r) => J$(Ke({}, "__esModule", { value: !0 }), r), ht = {};
+H$(ht, { spinnerPropDefs: () => X$ });
+var K$ = S$(ht);
+const Q$ = ["1", "2", "3"], X$ = { size: { type: "enum", className: "rt-r-size", values: Q$, default: "2", responsive: !0 }, loading: { type: "boolean", default: !0 } };
+var Qe = Object.defineProperty, Y$ = Object.getOwnPropertyDescriptor, U$ = Object.getOwnPropertyNames, Z$ = Object.prototype.hasOwnProperty, ey = (r, e) => {
+  for (var a in e) Qe(r, a, { get: e[a], enumerable: !0 });
+}, ry = (r, e, a, o) => {
+  if (e && typeof e == "object" || typeof e == "function") for (let t of U$(e)) !Z$.call(r, t) && t !== a && Qe(r, t, { get: () => e[t], enumerable: !(o = Y$(e, t)) || o.enumerable });
+  return r;
+}, ty = (r) => ry(Qe({}, "__esModule", { value: !0 }), r), wt = {};
+ey(wt, { strongPropDefs: () => py });
+var ay = ty(wt), oy = p, sy = u, ny = $;
+const py = { ...oy.asChildPropDef, ...ny.truncatePropDef, ...sy.textWrapPropDef };
+var Xe = Object.defineProperty, ly = Object.getOwnPropertyDescriptor, iy = Object.getOwnPropertyNames, cy = Object.prototype.hasOwnProperty, vy = (r, e) => {
+  for (var a in e) Xe(r, a, { get: e[a], enumerable: !0 });
+}, fy = (r, e, a, o) => {
+  if (e && typeof e == "object" || typeof e == "function") for (let t of iy(e)) !cy.call(r, t) && t !== a && Xe(r, t, { get: () => e[t], enumerable: !(o = ly(e, t)) || o.enumerable });
+  return r;
+}, uy = (r) => fy(Xe({}, "__esModule", { value: !0 }), r), Nt = {};
+vy(Nt, { switchPropDefs: () => dy });
+var $y = uy(Nt), yy = l, my = i, by = c;
+const Py = ["1", "2", "3"], gy = ["classic", "surface", "soft"], dy = { size: { type: "enum", className: "rt-r-size", values: Py, default: "2", responsive: !0 }, variant: { type: "enum", className: "rt-variant", values: gy, default: "surface" }, ...yy.colorPropDef, ...my.highContrastPropDef, ...by.radiusPropDef };
+var Ye = Object.defineProperty, Oy = Object.getOwnPropertyDescriptor, Dy = Object.getOwnPropertyNames, jy = Object.prototype.hasOwnProperty, hy = (r, e) => {
+  for (var a in e) Ye(r, a, { get: e[a], enumerable: !0 });
+}, wy = (r, e, a, o) => {
+  if (e && typeof e == "object" || typeof e == "function") for (let t of Dy(e)) !jy.call(r, t) && t !== a && Ye(r, t, { get: () => e[t], enumerable: !(o = Oy(e, t)) || o.enumerable });
+  return r;
+}, Ny = (r) => wy(Ye({}, "__esModule", { value: !0 }), r), _t = {};
+hy(_t, { baseTabListPropDefs: () => ky });
+var xt = Ny(_t), _y = l, xy = i;
+const Cy = ["1", "2"], zy = ["nowrap", "wrap", "wrap-reverse"], My = ["start", "center", "end"], ky = { size: { type: "enum", className: "rt-r-size", values: Cy, default: "2", responsive: !0 }, wrap: { type: "enum", className: "rt-r-fw", values: zy, responsive: !0 }, justify: { type: "enum", className: "rt-r-jc", values: My, responsive: !0 }, ..._y.colorPropDef, ...xy.highContrastPropDef };
+var Ue = Object.defineProperty, Wy = Object.getOwnPropertyDescriptor, Ry = Object.getOwnPropertyNames, Iy = Object.prototype.hasOwnProperty, Vy = (r, e) => {
+  for (var a in e) Ue(r, a, { get: e[a], enumerable: !0 });
+}, Ay = (r, e, a, o) => {
+  if (e && typeof e == "object" || typeof e == "function") for (let t of Ry(e)) !Iy.call(r, t) && t !== a && Ue(r, t, { get: () => e[t], enumerable: !(o = Wy(e, t)) || o.enumerable });
+  return r;
+}, By = (r) => Ay(Ue({}, "__esModule", { value: !0 }), r), Ct = {};
+Vy(Ct, { tabNavLinkPropDefs: () => Fy, tabNavRootPropDefs: () => Ey.baseTabListPropDefs });
+var qy = By(Ct), Ly = p, Ey = xt;
+const Fy = { ...Ly.asChildPropDef, active: { type: "boolean", default: !1 } };
+var Ze = Object.defineProperty, Gy = Object.getOwnPropertyDescriptor, Ty = Object.getOwnPropertyNames, Hy = Object.prototype.hasOwnProperty, Jy = (r, e) => {
+  for (var a in e) Ze(r, a, { get: e[a], enumerable: !0 });
+}, Sy = (r, e, a, o) => {
+  if (e && typeof e == "object" || typeof e == "function") for (let t of Ty(e)) !Hy.call(r, t) && t !== a && Ze(r, t, { get: () => e[t], enumerable: !(o = Gy(e, t)) || o.enumerable });
+  return r;
+}, Ky = (r) => Sy(Ze({}, "__esModule", { value: !0 }), r), zt = {};
+Jy(zt, { tableCellPropDefs: () => nm, tableRootPropDefs: () => rm, tableRowPropDefs: () => am });
+var Qy = Ky(zt), Xy = C, Yy = f;
+const Uy = ["1", "2", "3"], Zy = ["surface", "ghost"], em = ["auto", "fixed"], rm = { size: { type: "enum", className: "rt-r-size", values: Uy, default: "2", responsive: !0 }, variant: { type: "enum", className: "rt-variant", values: Zy, default: "ghost" }, layout: { type: "enum", className: "rt-r-tl", values: em, responsive: !0 } }, tm = ["start", "center", "end", "baseline"], am = { align: { type: "enum", className: "rt-r-va", values: tm, parseValue: om, responsive: !0 } };
+function om(r) {
+  return { baseline: "baseline", start: "top", center: "middle", end: "bottom" }[r];
+}
+const sm = ["start", "center", "end"], nm = { justify: { type: "enum", className: "rt-r-ta", values: sm, parseValue: pm, responsive: !0 }, ...Yy.widthPropDefs, ...Xy.paddingPropDefs };
+function pm(r) {
+  return { start: "left", center: "center", end: "right" }[r];
+}
+var er = Object.defineProperty, lm = Object.getOwnPropertyDescriptor, im = Object.getOwnPropertyNames, cm = Object.prototype.hasOwnProperty, vm = (r, e) => {
+  for (var a in e) er(r, a, { get: e[a], enumerable: !0 });
+}, fm = (r, e, a, o) => {
+  if (e && typeof e == "object" || typeof e == "function") for (let t of im(e)) !cm.call(r, t) && t !== a && er(r, t, { get: () => e[t], enumerable: !(o = lm(e, t)) || o.enumerable });
+  return r;
+}, um = (r) => fm(er({}, "__esModule", { value: !0 }), r), Mt = {};
+vm(Mt, { tabsContentPropDefs: () => bm, tabsListPropDefs: () => ym.baseTabListPropDefs, tabsRootPropDefs: () => mm });
+var $m = um(Mt), kt = p, ym = xt;
+const mm = { ...kt.asChildPropDef }, bm = { ...kt.asChildPropDef };
+var rr = Object.defineProperty, Pm = Object.getOwnPropertyDescriptor, gm = Object.getOwnPropertyNames, dm = Object.prototype.hasOwnProperty, Om = (r, e) => {
+  for (var a in e) rr(r, a, { get: e[a], enumerable: !0 });
+}, Dm = (r, e, a, o) => {
+  if (e && typeof e == "object" || typeof e == "function") for (let t of gm(e)) !dm.call(r, t) && t !== a && rr(r, t, { get: () => e[t], enumerable: !(o = Pm(e, t)) || o.enumerable });
+  return r;
+}, jm = (r) => Dm(rr({}, "__esModule", { value: !0 }), r), Wt = {};
+Om(Wt, { textAreaPropDefs: () => zm });
+var hm = jm(Wt), wm = l, Nm = c;
+const _m = ["1", "2", "3"], xm = ["classic", "surface", "soft"], Cm = ["none", "vertical", "horizontal", "both"], zm = { size: { type: "enum", className: "rt-r-size", values: _m, default: "2", responsive: !0 }, variant: { type: "enum", className: "rt-variant", values: xm, default: "surface" }, resize: { type: "enum", className: "rt-r-resize", values: Cm, responsive: !0 }, ...wm.colorPropDef, ...Nm.radiusPropDef };
+var tr = Object.defineProperty, Mm = Object.getOwnPropertyDescriptor, km = Object.getOwnPropertyNames, Wm = Object.prototype.hasOwnProperty, Rm = (r, e) => {
+  for (var a in e) tr(r, a, { get: e[a], enumerable: !0 });
+}, Im = (r, e, a, o) => {
+  if (e && typeof e == "object" || typeof e == "function") for (let t of km(e)) !Wm.call(r, t) && t !== a && tr(r, t, { get: () => e[t], enumerable: !(o = Mm(e, t)) || o.enumerable });
+  return r;
+}, Vm = (r) => Im(tr({}, "__esModule", { value: !0 }), r), Rt = {};
+Rm(Rt, { textFieldRootPropDefs: () => Fm, textFieldSlotPropDefs: () => Tm });
+var Am = Vm(Rt), It = l, V = C, Bm = c, qm = tt;
+const Lm = ["1", "2", "3"], Em = ["classic", "surface", "soft"], Fm = { size: { type: "enum", className: "rt-r-size", values: Lm, default: "2", responsive: !0 }, variant: { type: "enum", className: "rt-variant", values: Em, default: "surface" }, ...It.colorPropDef, ...Bm.radiusPropDef }, Gm = ["left", "right"], Tm = { side: { type: "enum", values: Gm }, ...It.colorPropDef, gap: qm.flexPropDefs.gap, px: V.paddingPropDefs.px, pl: V.paddingPropDefs.pl, pr: V.paddingPropDefs.pr };
+var ar = Object.defineProperty, Hm = Object.getOwnPropertyDescriptor, Jm = Object.getOwnPropertyNames, Sm = Object.prototype.hasOwnProperty, Km = (r, e) => {
+  for (var a in e) ar(r, a, { get: e[a], enumerable: !0 });
+}, Qm = (r, e, a, o) => {
+  if (e && typeof e == "object" || typeof e == "function") for (let t of Jm(e)) !Sm.call(r, t) && t !== a && ar(r, t, { get: () => e[t], enumerable: !(o = Hm(e, t)) || o.enumerable });
+  return r;
+}, Xm = (r) => Qm(ar({}, "__esModule", { value: !0 }), r), Vt = {};
+Km(Vt, { textPropDefs: () => lb });
+var Ym = Xm(Vt), Um = p, Zm = l, eb = i, rb = w, tb = ee, ab = u, ob = $, sb = D;
+const nb = ["span", "div", "label", "p"], pb = ["1", "2", "3", "4", "5", "6", "7", "8", "9"], lb = { as: { type: "enum", values: nb, default: "span" }, ...Um.asChildPropDef, size: { type: "enum", className: "rt-r-size", values: pb, responsive: !0 }, ...sb.weightPropDef, ...tb.textAlignPropDef, ...rb.leadingTrimPropDef, ...ob.truncatePropDef, ...ab.textWrapPropDef, ...Zm.colorPropDef, ...eb.highContrastPropDef };
+var or = Object.defineProperty, ib = Object.getOwnPropertyDescriptor, cb = Object.getOwnPropertyNames, vb = Object.prototype.hasOwnProperty, fb = (r, e) => {
+  for (var a in e) or(r, a, { get: e[a], enumerable: !0 });
+}, ub = (r, e, a, o) => {
+  if (e && typeof e == "object" || typeof e == "function") for (let t of cb(e)) !vb.call(r, t) && t !== a && or(r, t, { get: () => e[t], enumerable: !(o = ib(e, t)) || o.enumerable });
+  return r;
+}, $b = (r) => ub(or({}, "__esModule", { value: !0 }), r), At = {};
+fb(At, { themePropDefs: () => Ob });
+var yb = $b(At), mb = p, cr = l, bb = c;
+const Pb = ["inherit", "light", "dark"], gb = ["solid", "translucent"], db = ["90%", "95%", "100%", "105%", "110%"], Ob = { ...mb.asChildPropDef, hasBackground: { type: "boolean", default: !0 }, appearance: { type: "enum", values: Pb, default: "inherit" }, accentColor: { type: "enum", values: cr.accentColors, default: "indigo" }, grayColor: { type: "enum", values: cr.grayColors, default: "auto" }, panelBackground: { type: "enum", values: gb, default: "translucent" }, radius: { type: "enum", values: bb.radii, default: "medium" }, scaling: { type: "enum", values: db, default: "100%" } };
+var sr = Object.defineProperty, Db = Object.getOwnPropertyDescriptor, jb = Object.getOwnPropertyNames, hb = Object.prototype.hasOwnProperty, wb = (r, e) => {
+  for (var a in e) sr(r, a, { get: e[a], enumerable: !0 });
+}, Nb = (r, e, a, o) => {
+  if (e && typeof e == "object" || typeof e == "function") for (let t of jb(e)) !hb.call(r, t) && t !== a && sr(r, t, { get: () => e[t], enumerable: !(o = Db(e, t)) || o.enumerable });
+  return r;
+}, _b = (r) => Nb(sr({}, "__esModule", { value: !0 }), r), Bt = {};
+wb(Bt, { tooltipPropDefs: () => Cb });
+var xb = _b(Bt), A = f;
+const Cb = { content: { type: "ReactNode", required: !0 }, width: A.widthPropDefs.width, minWidth: A.widthPropDefs.minWidth, maxWidth: { ...A.widthPropDefs.maxWidth, default: "360px" } };
+B.exports;
+(function(r) {
+  var e = Object.defineProperty, a = Object.getOwnPropertyDescriptor, o = Object.getOwnPropertyNames, t = Object.prototype.hasOwnProperty, y = (m, v, N, nr) => {
+    if (v && typeof v == "object" || typeof v == "function") for (let j of o(v)) !t.call(m, j) && j !== N && e(m, j, { get: () => v[j], enumerable: !(nr = a(v, j)) || nr.enumerable });
+    return m;
+  }, n = (m, v, N) => (y(m, v, "default"), N && y(N, v, "default")), Lt = (m) => y(e({}, "__esModule", { value: !0 }), m), s = {};
+  r.exports = Lt(s), n(s, Qt, r.exports), n(s, p, r.exports), n(s, l, r.exports), n(s, T, r.exports), n(s, O, r.exports), n(s, i, r.exports), n(s, eo, r.exports), n(s, w, r.exports), n(s, jo, r.exports), n(s, C, r.exports), n(s, c, r.exports), n(s, ee, r.exports), n(s, u, r.exports), n(s, $, r.exports), n(s, D, r.exports), n(s, f, r.exports), n(s, ws, r.exports), n(s, Ws, r.exports), n(s, Ss, r.exports), n(s, pn, r.exports), n(s, jn, r.exports), n(s, Sn, r.exports), n(s, rp, r.exports), n(s, $p, r.exports), n(s, Ep, r.exports), n(s, vl, r.exports), n(s, Ol, r.exports), n(s, Cl, r.exports), n(s, Hl, r.exports), n(s, gi, r.exports), n(s, Ni, r.exports), n(s, Cr, r.exports), n(s, Gi, r.exports), n(s, Xi, r.exports), n(s, tt, r.exports), n(s, ye, r.exports), n(s, jc, r.exports), n(s, Ec, r.exports), n(s, Uc, r.exports), n(s, nv, r.exports), n(s, bv, r.exports), n(s, _v, r.exports), n(s, Tv, r.exports), n(s, rf, r.exports), n(s, yf, r.exports), n(s, Bf, r.exports), n(s, Jf, r.exports), n(s, su, r.exports), n(s, Pu, r.exports), n(s, zu, r.exports), n(s, Fu, r.exports), n(s, Zu, r.exports), n(s, $$, r.exports), n(s, w$, r.exports), n(s, I$, r.exports), n(s, K$, r.exports), n(s, ay, r.exports), n(s, $y, r.exports), n(s, qy, r.exports), n(s, Qy, r.exports), n(s, $m, r.exports), n(s, hm, r.exports), n(s, Am, r.exports), n(s, Ym, r.exports), n(s, yb, r.exports), n(s, xb, r.exports);
+})(B);
+var qt = B.exports;
+const zb = /* @__PURE__ */ Et(qt), kb = /* @__PURE__ */ Ft({
+  __proto__: null,
+  default: zb
+}, [qt]);
+export {
+  kb as uiProps
+};