@new-black/lyra 0.0.28 → 0.1.1

package/dist/lyra43.js

@@ -1,168 +1,2072 @@
-import { getDefaultExportFromCjs as r } from "./lyra94.js";
-import { p as o } from "./lyra41.js";
-const l = o;
-function i(a) {
-  return Object.fromEntries(
-    Object.entries(a).filter(([e]) => e !== "DEFAULT")
-  );
-}
-var s = l(
-  ({ addUtilities: a, matchUtilities: e, theme: n }) => {
-    a({
-      "@keyframes enter": n("keyframes.enter"),
-      "@keyframes exit": n("keyframes.exit"),
-      ".animate-in": {
-        animationName: "enter",
-        animationDuration: n("animationDuration.DEFAULT"),
-        "--tw-enter-opacity": "initial",
-        "--tw-enter-scale": "initial",
-        "--tw-enter-rotate": "initial",
-        "--tw-enter-translate-x": "initial",
-        "--tw-enter-translate-y": "initial"
-      },
-      ".animate-out": {
-        animationName: "exit",
-        animationDuration: n("animationDuration.DEFAULT"),
-        "--tw-exit-opacity": "initial",
-        "--tw-exit-scale": "initial",
-        "--tw-exit-rotate": "initial",
-        "--tw-exit-translate-x": "initial",
-        "--tw-exit-translate-y": "initial"
+import { useObjectRef as V, mergeRefs as q, mergeProps as x, filterDOMProps as g, useLayoutEffect as me, useViewportSize as _e, useResizeObserver as Ae } from "./lyra61.js";
+import o, { forwardRef as m, useRef as k, useContext as y, useMemo as O, useEffect as Z, createContext as $, useState as I, useCallback as K, cloneElement as ve } from "react";
+import qe, { createPortal as ze } from "react-dom";
+import { s as Ge } from "./lyra115.js";
+import { useHover as H, usePress as he } from "./lyra71.js";
+import { useFocusRing as B, FocusableProvider as Ue, FocusScope as We } from "./lyra55.js";
+import { useOverlayTriggerState as ee } from "./lyra116.js";
+import { useOverlayTrigger as je, usePopover as Qe, Overlay as ge, DismissButton as J, useModalOverlay as Xe, OverlayContainer as Ye, useOverlayPosition as Je } from "./lyra82.js";
+import { useButton as Ze } from "./lyra70.js";
+import { useCheckboxGroupState as et } from "./lyra117.js";
+import { useCheckboxGroup as tt, useCheckboxGroupItem as at, useCheckbox as it } from "./lyra72.js";
+import { useToggleState as lt } from "./lyra75.js";
+import { VisuallyHidden as te } from "./lyra92.js";
+import { useRadioGroupState as rt } from "./lyra118.js";
+import { useRadioGroup as st, useRadio as nt } from "./lyra95.js";
+import { useTextField as ot } from "./lyra91.js";
+import { useTooltipTriggerState as dt } from "./lyra119.js";
+import { useTooltipTrigger as ct, useTooltip as ut } from "./lyra99.js";
+import { useListState as ft } from "./lyra120.js";
+import { ListKeyboardDelegate as bt } from "./lyra87.js";
+import { useListBox as $t, useListBoxSection as pt, useOption as mt } from "./lyra86.js";
+import { useTimeFieldState as vt } from "./lyra121.js";
+import { useTimeField as ht, useDateSegment as gt } from "./lyra76.js";
+import { useDialog as xt } from "./lyra81.js";
+import { useNumberFieldState as yt } from "./lyra122.js";
+import { useNumberField as Pt } from "./lyra90.js";
+import { useProgressBar as St } from "./lyra94.js";
+import { useSelectState as Dt } from "./lyra123.js";
+import { useSelect as Ct, HiddenSelect as Et } from "./lyra96.js";
+import { useSliderState as kt } from "./lyra124.js";
+import { useSlider as Rt, useSliderThumb as wt } from "./lyra98.js";
+import { useIsSSR as Nt } from "./lyra49.js";
+import { SSRProvider as Zi } from "./lyra49.js";
+import { useSeparator as Tt } from "./lyra97.js";
+import { useLocale as ae, useNumberFormatter as Ft } from "./lyra42.js";
+class ie {
+  get childNodes() {
+    throw new Error("childNodes is not supported");
+  }
+  clone() {
+    let e = new ie(this.type, this.key);
+    return e.value = this.value, e.level = this.level, e.hasChildNodes = this.hasChildNodes, e.rendered = this.rendered, e.textValue = this.textValue, e["aria-label"] = this["aria-label"], e.index = this.index, e.parentKey = this.parentKey, e.prevKey = this.prevKey, e.nextKey = this.nextKey, e.firstChildKey = this.firstChildKey, e.lastChildKey = this.lastChildKey, e.props = this.props, e;
+  }
+  constructor(e, a) {
+    this.value = null, this.level = 0, this.hasChildNodes = !1, this.rendered = null, this.textValue = "", this["aria-label"] = void 0, this.index = 0, this.parentKey = null, this.prevKey = null, this.nextKey = null, this.firstChildKey = null, this.lastChildKey = null, this.props = {}, this.type = e, this.key = a;
+  }
+}
+class xe {
+  *[Symbol.iterator]() {
+    let e = this.firstChild;
+    for (; e; )
+      yield e, e = e.nextSibling;
+  }
+  get firstChild() {
+    return this._firstChild;
+  }
+  set firstChild(e) {
+    this._firstChild = e, this.ownerDocument.markDirty(this);
+  }
+  get lastChild() {
+    return this._lastChild;
+  }
+  set lastChild(e) {
+    this._lastChild = e, this.ownerDocument.markDirty(this);
+  }
+  get previousSibling() {
+    return this._previousSibling;
+  }
+  set previousSibling(e) {
+    this._previousSibling = e, this.ownerDocument.markDirty(this);
+  }
+  get nextSibling() {
+    return this._nextSibling;
+  }
+  set nextSibling(e) {
+    this._nextSibling = e, this.ownerDocument.markDirty(this);
+  }
+  get parentNode() {
+    return this._parentNode;
+  }
+  set parentNode(e) {
+    this._parentNode = e, this.ownerDocument.markDirty(this);
+  }
+  appendChild(e) {
+    this.ownerDocument.startTransaction(), e.parentNode && e.parentNode.removeChild(e), this.firstChild == null && (this.firstChild = e), this.lastChild ? (this.lastChild.nextSibling = e, e.index = this.lastChild.index + 1, e.previousSibling = this.lastChild) : (e.previousSibling = null, e.index = 0), e.parentNode = this, e.nextSibling = null, this.lastChild = e, this.ownerDocument.markDirty(this), e.hasSetProps && this.ownerDocument.addNode(e), this.ownerDocument.endTransaction(), this.ownerDocument.queueUpdate();
+  }
+  insertBefore(e, a) {
+    if (a == null)
+      return this.appendChild(e);
+    this.ownerDocument.startTransaction(), e.parentNode && e.parentNode.removeChild(e), e.nextSibling = a, e.previousSibling = a.previousSibling, e.index = a.index, this.firstChild === a ? this.firstChild = e : a.previousSibling && (a.previousSibling.nextSibling = e), a.previousSibling = e, e.parentNode = a.parentNode;
+    let i = a;
+    for (; i; )
+      i.index++, i = i.nextSibling;
+    e.hasSetProps && this.ownerDocument.addNode(e), this.ownerDocument.endTransaction(), this.ownerDocument.queueUpdate();
+  }
+  removeChild(e) {
+    if (e.parentNode !== this)
+      return;
+    this.ownerDocument.startTransaction();
+    let a = e.nextSibling;
+    for (; a; )
+      a.index--, a = a.nextSibling;
+    e.nextSibling && (e.nextSibling.previousSibling = e.previousSibling), e.previousSibling && (e.previousSibling.nextSibling = e.nextSibling), this.firstChild === e && (this.firstChild = e.nextSibling), this.lastChild === e && (this.lastChild = e.previousSibling), e.parentNode = null, e.nextSibling = null, e.previousSibling = null, e.index = 0, this.ownerDocument.removeNode(e), this.ownerDocument.endTransaction(), this.ownerDocument.queueUpdate();
+  }
+  addEventListener() {
+  }
+  removeEventListener() {
+  }
+  constructor(e) {
+    this._firstChild = null, this._lastChild = null, this._previousSibling = null, this._nextSibling = null, this._parentNode = null, this.ownerDocument = e;
+  }
+}
+let Mt = 0;
+class A extends xe {
+  get index() {
+    return this._index;
+  }
+  set index(e) {
+    this._index = e, this.ownerDocument.markDirty(this);
+  }
+  get level() {
+    return this.parentNode instanceof A ? this.parentNode.level + (this.node.type === "item" ? 1 : 0) : 0;
+  }
+  updateNode() {
+    var e, a, i, l;
+    let r = this.ownerDocument.getMutableNode(this);
+    r.index = this.index, r.level = this.level, r.parentKey = this.parentNode instanceof A ? this.parentNode.node.key : null;
+    var n;
+    r.prevKey = (n = (e = this.previousSibling) === null || e === void 0 ? void 0 : e.node.key) !== null && n !== void 0 ? n : null;
+    var s;
+    r.nextKey = (s = (a = this.nextSibling) === null || a === void 0 ? void 0 : a.node.key) !== null && s !== void 0 ? s : null, r.hasChildNodes = !!this.firstChild;
+    var d;
+    r.firstChildKey = (d = (i = this.firstChild) === null || i === void 0 ? void 0 : i.node.key) !== null && d !== void 0 ? d : null;
+    var c;
+    r.lastChildKey = (c = (l = this.lastChild) === null || l === void 0 ? void 0 : l.node.key) !== null && c !== void 0 ? c : null;
+  }
+  setProps(e, a, i) {
+    let l = this.ownerDocument.getMutableNode(this), { value: r, textValue: n, id: s, ...d } = e;
+    if (d.ref = a, l.props = d, l.rendered = i, l.value = r, l.textValue = n || (typeof i == "string" ? i : "") || e["aria-label"] || "", s != null && s !== l.key) {
+      if (this.hasSetProps)
+        throw new Error("Cannot change the id of an item");
+      l.key = s;
+    }
+    this.hasSetProps || (this.ownerDocument.addNode(this), this.ownerDocument.endTransaction(), this.hasSetProps = !0), this.ownerDocument.queueUpdate();
+  }
+  get style() {
+    return {};
+  }
+  hasAttribute() {
+  }
+  setAttribute() {
+  }
+  setAttributeNS() {
+  }
+  removeAttribute() {
+  }
+  constructor(e, a) {
+    super(a), this.nodeType = 8, this._index = 0, this.hasSetProps = !1, this.node = new ie(e, `react-aria-${++Mt}`), this.ownerDocument.startTransaction();
+  }
+}
+class Ot {
+  get size() {
+    return this.keyMap.size;
+  }
+  getKeys() {
+    return this.keyMap.keys();
+  }
+  *[Symbol.iterator]() {
+    let e = this.firstKey != null ? this.keyMap.get(this.firstKey) : void 0;
+    for (; e; )
+      yield e, e = e.nextKey != null ? this.keyMap.get(e.nextKey) : void 0;
+  }
+  getChildren(e) {
+    let a = this.keyMap;
+    return {
+      *[Symbol.iterator]() {
+        let i = a.get(e), l = (i == null ? void 0 : i.firstChildKey) != null ? a.get(i.firstChildKey) : null;
+        for (; l; )
+          yield l, l = l.nextKey != null ? a.get(l.nextKey) : void 0;
       }
-    }), e(
-      {
-        "fade-in": (t) => ({ "--tw-enter-opacity": t }),
-        "fade-out": (t) => ({ "--tw-exit-opacity": t })
-      },
-      { values: n("animationOpacity") }
-    ), e(
-      {
-        "zoom-in": (t) => ({ "--tw-enter-scale": t }),
-        "zoom-out": (t) => ({ "--tw-exit-scale": t })
-      },
-      { values: n("animationScale") }
-    ), e(
-      {
-        "spin-in": (t) => ({ "--tw-enter-rotate": t }),
-        "spin-out": (t) => ({ "--tw-exit-rotate": t })
-      },
-      { values: n("animationRotate") }
-    ), e(
-      {
-        "slide-in-from-top": (t) => ({
-          "--tw-enter-translate-y": `-${t}`
-        }),
-        "slide-in-from-bottom": (t) => ({
-          "--tw-enter-translate-y": t
-        }),
-        "slide-in-from-left": (t) => ({
-          "--tw-enter-translate-x": `-${t}`
-        }),
-        "slide-in-from-right": (t) => ({
-          "--tw-enter-translate-x": t
-        }),
-        "slide-out-to-top": (t) => ({
-          "--tw-exit-translate-y": `-${t}`
-        }),
-        "slide-out-to-bottom": (t) => ({
-          "--tw-exit-translate-y": t
-        }),
-        "slide-out-to-left": (t) => ({
-          "--tw-exit-translate-x": `-${t}`
-        }),
-        "slide-out-to-right": (t) => ({
-          "--tw-exit-translate-x": t
-        })
-      },
-      { values: n("animationTranslate") }
-    ), e(
-      { duration: (t) => ({ animationDuration: t }) },
-      { values: i(n("animationDuration")) }
-    ), e(
-      { delay: (t) => ({ animationDelay: t }) },
-      { values: n("animationDelay") }
-    ), e(
-      { ease: (t) => ({ animationTimingFunction: t }) },
-      { values: i(n("animationTimingFunction")) }
-    ), a({
-      ".running": { animationPlayState: "running" },
-      ".paused": { animationPlayState: "paused" }
-    }), e(
-      { "fill-mode": (t) => ({ animationFillMode: t }) },
-      { values: n("animationFillMode") }
-    ), e(
-      { direction: (t) => ({ animationDirection: t }) },
-      { values: n("animationDirection") }
-    ), e(
-      { repeat: (t) => ({ animationIterationCount: t }) },
-      { values: n("animationRepeat") }
-    );
-  },
-  {
-    theme: {
-      extend: {
-        animationDelay: ({ theme: a }) => ({
-          ...a("transitionDelay")
-        }),
-        animationDuration: ({ theme: a }) => ({
-          0: "0ms",
-          ...a("transitionDuration")
-        }),
-        animationTimingFunction: ({ theme: a }) => ({
-          ...a("transitionTimingFunction")
-        }),
-        animationFillMode: {
-          none: "none",
-          forwards: "forwards",
-          backwards: "backwards",
-          both: "both"
-        },
-        animationDirection: {
-          normal: "normal",
-          reverse: "reverse",
-          alternate: "alternate",
-          "alternate-reverse": "alternate-reverse"
-        },
-        animationOpacity: ({ theme: a }) => ({
-          DEFAULT: 0,
-          ...a("opacity")
-        }),
-        animationTranslate: ({ theme: a }) => ({
-          DEFAULT: "100%",
-          ...a("translate")
-        }),
-        animationScale: ({ theme: a }) => ({
-          DEFAULT: 0,
-          ...a("scale")
-        }),
-        animationRotate: ({ theme: a }) => ({
-          DEFAULT: "30deg",
-          ...a("rotate")
-        }),
-        animationRepeat: {
-          0: "0",
-          1: "1",
-          infinite: "infinite"
-        },
-        keyframes: {
-          enter: {
-            from: {
-              opacity: "var(--tw-enter-opacity, 1)",
-              transform: "translate3d(var(--tw-enter-translate-x, 0), var(--tw-enter-translate-y, 0), 0) scale3d(var(--tw-enter-scale, 1), var(--tw-enter-scale, 1), var(--tw-enter-scale, 1)) rotate(var(--tw-enter-rotate, 0))"
-            }
-          },
-          exit: {
-            to: {
-              opacity: "var(--tw-exit-opacity, 1)",
-              transform: "translate3d(var(--tw-exit-translate-x, 0), var(--tw-exit-translate-y, 0), 0) scale3d(var(--tw-exit-scale, 1), var(--tw-exit-scale, 1), var(--tw-exit-scale, 1)) rotate(var(--tw-exit-rotate, 0))"
-            }
+    };
+  }
+  getKeyBefore(e) {
+    let a = this.keyMap.get(e);
+    if (!a)
+      return null;
+    if (a.prevKey != null) {
+      for (a = this.keyMap.get(a.prevKey); a && a.type !== "item" && a.lastChildKey != null; )
+        a = this.keyMap.get(a.lastChildKey);
+      var i;
+      return (i = a == null ? void 0 : a.key) !== null && i !== void 0 ? i : null;
+    }
+    return a.parentKey;
+  }
+  getKeyAfter(e) {
+    let a = this.keyMap.get(e);
+    if (!a)
+      return null;
+    if (a.type !== "item" && a.firstChildKey != null)
+      return a.firstChildKey;
+    for (; a; ) {
+      if (a.nextKey != null)
+        return a.nextKey;
+      if (a.parentKey != null)
+        a = this.keyMap.get(a.parentKey);
+      else
+        return null;
+    }
+    return null;
+  }
+  getFirstKey() {
+    return this.firstKey;
+  }
+  getLastKey() {
+    let e = this.lastKey != null ? this.keyMap.get(this.lastKey) : null;
+    for (; (e == null ? void 0 : e.lastChildKey) != null; )
+      e = this.keyMap.get(e.lastChildKey);
+    var a;
+    return (a = e == null ? void 0 : e.key) !== null && a !== void 0 ? a : null;
+  }
+  getItem(e) {
+    var a;
+    return (a = this.keyMap.get(e)) !== null && a !== void 0 ? a : null;
+  }
+  at() {
+    throw new Error("Not implemented");
+  }
+  clone() {
+    let e = this.constructor, a = new e();
+    return a.keyMap = new Map(this.keyMap), a.firstKey = this.firstKey, a.lastKey = this.lastKey, a;
+  }
+  addNode(e) {
+    if (this.frozen)
+      throw new Error("Cannot add a node to a frozen collection");
+    this.keyMap.set(e.key, e);
+  }
+  removeNode(e) {
+    if (this.frozen)
+      throw new Error("Cannot remove a node to a frozen collection");
+    this.keyMap.delete(e);
+  }
+  commit(e, a) {
+    if (this.frozen)
+      throw new Error("Cannot commit a frozen collection");
+    this.firstKey = e, this.lastKey = a, this.frozen = !0;
+  }
+  constructor() {
+    this.keyMap = /* @__PURE__ */ new Map(), this.firstKey = null, this.lastKey = null, this.frozen = !1;
+  }
+}
+class It extends xe {
+  createElement(e) {
+    return new A(e, this);
+  }
+  /**
+  * Lazily gets a mutable instance of a Node. If the node has already
+  * been cloned during this update cycle, it just returns the existing one.
+  */
+  getMutableNode(e) {
+    let a = e.node;
+    return this.mutatedNodes.has(e) || (a = e.node.clone(), this.mutatedNodes.add(e), e.node = a), this.markDirty(e), a;
+  }
+  getMutableCollection() {
+    return this.collectionMutated || (this.collection = this.collection.clone(), this.collectionMutated = !0), this.collection;
+  }
+  markDirty(e) {
+    this.dirtyNodes.add(e);
+  }
+  startTransaction() {
+    this.transactionCount++;
+  }
+  endTransaction() {
+    this.transactionCount--;
+  }
+  addNode(e) {
+    let a = this.getMutableCollection();
+    if (!a.getItem(e.node.key)) {
+      a.addNode(e.node);
+      for (let i of e)
+        this.addNode(i);
+    }
+    this.markDirty(e);
+  }
+  removeNode(e) {
+    for (let i of e)
+      i.parentNode = null, this.removeNode(i);
+    this.getMutableCollection().removeNode(e.node.key), this.markDirty(e);
+  }
+  /** Finalizes the collection update, updating all nodes and freezing the collection. */
+  getCollection() {
+    if (this.transactionCount > 0)
+      return this.collection;
+    for (let r of this.dirtyNodes)
+      r instanceof A && r.parentNode && r.updateNode();
+    if (this.dirtyNodes.clear(), this.mutatedNodes.size) {
+      var e, a;
+      let r = this.getMutableCollection();
+      for (let n of this.mutatedNodes)
+        n.parentNode && r.addNode(n.node);
+      var i, l;
+      r.commit((i = (e = this.firstChild) === null || e === void 0 ? void 0 : e.node.key) !== null && i !== void 0 ? i : null, (l = (a = this.lastChild) === null || a === void 0 ? void 0 : a.node.key) !== null && l !== void 0 ? l : null), this.mutatedNodes.clear();
+    }
+    return this.collectionMutated = !1, this.collection;
+  }
+  queueUpdate() {
+    if (!(this.dirtyNodes.size === 0 || this.transactionCount > 0))
+      for (let e of this.subscriptions)
+        e();
+  }
+  subscribe(e) {
+    return this.subscriptions.add(e), () => this.subscriptions.delete(e);
+  }
+  constructor(e) {
+    super(null), this.nodeType = 11, this.ownerDocument = this, this.dirtyNodes = /* @__PURE__ */ new Set(), this.mutatedNodes = /* @__PURE__ */ new Set(), this.subscriptions = /* @__PURE__ */ new Set(), this.transactionCount = 0, this.collection = e, this.collectionMutated = !0;
+  }
+}
+function le(t) {
+  let { children: e, items: a, idScope: i, addIdAndValue: l } = t, r = O(() => /* @__PURE__ */ new WeakMap(), []);
+  return O(() => {
+    if (a && typeof e == "function") {
+      let d = [];
+      for (let c of a) {
+        let u = r.get(c);
+        if (!u) {
+          if (u = e(c), u.key == null) {
+            var n, s;
+            let f = (s = (n = u.props.id) !== null && n !== void 0 ? n : c.key) !== null && s !== void 0 ? s : c.id;
+            if (f == null)
+              throw new Error("Could not determine key for item");
+            i && (f = i + ":" + f), u = /* @__PURE__ */ ve(u, l ? {
+              key: f,
+              id: f,
+              value: c
+            } : {
+              key: f
+            });
           }
+          r.set(c, u);
         }
+        d.push(u);
       }
+      return d;
+    } else if (typeof e != "function")
+      return e;
+  }, [
+    e,
+    a,
+    r,
+    i,
+    l
+  ]);
+}
+function ye(t) {
+  return le({
+    ...t,
+    addIdAndValue: !0
+  });
+}
+const Pe = /* @__PURE__ */ $(!1);
+function Se(t, e) {
+  let { collection: a, document: i } = Kt(e);
+  return {
+    portal: Vt(t, i),
+    collection: a
+  };
+}
+function Kt(t) {
+  let e = O(() => new It(t || new Ot()), [
+    t
+  ]), a = K((r) => e.subscribe(r), [
+    e
+  ]), i = K(() => e.getCollection(), [
+    e
+  ]);
+  return {
+    collection: Ge.useSyncExternalStore(a, i, i),
+    document: e
+  };
+}
+function Vt(t, e) {
+  let a = ye(t), i = O(() => /* @__PURE__ */ o.createElement(Pe.Provider, {
+    value: !0
+  }, a), [
+    a
+  ]);
+  return Nt() ? null : /* @__PURE__ */ ze(i, e);
+}
+function De(t, e, a) {
+  let i = y(Pe);
+  return a = re(e, a, e.children), i ? /* @__PURE__ */ o.createElement(t, {
+    ref: a
+  }) : null;
+}
+function re(t, e, a) {
+  return K((i) => {
+    i == null || i.setProps(t, e, a);
+  }, [
+    t,
+    e,
+    a
+  ]);
+}
+function Ht(t, e) {
+  return /* @__PURE__ */ o.createElement("item", {
+    ref: re(t, e, t.children)
+  });
+}
+const Pi = /* @__PURE__ */ m(Ht);
+function Bt(t, e) {
+  let a = ye(t);
+  return /* @__PURE__ */ o.createElement("section", {
+    ref: re(t, e)
+  }, a);
+}
+const Si = /* @__PURE__ */ m(Bt), Ce = Symbol("callback"), $e = Symbol("default");
+function N({ values: t, children: e }) {
+  for (let [a, i] of t)
+    e = /* @__PURE__ */ o.createElement(a.Provider, {
+      value: i
+    }, e);
+  return e;
+}
+function h(t) {
+  let { className: e, style: a, children: i, defaultClassName: l, defaultChildren: r, values: n } = t;
+  return O(() => {
+    let s, d, c;
+    return typeof e == "function" ? s = e(n) : s = e, typeof a == "function" ? d = a(n) : d = a, typeof i == "function" ? c = i(n) : i == null ? c = r : c = i, {
+      className: s ?? l,
+      style: d,
+      children: c
+    };
+  }, [
+    e,
+    a,
+    i,
+    l,
+    r,
+    n
+  ]);
+}
+function P(t, e, a) {
+  let i = y(a) || {};
+  if ("slots" in i && i.slots) {
+    if (!t.slot && !i.slots[$e])
+      throw new Error("A slot prop is required");
+    let c = t.slot || $e;
+    if (!i.slots[c])
+      throw new Error(`Invalid slot "${t.slot}". Valid slot names are ` + new Intl.ListFormat().format(Object.keys(i.slots).map((u) => `"${u}"`)) + ".");
+    i = i.slots[c];
+  }
+  let { ref: l, [Ce]: r, ...n } = i, s = V(O(() => q(e, l), [
+    e,
+    l
+  ])), d = x(n, t);
+  return Z(() => {
+    r && r(t);
+  }, [
+    r,
+    t
+  ]), [
+    d,
+    s
+  ];
+}
+function T() {
+  let [t, e] = I(!0), a = k(!1), i = K((l) => {
+    a.current = !0, e(!!l);
+  }, []);
+  return me(() => {
+    a.current || e(!1);
+  }, []), [
+    i,
+    t
+  ];
+}
+function Q(t, e = !0) {
+  let [a, i] = I(!0);
+  return Ee(t, a && e, K(() => i(!1), [])), a && e;
+}
+function j(t, e) {
+  let [a, i] = I(!1), [l, r] = I("idle");
+  return !e && t.current && l === "idle" && (a = !0, i(!0), r("exiting")), !t.current && l === "exited" && r("idle"), Ee(t, a, K(() => {
+    r("exited"), i(!1);
+  }, [])), a;
+}
+function Ee(t, e, a) {
+  let i = k(null);
+  e && t.current && (i.current = window.getComputedStyle(t.current).animation), me(() => {
+    if (e && t.current) {
+      let l = window.getComputedStyle(t.current);
+      if (l.animationName !== "none" && l.animation !== i.current) {
+        let r = (s) => {
+          s.target === t.current && (n.removeEventListener("animationend", r), qe.flushSync(() => {
+            a();
+          }));
+        }, n = t.current;
+        return n.addEventListener("animationend", r), () => {
+          n.removeEventListener("animationend", r);
+        };
+      } else
+        a();
     }
+  }, [
+    t,
+    e,
+    a
+  ]);
+}
+const ke = /* @__PURE__ */ $(!1), Lt = /* @__PURE__ */ $({}), _t = /* @__PURE__ */ new Set([
+  "form",
+  "formAction",
+  "formEncType",
+  "formMethod",
+  "formNoValidate",
+  "formTarget",
+  "name",
+  "value"
+]), z = /* @__PURE__ */ $({});
+function At(t, e) {
+  [t, e] = P(t, e, z);
+  let a = t, { buttonProps: i, isPressed: l } = Ze(t, e), { focusProps: r, isFocused: n, isFocusVisible: s } = B(t), { hoverProps: d, isHovered: c } = H(t), u = h({
+    ...t,
+    values: {
+      isHovered: c,
+      isPressed: l,
+      isFocused: n,
+      isFocusVisible: s,
+      isDisabled: t.isDisabled || !1
+    },
+    defaultClassName: "react-aria-Button"
+  });
+  return /* @__PURE__ */ o.createElement("button", {
+    ...g(t, {
+      propNames: _t
+    }),
+    ...x(i, r, d),
+    ...u,
+    ref: e,
+    slot: t.slot,
+    "data-pressed": a.isPressed || l || void 0,
+    "data-hovered": c || void 0,
+    "data-focused": n || void 0,
+    "data-focus-visible": s || void 0
+  });
+}
+const Di = /* @__PURE__ */ m(At), L = /* @__PURE__ */ $({}), F = /* @__PURE__ */ $({});
+function qt(t, e) {
+  [t, e] = P(t, e, F);
+  let { elementType: a = "label", ...i } = t;
+  return /* @__PURE__ */ o.createElement(a, {
+    className: "react-aria-Label",
+    ...i,
+    ref: e
+  });
+}
+const Ci = /* @__PURE__ */ m(qt), zt = /* @__PURE__ */ $(null), Re = /* @__PURE__ */ $(null);
+function Gt(t, e) {
+  [t, e] = P(t, e, zt);
+  let a = et(t), [i, l] = T(), { groupProps: r, labelProps: n, descriptionProps: s, errorMessageProps: d } = tt({
+    ...t,
+    label: l
+  }, a), c = h({
+    ...t,
+    values: {
+      isDisabled: a.isDisabled,
+      isReadOnly: a.isReadOnly,
+      isRequired: t.isRequired || !1,
+      validationState: a.validationState,
+      state: a
+    },
+    defaultClassName: "react-aria-CheckboxGroup"
+  });
+  return /* @__PURE__ */ o.createElement("div", {
+    ...r,
+    ...c,
+    ref: e,
+    slot: t.slot,
+    "data-readonly": a.isReadOnly || void 0,
+    "data-required": t.isRequired || void 0,
+    "data-validation-state": a.validationState || void 0,
+    "data-disabled": t.isDisabled || void 0
+  }, /* @__PURE__ */ o.createElement(N, {
+    values: [
+      [
+        Re,
+        a
+      ],
+      [
+        F,
+        {
+          ...n,
+          ref: i,
+          elementType: "span"
+        }
+      ],
+      [
+        L,
+        {
+          slots: {
+            description: s,
+            errorMessage: d
+          }
+        }
+      ]
+    ]
+  }, c.children));
+}
+const Ut = /* @__PURE__ */ $(null);
+function Wt(t, e) {
+  [t, e] = P(t, e, Ut);
+  let a = y(Re), { inputProps: i, isSelected: l, isDisabled: r, isReadOnly: n, isPressed: s } = a ? at({
+    ...t,
+    // Value is optional for standalone checkboxes, but required for CheckboxGroup items;
+    // it's passed explicitly here to avoid typescript error (requires ignore).
+    // @ts-ignore
+    value: t.value,
+    // ReactNode type doesn't allow function children.
+    children: typeof t.children == "function" ? !0 : t.children
+  }, a, e) : it({
+    ...t,
+    children: typeof t.children == "function" ? !0 : t.children
+  }, lt(t), e), { isFocused: d, isFocusVisible: c, focusProps: u } = B(), f = r || n, [b, p] = I(!1), { pressProps: v } = he({
+    isDisabled: f,
+    onPressStart(w) {
+      w.pointerType !== "keyboard" && p(!0);
+    },
+    onPressEnd(w) {
+      w.pointerType !== "keyboard" && p(!1);
+    }
+  }), { hoverProps: S, isHovered: E } = H({
+    isDisabled: f
+  }), R = f ? !1 : b || s, D = h({
+    // TODO: should data attrs go on the label or on the <input>? useCheckbox passes them to the input...
+    ...t,
+    defaultClassName: "react-aria-Checkbox",
+    values: {
+      isSelected: l,
+      isIndeterminate: t.isIndeterminate || !1,
+      isPressed: R,
+      isHovered: E,
+      isFocused: d,
+      isFocusVisible: c,
+      isDisabled: r,
+      isReadOnly: n,
+      validationState: t.validationState || (a == null ? void 0 : a.validationState),
+      isRequired: t.isRequired || !1
+    }
+  }), C = g(t);
+  return delete C.id, /* @__PURE__ */ o.createElement("label", {
+    ...x(C, v, S, D),
+    slot: t.slot,
+    "data-selected": l || void 0,
+    "data-indeterminate": t.isIndeterminate || void 0,
+    "data-pressed": R || void 0,
+    "data-hovered": E || void 0,
+    "data-focused": d || void 0,
+    "data-focus-visible": c || void 0,
+    "data-disabled": r || void 0,
+    "data-readonly": n || void 0,
+    "data-validation-state": t.validationState || (a == null ? void 0 : a.validationState) || void 0,
+    "data-required": t.isRequired || void 0
+  }, /* @__PURE__ */ o.createElement(te, {
+    elementType: "span"
+  }, /* @__PURE__ */ o.createElement("input", {
+    ...i,
+    ...u,
+    ref: e
+  })), D.children);
+}
+const Ei = /* @__PURE__ */ m(Wt), ki = /* @__PURE__ */ m(Gt), se = /* @__PURE__ */ $({});
+function jt(t, e) {
+  [t, e] = P(t, e, se);
+  let { hoverProps: a, isHovered: i } = H({}), { isFocused: l, isFocusVisible: r, focusProps: n } = B({
+    isTextInput: !0,
+    autoFocus: t.autoFocus
+  }), s = h({
+    ...t,
+    values: {
+      isHovered: i,
+      isFocused: l,
+      isFocusVisible: r,
+      isDisabled: t.disabled || !1
+    },
+    defaultClassName: "react-aria-Input"
+  });
+  return /* @__PURE__ */ o.createElement("input", {
+    ...x(t, n, a),
+    ...s,
+    ref: e,
+    "data-hovered": i || void 0,
+    "data-focus-visible": r || void 0
+  });
+}
+const Ri = /* @__PURE__ */ m(jt), we = /* @__PURE__ */ $(null);
+function Qt(t, e) {
+  let { render: a } = y(we);
+  return /* @__PURE__ */ o.createElement(o.Fragment, null, a(t, e));
+}
+const Xt = /* @__PURE__ */ m(Qt), Yt = /* @__PURE__ */ $({});
+function Jt(t, e) {
+  [t, e] = P(t, e, Yt);
+  let a = De("header", t, e);
+  return a || /* @__PURE__ */ o.createElement("header", {
+    className: "react-aria-Header",
+    ...t,
+    ref: e
+  }, t.children);
+}
+const Zt = /* @__PURE__ */ m(Jt), Ne = /* @__PURE__ */ $({});
+function ea(t, e) {
+  [t, e] = P(t, e, Ne);
+  let { elementType: a, orientation: i, style: l, className: r } = t, n = a || "hr";
+  n === "hr" && i === "vertical" && (n = "div");
+  let { separatorProps: s } = Tt({
+    elementType: a,
+    orientation: i
+  }), d = De("separator", t, e);
+  return d || /* @__PURE__ */ o.createElement(n, {
+    ...g(t),
+    ...s,
+    style: l,
+    className: r ?? "react-aria-Separator",
+    ref: e,
+    slot: t.slot
+  });
+}
+const ta = /* @__PURE__ */ m(ea), Te = /* @__PURE__ */ $(null), X = /* @__PURE__ */ $(null);
+function aa(t, e) {
+  [t, e] = P(t, e, Te);
+  let a = t.state, i = y(ke);
+  return a ? i ? null : /* @__PURE__ */ o.createElement(Fe, {
+    state: a,
+    props: t,
+    listBoxRef: e
+  }) : /* @__PURE__ */ o.createElement(ia, {
+    props: t,
+    listBoxRef: e
+  });
+}
+function ia({ props: t, listBoxRef: e }) {
+  let { portal: a, collection: i } = Se(t);
+  t = {
+    ...t,
+    collection: i,
+    children: null,
+    items: null
+  };
+  let l = ft(t);
+  return /* @__PURE__ */ o.createElement(o.Fragment, null, a, /* @__PURE__ */ o.createElement(Fe, {
+    state: l,
+    props: t,
+    listBoxRef: e
+  }));
+}
+const wi = /* @__PURE__ */ m(aa);
+function Fe({ state: t, props: e, listBoxRef: a }) {
+  let { dragAndDropHooks: i, layout: l = "stack", orientation: r = "vertical" } = e, { collection: n, selectionManager: s } = t, d = !!(i != null && i.useDraggableCollectionState), c = !!(i != null && i.useDroppableCollectionState), { direction: u } = ae(), { disabledBehavior: f, disabledKeys: b } = s, p = O(() => e.keyboardDelegate || new bt({
+    collection: n,
+    ref: a,
+    disabledKeys: f === "selection" ? /* @__PURE__ */ new Set() : b,
+    layout: l,
+    orientation: r,
+    direction: u
+  }), [
+    n,
+    a,
+    f,
+    b,
+    r,
+    u,
+    e.keyboardDelegate,
+    l
+  ]), { listBoxProps: v } = $t({
+    ...e,
+    shouldSelectOnPressUp: d || e.shouldSelectOnPressUp,
+    keyboardDelegate: p
+  }, t, a), S = le({
+    items: n,
+    children: (M) => {
+      switch (M.type) {
+        case "section":
+          return /* @__PURE__ */ o.createElement(la, {
+            section: M
+          });
+        case "separator":
+          return /* @__PURE__ */ o.createElement(ta, M.props);
+        case "item":
+          return /* @__PURE__ */ o.createElement(Me, {
+            item: M
+          });
+        default:
+          throw new Error("Unsupported node type in Menu: " + M.type);
+      }
+    }
+  }), E = k(d), R = k(c);
+  Z(() => {
+    E.current !== d && console.warn("Drag hooks were provided during one render, but not another. This should be avoided as it may produce unexpected behavior."), R.current !== c && console.warn("Drop hooks were provided during one render, but not another. This should be avoided as it may produce unexpected behavior.");
+  }, [
+    d,
+    c
+  ]);
+  let D, C, w, _ = !1, G = null, U = k(null);
+  if (d && i) {
+    D = i.useDraggableCollectionState({
+      collection: n,
+      selectionManager: s,
+      preview: i.renderDragPreview ? U : void 0
+    }), i.useDraggableCollection({}, D, a);
+    let M = i.DragPreview;
+    G = i.renderDragPreview ? /* @__PURE__ */ o.createElement(M, {
+      ref: U
+    }, i.renderDragPreview) : null;
+  }
+  if (c && i) {
+    C = i.useDroppableCollectionState({
+      collection: n,
+      selectionManager: s
+    });
+    let M = i.dropTargetDelegate || new i.ListDropTargetDelegate(n, a, {
+      orientation: r,
+      layout: l,
+      direction: u
+    });
+    w = i.useDroppableCollection({
+      keyboardDelegate: p,
+      dropTargetDelegate: M
+    }, C, a), _ = C.isDropTarget({
+      type: "root"
+    });
   }
-);
-const w = /* @__PURE__ */ r(s);
+  let { focusProps: W, isFocused: ue, isFocusVisible: fe } = B(), Le = h({
+    className: e.className,
+    style: e.style,
+    defaultClassName: "react-aria-ListBox",
+    values: {
+      isDropTarget: _,
+      isEmpty: t.collection.size === 0,
+      isFocused: ue,
+      isFocusVisible: fe,
+      state: t
+    }
+  }), be = null;
+  return t.collection.size === 0 && e.renderEmptyState && (be = /* @__PURE__ */ o.createElement("div", {
+    // eslint-disable-next-line
+    role: "option",
+    style: {
+      display: "contents"
+    }
+  }, e.renderEmptyState())), /* @__PURE__ */ o.createElement(We, null, /* @__PURE__ */ o.createElement("div", {
+    ...g(e),
+    ...x(v, W, w == null ? void 0 : w.collectionProps),
+    ...Le,
+    ref: a,
+    slot: e.slot,
+    "data-drop-target": _ || void 0,
+    "data-empty": t.collection.size === 0 || void 0,
+    "data-focused": ue || void 0,
+    "data-focus-visible": fe || void 0,
+    "data-layout": e.layout || "stack",
+    "data-orientation": e.orientation || "vertical"
+  }, /* @__PURE__ */ o.createElement(N, {
+    values: [
+      [
+        X,
+        {
+          state: t,
+          shouldFocusOnHover: e.shouldFocusOnHover,
+          dragAndDropHooks: i,
+          dragState: D,
+          dropState: C
+        }
+      ],
+      [
+        Ne,
+        {
+          elementType: "li"
+        }
+      ],
+      [
+        we,
+        {
+          render: ra
+        }
+      ]
+    ]
+  }, S), be, G));
+}
+function la({ section: t, className: e, style: a }) {
+  var i, l;
+  let { state: r } = y(X), [n, s] = T();
+  var d;
+  let { headingProps: c, groupProps: u } = pt({
+    heading: s,
+    "aria-label": (d = t["aria-label"]) !== null && d !== void 0 ? d : void 0
+  }), f = le({
+    items: r.collection.getChildren(t.key),
+    children: (b) => {
+      switch (b.type) {
+        case "header": {
+          let { ref: p, ...v } = b.props;
+          return /* @__PURE__ */ o.createElement(Zt, {
+            ...c,
+            ...v,
+            ref: q(n, p)
+          }, b.rendered);
+        }
+        case "item":
+          return /* @__PURE__ */ o.createElement(Me, {
+            item: b
+          });
+        default:
+          throw new Error("Unsupported element type in Section: " + b.type);
+      }
+    }
+  });
+  return /* @__PURE__ */ o.createElement("section", {
+    ...g(t.props),
+    ...u,
+    className: e || ((i = t.props) === null || i === void 0 ? void 0 : i.className) || "react-aria-Section",
+    style: a || ((l = t.props) === null || l === void 0 ? void 0 : l.style),
+    ref: t.props.ref
+  }, f);
+}
+function Me({ item: t }) {
+  let e = V(t.props.ref), { state: a, shouldFocusOnHover: i, dragAndDropHooks: l, dragState: r, dropState: n } = y(X), { optionProps: s, labelProps: d, descriptionProps: c, ...u } = mt({
+    key: t.key
+  }, a, e), { hoverProps: f, isHovered: b } = H({
+    isDisabled: i || !u.allowsSelection && !u.hasAction
+  });
+  i && (f = {}, b = u.isFocused);
+  let p = null;
+  r && l && (p = l.useDraggableItem({
+    key: t.key
+  }, r));
+  let v = null;
+  n && l && (v = l.useDroppableItem({
+    target: {
+      type: "item",
+      key: t.key,
+      dropPosition: "on"
+    }
+  }, n, e));
+  let S = t.props, E = r && r.isDragging(t.key), R = h({
+    ...S,
+    id: void 0,
+    children: t.rendered,
+    defaultClassName: "react-aria-Item",
+    values: {
+      ...u,
+      isHovered: b,
+      selectionMode: a.selectionManager.selectionMode,
+      selectionBehavior: a.selectionManager.selectionBehavior,
+      allowsDragging: !!r,
+      isDragging: E,
+      isDropTarget: v == null ? void 0 : v.isDropTarget
+    }
+  }), D = (l == null ? void 0 : l.renderDropIndicator) || ((C) => /* @__PURE__ */ o.createElement(Xt, {
+    target: C
+  }));
+  return Z(() => {
+    t.textValue || console.warn("A `textValue` prop is required for <Item> elements with non-plain text children in order to support accessibility features such as type to select.");
+  }, [
+    t.textValue
+  ]), /* @__PURE__ */ o.createElement(o.Fragment, null, (l == null ? void 0 : l.useDropIndicator) && D({
+    type: "item",
+    key: t.key,
+    dropPosition: "before"
+  }), /* @__PURE__ */ o.createElement("div", {
+    ...x(g(S), s, f, p == null ? void 0 : p.dragProps, v == null ? void 0 : v.dropProps),
+    ...R,
+    ref: e,
+    "data-hovered": b || void 0,
+    "data-focused": u.isFocused || void 0,
+    "data-focus-visible": u.isFocusVisible || void 0,
+    "data-pressed": u.isPressed || void 0,
+    "data-dragging": E || void 0,
+    "data-drop-target": (v == null ? void 0 : v.isDropTarget) || void 0
+  }, /* @__PURE__ */ o.createElement(N, {
+    values: [
+      [
+        L,
+        {
+          slots: {
+            label: d,
+            description: c
+          }
+        }
+      ]
+    ]
+  }, R.children)), (l == null ? void 0 : l.useDropIndicator) && a.collection.getKeyAfter(t.key) == null && D({
+    type: "item",
+    key: t.key,
+    dropPosition: "after"
+  }));
+}
+function ra(t, e) {
+  e = V(e);
+  let { dragAndDropHooks: a, dropState: i } = y(X), { dropIndicatorProps: l, isHidden: r, isDropTarget: n } = a.useDropIndicator(t, i, e);
+  return r ? null : /* @__PURE__ */ o.createElement(na, {
+    ...t,
+    dropIndicatorProps: l,
+    isDropTarget: n,
+    ref: e
+  });
+}
+function sa(t, e) {
+  let { dropIndicatorProps: a, isDropTarget: i, ...l } = t, r = h({
+    ...l,
+    defaultClassName: "react-aria-DropIndicator",
+    values: {
+      isDropTarget: i
+    }
+  });
+  return /* @__PURE__ */ o.createElement("div", {
+    ...a,
+    ...r,
+    // eslint-disable-next-line
+    role: "option",
+    ref: e,
+    "data-drop-target": i || void 0
+  });
+}
+const na = /* @__PURE__ */ m(sa), ne = /* @__PURE__ */ $(null);
+function oa(t, e) {
+  let { arrowProps: a, placement: i } = y(ne), l = {
+    ...a.style,
+    position: "absolute",
+    [i]: "100%",
+    transform: i === "top" || i === "bottom" ? "translateX(-50%)" : "translateY(-50%)"
+  }, r = h({
+    ...t,
+    defaultClassName: "react-aria-OverlayArrow",
+    values: {
+      placement: i
+    }
+  });
+  return /* @__PURE__ */ o.createElement("div", {
+    ...x(a, t),
+    ...r,
+    style: {
+      ...r.style,
+      ...l
+    },
+    ref: e,
+    "data-placement": i
+  });
+}
+const Ni = /* @__PURE__ */ m(oa), oe = /* @__PURE__ */ $(null);
+function da(t, e) {
+  [t, e] = P(t, e, oe);
+  let a = t, i = ee(t), l = t.isOpen != null || t.defaultOpen != null || !(a != null && a.state) ? i : a.state, r = j(e, l.isOpen);
+  if (l && !l.isOpen && !r) {
+    let n = t.children;
+    return typeof n == "function" && (n = n({
+      placement: "bottom",
+      isEntering: !1,
+      isExiting: !1
+    })), a.preserveChildren ? /* @__PURE__ */ o.createElement(ke.Provider, {
+      value: !0
+    }, n) : null;
+  }
+  return /* @__PURE__ */ o.createElement(ca, {
+    ...t,
+    triggerRef: a.triggerRef,
+    state: l,
+    popoverRef: e,
+    isExiting: r
+  });
+}
+const Ti = /* @__PURE__ */ m(da);
+function ca({ state: t, isExiting: e, ...a }) {
+  var i;
+  let { popoverProps: l, underlayProps: r, arrowProps: n, placement: s } = Qe({
+    ...a,
+    offset: (i = a.offset) !== null && i !== void 0 ? i : 8
+  }, t), d = a.popoverRef, c = Q(d, !!s), u = h({
+    ...a,
+    defaultClassName: "react-aria-Popover",
+    values: {
+      placement: s,
+      isEntering: c,
+      isExiting: e
+    }
+  }), f = {
+    ...u.style,
+    ...l.style
+  };
+  return /* @__PURE__ */ o.createElement(ge, {
+    isExiting: e
+  }, !a.isNonModal && /* @__PURE__ */ o.createElement("div", {
+    ...r,
+    style: {
+      position: "fixed",
+      inset: 0
+    }
+  }), /* @__PURE__ */ o.createElement("div", {
+    ...x(g(a), l),
+    ...u,
+    ref: d,
+    slot: a.slot,
+    style: f,
+    "data-placement": s,
+    "data-entering": c || void 0,
+    "data-exiting": e || void 0
+  }, !a.isNonModal && /* @__PURE__ */ o.createElement(J, {
+    onDismiss: t.close
+  }), /* @__PURE__ */ o.createElement(ne.Provider, {
+    value: {
+      arrowProps: n,
+      placement: s
+    }
+  }, u.children), /* @__PURE__ */ o.createElement(J, {
+    onDismiss: t.close
+  })));
+}
+const ua = /* @__PURE__ */ $(null), Oe = /* @__PURE__ */ $(null);
+function fa(t, e) {
+  [t, e] = P(t, e, ua);
+  let { locale: a } = ae(), i = vt({
+    ...t,
+    locale: a
+  }), l = k(null), [r, n] = T(), s = k(null), { labelProps: d, fieldProps: c, inputProps: u, descriptionProps: f, errorMessageProps: b } = ht({
+    ...t,
+    label: n,
+    inputRef: s
+  }, i, l), p = h({
+    ...t,
+    values: {
+      state: i,
+      validationState: i.validationState,
+      isDisabled: i.isDisabled
+    },
+    defaultClassName: "react-aria-TimeField"
+  }), v = g(t);
+  return delete v.id, /* @__PURE__ */ o.createElement(N, {
+    values: [
+      [
+        Oe,
+        {
+          state: i,
+          fieldProps: c,
+          ref: l,
+          inputRef: s,
+          inputProps: u
+        }
+      ],
+      [
+        F,
+        {
+          ...d,
+          ref: r,
+          elementType: "span"
+        }
+      ],
+      [
+        L,
+        {
+          slots: {
+            description: f,
+            errorMessage: b
+          }
+        }
+      ]
+    ]
+  }, /* @__PURE__ */ o.createElement("div", {
+    ...v,
+    ...p,
+    ref: e,
+    slot: t.slot,
+    "data-validation-date": i.validationState || void 0
+  }));
+}
+const Fi = /* @__PURE__ */ m(fa), Ie = /* @__PURE__ */ $(null);
+function ba({ children: t, slot: e, ...a }, i) {
+  let [{ state: l, fieldProps: r, inputProps: n, inputRef: s }, d] = P({
+    slot: e
+  }, i, Oe), { hoverProps: c, isHovered: u } = H({}), { isFocused: f, isFocusVisible: b, focusProps: p } = B({
+    within: !0,
+    isTextInput: !0
+  }), v = h({
+    ...a,
+    values: {
+      isHovered: u,
+      isFocusWithin: f,
+      isFocusVisible: b,
+      isDisabled: l.isDisabled
+    },
+    defaultClassName: "react-aria-DateInput"
+  });
+  return /* @__PURE__ */ o.createElement(Ie.Provider, {
+    value: l
+  }, /* @__PURE__ */ o.createElement("div", {
+    ...x(g(a), r, p, c),
+    ...v,
+    ref: d,
+    slot: e,
+    "data-hovered": u || void 0,
+    "data-focus-visible": b || void 0,
+    "data-disabled": l.isDisabled || void 0
+  }, l.segments.map((S, E) => /* @__PURE__ */ ve(t(S), {
+    key: E
+  }))), /* @__PURE__ */ o.createElement("input", {
+    ...n,
+    ref: s
+  }));
+}
+const Mi = /* @__PURE__ */ m(ba);
+function $a({ segment: t, ...e }, a) {
+  let i = y(Ie), l = V(a), { segmentProps: r } = gt(t, i, l), n = h({
+    ...e,
+    values: {
+      ...t,
+      isReadOnly: !t.isEditable,
+      isInvalid: i.validationState === "invalid"
+    },
+    defaultChildren: t.text,
+    defaultClassName: "react-aria-DateSegment"
+  });
+  return /* @__PURE__ */ o.createElement("div", {
+    ...x(g(e), r),
+    ...n,
+    ref: l,
+    "data-type": t.type
+  });
+}
+const Oi = /* @__PURE__ */ m($a), Ke = /* @__PURE__ */ $(null), de = /* @__PURE__ */ $(null);
+function pa(t, e) {
+  if (y(de))
+    return /* @__PURE__ */ o.createElement(pe, {
+      ...t,
+      modalRef: e
+    }, t.children);
+  let { isDismissable: i, isKeyboardDismissDisabled: l, isOpen: r, defaultOpen: n, onOpenChange: s, children: d, ...c } = t;
+  return /* @__PURE__ */ o.createElement(va, {
+    isDismissable: i,
+    isKeyboardDismissDisabled: l,
+    isOpen: r,
+    defaultOpen: n,
+    onOpenChange: s
+  }, /* @__PURE__ */ o.createElement(pe, {
+    ...c,
+    modalRef: e
+  }, d));
+}
+const Ii = /* @__PURE__ */ m(pa);
+function ma(t, e) {
+  let a = y(Ke), i = ee(t), l = t.isOpen != null || t.defaultOpen != null || !(a != null && a.state) ? i : a.state, r = V(e), n = k(null), s = j(r, l.isOpen), d = j(n, l.isOpen), c = s || d;
+  return !l.isOpen && !c ? null : /* @__PURE__ */ o.createElement(ha, {
+    ...t,
+    state: l,
+    isExiting: c,
+    overlayRef: r,
+    modalRef: n
+  });
+}
+const va = /* @__PURE__ */ m(ma);
+function ha(t) {
+  let e = t.modalRef, { state: a } = t, { modalProps: i, underlayProps: l } = Xe(t, a, e), r = Q(t.overlayRef), n = h({
+    ...t,
+    defaultClassName: "react-aria-ModalOverlay",
+    values: {
+      isEntering: r,
+      isExiting: t.isExiting,
+      state: a
+    }
+  }), s = _e(), d = {
+    ...n.style,
+    "--visual-viewport-height": s.height + "px"
+  };
+  return /* @__PURE__ */ o.createElement(ge, {
+    isExiting: t.isExiting
+  }, /* @__PURE__ */ o.createElement("div", {
+    ...x(g(t), l),
+    ...n,
+    style: d,
+    ref: t.overlayRef,
+    "data-entering": r || void 0,
+    "data-exiting": t.isExiting || void 0
+  }, /* @__PURE__ */ o.createElement(de.Provider, {
+    value: {
+      modalProps: i,
+      modalRef: e,
+      state: a,
+      isExiting: t.isExiting,
+      isDismissable: t.isDismissable
+    }
+  }, n.children)));
+}
+function pe(t) {
+  let { modalProps: e, modalRef: a, isExiting: i, isDismissable: l, state: r } = y(de), n = O(() => q(t.modalRef, a), [
+    t.modalRef,
+    a
+  ]), s = V(n), d = Q(s), c = h({
+    ...t,
+    defaultClassName: "react-aria-Modal",
+    values: {
+      isEntering: d,
+      isExiting: i,
+      state: r
+    }
+  });
+  return /* @__PURE__ */ o.createElement("div", {
+    ...x(g(t), e),
+    ...c,
+    ref: s,
+    "data-entering": d || void 0,
+    "data-exiting": i || void 0
+  }, l && /* @__PURE__ */ o.createElement(J, {
+    onDismiss: r.close
+  }), c.children);
+}
+const Ve = /* @__PURE__ */ $(null);
+function Ki(t) {
+  let e = ee(t), a = k(null), { triggerProps: i, overlayProps: l } = je({
+    type: "dialog"
+  }, e, a);
+  return /* @__PURE__ */ o.createElement(N, {
+    values: [
+      [
+        Ke,
+        {
+          state: e
+        }
+      ],
+      [
+        Ve,
+        {
+          ...l,
+          onClose: e.close
+        }
+      ],
+      [
+        z,
+        {
+          ...i,
+          isPressed: e.isOpen,
+          ref: a
+        }
+      ],
+      [
+        oe,
+        {
+          state: e,
+          triggerRef: a
+        }
+      ]
+    ]
+  }, t.children);
+}
+function ga(t, e) {
+  [t, e] = P(t, e, Ve);
+  let { dialogProps: a, titleProps: i } = xt(t, e), l = t.children;
+  typeof l == "function" && (l = l({
+    close: t.onClose || (() => {
+    })
+  }));
+  var r;
+  return /* @__PURE__ */ o.createElement("section", {
+    ...g(t),
+    ...a,
+    ref: e,
+    slot: t.slot,
+    style: t.style,
+    className: (r = t.className) !== null && r !== void 0 ? r : "react-aria-Dialog"
+  }, /* @__PURE__ */ o.createElement(N, {
+    values: [
+      [
+        z,
+        void 0
+      ],
+      // TODO: clear context within dialog content?
+      [
+        Lt,
+        {
+          ...i,
+          level: 2
+        }
+      ]
+    ]
+  }, l));
+}
+const Vi = /* @__PURE__ */ m(ga), xa = /* @__PURE__ */ $({}), ya = /* @__PURE__ */ $(null);
+function Pa(t, e) {
+  [t, e] = P(t, e, ya);
+  let { locale: a } = ae(), i = yt({
+    ...t,
+    locale: a
+  }), l = k(null), [r, n] = T(), { labelProps: s, groupProps: d, inputProps: c, incrementButtonProps: u, decrementButtonProps: f, descriptionProps: b, errorMessageProps: p } = Pt({
+    ...t,
+    label: n
+  }, i, l), v = h({
+    ...t,
+    values: {
+      state: i,
+      isDisabled: t.isDisabled || !1,
+      validationState: t.validationState
+    },
+    defaultClassName: "react-aria-NumberField"
+  }), S = g(t);
+  return delete S.id, /* @__PURE__ */ o.createElement(N, {
+    values: [
+      [
+        xa,
+        d
+      ],
+      [
+        se,
+        {
+          ...c,
+          ref: l
+        }
+      ],
+      [
+        F,
+        {
+          ...s,
+          ref: r
+        }
+      ],
+      [
+        z,
+        {
+          slots: {
+            increment: u,
+            decrement: f
+          }
+        }
+      ],
+      [
+        L,
+        {
+          slots: {
+            description: b,
+            errorMessage: p
+          }
+        }
+      ]
+    ]
+  }, /* @__PURE__ */ o.createElement("div", {
+    ...S,
+    ...v,
+    ref: e,
+    slot: t.slot,
+    "data-disabled": t.isDisabled || void 0,
+    "data-validation-state": t.validationState || void 0
+  }), t.name && /* @__PURE__ */ o.createElement("input", {
+    type: "hidden",
+    name: t.name,
+    value: isNaN(i.numberValue) ? "" : i.numberValue
+  }));
+}
+const Hi = /* @__PURE__ */ m(Pa), Sa = /* @__PURE__ */ $(null);
+function Da(t, e) {
+  [t, e] = P(t, e, Sa);
+  let { value: a = 0, minValue: i = 0, maxValue: l = 100, isIndeterminate: r = !1 } = t, [n, s] = T(), { progressBarProps: d, labelProps: c } = St({
+    ...t,
+    label: s
+  }), u = r ? void 0 : (a - i) / (l - i) * 100, f = h({
+    ...t,
+    defaultClassName: "react-aria-ProgressBar",
+    values: {
+      percentage: u,
+      valueText: d["aria-valuetext"],
+      isIndeterminate: r
+    }
+  });
+  return /* @__PURE__ */ o.createElement("div", {
+    ...d,
+    ...f,
+    ref: e,
+    slot: t.slot
+  }, /* @__PURE__ */ o.createElement(F.Provider, {
+    value: {
+      ...c,
+      ref: n,
+      elementType: "span"
+    }
+  }, f.children));
+}
+const Bi = /* @__PURE__ */ m(Da), Ca = /* @__PURE__ */ $(null), Ea = /* @__PURE__ */ $(null);
+let He = /* @__PURE__ */ $(null);
+function ka(t, e) {
+  [t, e] = P(t, e, Ca);
+  let a = rt(t), [i, l] = T(), { radioGroupProps: r, labelProps: n, descriptionProps: s, errorMessageProps: d } = st({
+    ...t,
+    label: l
+  }, a), c = h({
+    ...t,
+    values: {
+      orientation: t.orientation || "vertical",
+      isDisabled: a.isDisabled,
+      isReadOnly: a.isReadOnly,
+      isRequired: a.isRequired,
+      validationState: a.validationState,
+      state: a
+    },
+    defaultClassName: "react-aria-RadioGroup"
+  });
+  return /* @__PURE__ */ o.createElement("div", {
+    ...r,
+    ...c,
+    ref: e,
+    slot: t.slot,
+    "data-validation-state": a.validationState || void 0
+  }, /* @__PURE__ */ o.createElement(N, {
+    values: [
+      [
+        He,
+        a
+      ],
+      [
+        F,
+        {
+          ...n,
+          ref: i,
+          elementType: "span"
+        }
+      ],
+      [
+        L,
+        {
+          slots: {
+            description: s,
+            errorMessage: d
+          }
+        }
+      ]
+    ]
+  }, c.children));
+}
+function Ra(t, e) {
+  [t, e] = P(t, e, Ea);
+  let a = o.useContext(He), i = V(e), { inputProps: l, isSelected: r, isDisabled: n, isPressed: s } = nt({
+    ...t,
+    // ReactNode type doesn't allow function children.
+    children: typeof t.children == "function" ? !0 : t.children
+  }, a, i), { isFocused: d, isFocusVisible: c, focusProps: u } = B(), f = n || a.isReadOnly, [b, p] = I(!1), { pressProps: v } = he({
+    isDisabled: f,
+    onPressStart(w) {
+      w.pointerType !== "keyboard" && p(!0);
+    },
+    onPressEnd(w) {
+      w.pointerType !== "keyboard" && p(!1);
+    }
+  }), { hoverProps: S, isHovered: E } = H({
+    isDisabled: f
+  }), R = f ? !1 : b || s, D = h({
+    ...t,
+    defaultClassName: "react-aria-Radio",
+    values: {
+      isSelected: r,
+      isPressed: R,
+      isHovered: E,
+      isFocused: d,
+      isFocusVisible: c,
+      isDisabled: n,
+      isReadOnly: a.isReadOnly,
+      validationState: a.validationState,
+      isRequired: a.isRequired
+    }
+  }), C = g(t);
+  return delete C.id, /* @__PURE__ */ o.createElement("label", {
+    ...x(C, v, S, D),
+    "data-selected": r || void 0,
+    "data-pressed": R || void 0,
+    "data-hovered": E || void 0,
+    "data-focused": d || void 0,
+    "data-focus-visible": c || void 0,
+    "data-disabled": n || void 0,
+    "data-readonly": a.isReadOnly || void 0,
+    "data-validation-state": a.validationState || void 0,
+    "data-required": a.isRequired || void 0
+  }, /* @__PURE__ */ o.createElement(te, {
+    elementType: "span"
+  }, /* @__PURE__ */ o.createElement("input", {
+    ...x(l, u),
+    ref: i
+  })), D.children);
+}
+const Li = /* @__PURE__ */ m(ka), _i = /* @__PURE__ */ m(Ra), wa = /* @__PURE__ */ $(null), Be = /* @__PURE__ */ $(null);
+function Na(t, e) {
+  [t, e] = P(t, e, wa);
+  let [a, i] = I({
+    children: []
+  });
+  var l;
+  let { portal: r, collection: n } = Se({
+    items: (l = t.items) !== null && l !== void 0 ? l : a.items,
+    children: a.children
+  }), s = Dt({
+    ...t,
+    collection: n,
+    children: void 0
+  }), { isFocusVisible: d, focusProps: c } = B({
+    within: !0
+  }), u = O(() => ({
+    isOpen: s.isOpen,
+    isFocused: s.isFocused,
+    isFocusVisible: d,
+    isDisabled: t.isDisabled || !1,
+    validationState: t.validationState,
+    isRequired: t.isRequired || !1,
+    state: {
+      isFocused: s.isFocused,
+      setFocused: s.setFocused,
+      focusStrategy: s.focusStrategy,
+      isOpen: s.isOpen,
+      setOpen: s.setOpen,
+      selectedKey: s.selectedKey,
+      selectedItem: s.selectedItem,
+      close: s.close
+    }
+  }), [
+    s.isOpen,
+    s.isFocused,
+    s.setFocused,
+    s.focusStrategy,
+    s.setOpen,
+    s.selectedKey,
+    s.selectedItem,
+    s.close,
+    d,
+    t.isDisabled,
+    t.validationState,
+    t.isRequired
+  ]), f = k(null), [b, p] = T(), { labelProps: v, triggerProps: S, valueProps: E, menuProps: R, descriptionProps: D, errorMessageProps: C } = Ct({
+    ...t,
+    label: p
+  }, s, f), [w, _] = I(null), G = K(() => {
+    f.current && _(f.current.offsetWidth + "px");
+  }, [
+    f
+  ]);
+  Ae({
+    ref: f,
+    onResize: G
+  });
+  let U = h({
+    ...t,
+    values: u,
+    defaultClassName: "react-aria-Select"
+  }), W = g(t);
+  return delete W.id, /* @__PURE__ */ o.createElement(N, {
+    values: [
+      [
+        Be,
+        {
+          state: s,
+          valueProps: E,
+          placeholder: t.placeholder
+        }
+      ],
+      [
+        F,
+        {
+          ...v,
+          ref: b,
+          elementType: "span"
+        }
+      ],
+      [
+        z,
+        {
+          ...S,
+          ref: f,
+          isPressed: s.isOpen
+        }
+      ],
+      [
+        oe,
+        {
+          state: s,
+          triggerRef: f,
+          preserveChildren: !0,
+          placement: "bottom start",
+          style: {
+            "--trigger-width": w
+          }
+        }
+      ],
+      [
+        Te,
+        {
+          state: s,
+          [Ce]: i,
+          ...R
+        }
+      ],
+      [
+        L,
+        {
+          slots: {
+            description: D,
+            errorMessage: C
+          }
+        }
+      ]
+    ]
+  }, /* @__PURE__ */ o.createElement("div", {
+    ...W,
+    ...U,
+    ...c,
+    ref: e,
+    slot: t.slot,
+    "data-focused": s.isFocused || void 0,
+    "data-focus-visible": d || void 0,
+    "data-open": s.isOpen || void 0,
+    "data-disabled": t.isDisabled || void 0,
+    "data-validation-state": t.validationState || void 0,
+    "data-required": t.isRequired || void 0
+  }), r, /* @__PURE__ */ o.createElement(Et, {
+    state: s,
+    triggerRef: f,
+    label: p,
+    name: t.name
+  }));
+}
+const Ai = /* @__PURE__ */ m(Na);
+function Ta(t, e) {
+  var a, i, l;
+  let { state: r, valueProps: n, placeholder: s } = y(Be), d = (a = r.selectedItem) === null || a === void 0 ? void 0 : a.rendered;
+  typeof d == "function" && (d = d({
+    isHovered: !1,
+    isPressed: !1,
+    isSelected: !1,
+    isFocused: !1,
+    isFocusVisible: !1,
+    isDisabled: !1,
+    selectionMode: "single",
+    selectionBehavior: "toggle"
+  }));
+  var c, u;
+  let f = h({
+    ...t,
+    // TODO: localize this.
+    defaultChildren: d || s || "Select an item",
+    defaultClassName: "react-aria-SelectValue",
+    values: {
+      selectedItem: (c = (i = r.selectedItem) === null || i === void 0 ? void 0 : i.value) !== null && c !== void 0 ? c : null,
+      selectedText: (u = (l = r.selectedItem) === null || l === void 0 ? void 0 : l.textValue) !== null && u !== void 0 ? u : null,
+      isPlaceholder: !r.selectedItem
+    }
+  }), b = g(t);
+  return delete b.id, /* @__PURE__ */ o.createElement("span", {
+    ref: e,
+    ...b,
+    ...n,
+    ...f,
+    "data-placeholder": !r.selectedItem || void 0
+  }, /* @__PURE__ */ o.createElement(L.Provider, {
+    value: void 0
+  }, f.children));
+}
+const qi = /* @__PURE__ */ m(Ta), Fa = /* @__PURE__ */ $(null), Y = /* @__PURE__ */ $(null);
+function Ma(t, e) {
+  [t, e] = P(t, e, Fa);
+  let a = k(null), i = Ft(t.formatOptions), l = kt({
+    ...t,
+    numberFormatter: i
+  }), [r, n] = T(), { groupProps: s, trackProps: d, labelProps: c, outputProps: u } = Rt({
+    ...t,
+    label: n
+  }, l, a), f = h({
+    ...t,
+    values: {
+      orientation: l.orientation,
+      isDisabled: l.isDisabled,
+      state: l
+    },
+    defaultClassName: "react-aria-Slider"
+  }), b = g(t);
+  return delete b.id, /* @__PURE__ */ o.createElement(N, {
+    values: [
+      [
+        Y,
+        {
+          state: l,
+          trackProps: d,
+          trackRef: a,
+          outputProps: u
+        }
+      ],
+      [
+        F,
+        {
+          ...c,
+          ref: r
+        }
+      ]
+    ]
+  }, /* @__PURE__ */ o.createElement("div", {
+    ...b,
+    ...s,
+    ...f,
+    ref: e,
+    slot: t.slot,
+    "data-orientation": l.orientation,
+    "data-disabled": l.isDisabled || void 0
+  }));
+}
+const zi = /* @__PURE__ */ m(Ma);
+function Oa({ children: t, style: e, className: a, ...i }, l) {
+  let { state: r, outputProps: n } = y(Y), s = h({
+    className: a,
+    style: e,
+    children: t,
+    defaultChildren: r.getThumbValueLabel(0),
+    defaultClassName: "react-aria-SliderOutput",
+    values: {
+      orientation: r.orientation,
+      isDisabled: r.isDisabled,
+      state: r
+    }
+  });
+  return /* @__PURE__ */ o.createElement("output", {
+    ...x(g(i), n),
+    ...s,
+    ref: l,
+    "data-orientation": r.orientation || void 0,
+    "data-disabled": r.isDisabled || void 0
+  });
+}
+const Gi = /* @__PURE__ */ m(Oa);
+function Ia(t, e) {
+  let { state: a, trackProps: i, trackRef: l } = y(Y), { hoverProps: r, isHovered: n } = H({}), s = q(e, l), d = h({
+    ...t,
+    defaultClassName: "react-aria-SliderTrack",
+    values: {
+      orientation: a.orientation,
+      isDisabled: a.isDisabled,
+      isHovered: n,
+      state: a
+    }
+  });
+  return /* @__PURE__ */ o.createElement("div", {
+    ...x(g(t), r, i),
+    ...d,
+    ref: s,
+    "data-hovered": n || void 0,
+    "data-orientation": a.orientation || void 0,
+    "data-disabled": a.isDisabled || void 0
+  });
+}
+const Ui = /* @__PURE__ */ m(Ia);
+function Ka(t, e) {
+  let { state: a, trackRef: i } = y(Y), { index: l = 0 } = t, r = k(null), [n, s] = T(), { thumbProps: d, inputProps: c, labelProps: u, isDragging: f, isFocused: b, isDisabled: p } = wt({
+    ...t,
+    index: l,
+    trackRef: i,
+    inputRef: r,
+    label: s
+  }, a), { focusProps: v, isFocusVisible: S } = B(), { hoverProps: E, isHovered: R } = H({}), D = h({
+    ...t,
+    defaultClassName: "react-aria-SliderThumb",
+    values: {
+      state: a,
+      isHovered: R,
+      isDragging: f,
+      isFocused: b,
+      isFocusVisible: S,
+      isDisabled: p
+    }
+  }), C = g(t);
+  return delete C.id, /* @__PURE__ */ o.createElement("div", {
+    ...x(C, d, E),
+    ...D,
+    ref: e,
+    style: {
+      ...d.style,
+      ...D.style
+    },
+    "data-hovered": R || void 0,
+    "data-dragging": f || void 0,
+    "data-focused": b || void 0,
+    "data-focus-visible": S || void 0,
+    "data-disabled": p || void 0
+  }, /* @__PURE__ */ o.createElement(te, null, /* @__PURE__ */ o.createElement("input", {
+    ref: r,
+    ...x(c, v)
+  })), /* @__PURE__ */ o.createElement(N, {
+    values: [
+      [
+        F,
+        {
+          ...u,
+          ref: n
+        }
+      ]
+    ]
+  }, D.children));
+}
+const Wi = /* @__PURE__ */ m(Ka), Va = /* @__PURE__ */ $({}), Ha = /* @__PURE__ */ $(null);
+function Ba(t, e) {
+  [t, e] = P(t, e, Ha);
+  let a = k(null), [i, l] = T(), [r, n] = I("input"), { labelProps: s, inputProps: d, descriptionProps: c, errorMessageProps: u } = ot({
+    ...t,
+    inputElementType: r,
+    label: l
+  }, a), f = K((p) => {
+    a.current = p, p && n(p instanceof HTMLTextAreaElement ? "textarea" : "input");
+  }, []), b = h({
+    ...t,
+    values: {
+      isDisabled: t.isDisabled || !1,
+      validationState: t.validationState
+    },
+    defaultClassName: "react-aria-TextField"
+  });
+  return /* @__PURE__ */ o.createElement("div", {
+    ...g(t),
+    ...b,
+    ref: e,
+    slot: t.slot,
+    "data-disabled": t.isDisabled || void 0,
+    "data-validation-state": t.validationState || void 0
+  }, /* @__PURE__ */ o.createElement(N, {
+    values: [
+      [
+        F,
+        {
+          ...s,
+          ref: i
+        }
+      ],
+      [
+        se,
+        {
+          ...d,
+          ref: f
+        }
+      ],
+      [
+        Va,
+        {
+          ...d,
+          ref: f
+        }
+      ],
+      [
+        L,
+        {
+          slots: {
+            description: c,
+            errorMessage: u
+          }
+        }
+      ]
+    ]
+  }, b.children));
+}
+const ji = m(Ba), ce = /* @__PURE__ */ $(null);
+function Qi(t) {
+  let e = dt(t), a = k(null), { triggerProps: i, tooltipProps: l } = ct(t, e, a);
+  return /* @__PURE__ */ o.createElement(ce.Provider, {
+    value: {
+      state: e,
+      triggerRef: a,
+      tooltipProps: l
+    }
+  }, /* @__PURE__ */ o.createElement(Ue, {
+    ...i,
+    ref: a
+  }, t.children));
+}
+function La(t, e) {
+  let { state: a } = y(ce), i = V(e), l = j(i, a.isOpen);
+  return !a.isOpen && !l ? null : /* @__PURE__ */ o.createElement(Ye, null, /* @__PURE__ */ o.createElement(_a, {
+    ...t,
+    tooltipRef: i,
+    isExiting: l
+  }));
+}
+const Xi = /* @__PURE__ */ m(La);
+function _a(t) {
+  let { state: e, triggerRef: a, tooltipProps: i } = y(ce), l = k(null), { overlayProps: r, arrowProps: n, placement: s } = Je({
+    placement: t.placement || "top",
+    targetRef: a,
+    overlayRef: l,
+    offset: t.offset,
+    crossOffset: t.crossOffset,
+    isOpen: e.isOpen
+  }), d = Q(l, !!s), c = h({
+    ...t,
+    defaultClassName: "react-aria-Tooltip",
+    values: {
+      placement: s,
+      isEntering: d,
+      isExiting: t.isExiting,
+      state: e
+    }
+  });
+  t = x(t, r);
+  let { tooltipProps: u } = ut(t, e);
+  return /* @__PURE__ */ o.createElement("div", {
+    ...x(i, u),
+    ref: q(l, t.tooltipRef),
+    ...c,
+    style: {
+      ...c.style,
+      ...r.style
+    },
+    "data-placement": s,
+    "data-entering": d || void 0,
+    "data-exiting": t.isExiting || void 0
+  }, /* @__PURE__ */ o.createElement(ne.Provider, {
+    value: {
+      arrowProps: n,
+      placement: s
+    }
+  }, c.children));
+}
 export {
-  w as default
+  Di as Button,
+  z as ButtonContext,
+  Ei as Checkbox,
+  Ut as CheckboxContext,
+  ki as CheckboxGroup,
+  zt as CheckboxGroupContext,
+  Mi as DateInput,
+  Oi as DateSegment,
+  Vi as Dialog,
+  Ve as DialogContext,
+  Ki as DialogTrigger,
+  Xt as DropIndicator,
+  we as DropIndicatorContext,
+  xa as GroupContext,
+  Zt as Header,
+  Lt as HeadingContext,
+  Ri as Input,
+  se as InputContext,
+  Pi as Item,
+  Ci as Label,
+  F as LabelContext,
+  wi as ListBox,
+  Te as ListBoxContext,
+  Ii as Modal,
+  Ke as ModalContext,
+  va as ModalOverlay,
+  Hi as NumberField,
+  ya as NumberFieldContext,
+  Ni as OverlayArrow,
+  Ti as Popover,
+  oe as PopoverContext,
+  Bi as ProgressBar,
+  Sa as ProgressBarContext,
+  N as Provider,
+  _i as Radio,
+  Ea as RadioContext,
+  Li as RadioGroup,
+  Ca as RadioGroupContext,
+  Zi as SSRProvider,
+  Si as Section,
+  Ai as Select,
+  wa as SelectContext,
+  qi as SelectValue,
+  ta as Separator,
+  Ne as SeparatorContext,
+  zi as Slider,
+  Fa as SliderContext,
+  Gi as SliderOutput,
+  Wi as SliderThumb,
+  Ui as SliderTrack,
+  Va as TextAreaContext,
+  L as TextContext,
+  ji as TextField,
+  Ha as TextFieldContext,
+  Fi as TimeField,
+  ua as TimeFieldContext,
+  Xi as Tooltip,
+  Qi as TooltipTrigger,
+  P as useContextProps
 };