@new-black/lyra 0.0.13 → 0.0.15

package/dist/lyra53.js

@@ -1,4 +1,1396 @@
-const r = "";
+import { useObjectRef as L, mergeRefs as U, mergeProps as D, filterDOMProps as S, useLayoutEffect as ae, useResizeObserver as ke } from "./lyra39.js";
+import s, { forwardRef as h, useContext as x, useMemo as k, useEffect as q, useRef as y, useState as I, useCallback as N, createContext as p, cloneElement as Ne } from "react";
+import Te, { createPortal as Me } from "react-dom";
+import { s as Ke } from "./lyra100.js";
+import { useHover as W } from "./lyra42.js";
+import { useFocusRing as j, FocusableProvider as Ie, FocusScope as Fe } from "./lyra45.js";
+import { useButton as Be } from "./lyra67.js";
+import { useOverlayTriggerState as se } from "./lyra101.js";
+import { useOverlayTrigger as Oe, usePopover as Re, Overlay as Ve, DismissButton as ie, OverlayContainer as _e, useOverlayPosition as He } from "./lyra72.js";
+import { useNumberFieldState as Le } from "./lyra102.js";
+import { useNumberField as Ae } from "./lyra73.js";
+import { useTextField as ze } from "./lyra74.js";
+import { useTooltipTriggerState as Ue } from "./lyra103.js";
+import { useTooltipTrigger as qe, useTooltip as We } from "./lyra81.js";
+import { useListState as je } from "./lyra104.js";
+import { ListKeyboardDelegate as Ge } from "./lyra70.js";
+import { useListBox as Qe, useListBoxSection as Xe, useOption as Ye } from "./lyra69.js";
+import { useProgressBar as Je } from "./lyra78.js";
+import { useSelectState as Ze } from "./lyra105.js";
+import { useSelect as et, HiddenSelect as tt } from "./lyra79.js";
+import { useIsSSR as rt } from "./lyra37.js";
+import { SSRProvider as Kr } from "./lyra37.js";
+import { useSeparator as lt } from "./lyra80.js";
+import { useLocale as de } from "./lyra38.js";
+class G {
+  get childNodes() {
+    throw new Error("childNodes is not supported");
+  }
+  clone() {
+    let e = new G(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, t) {
+    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 = t;
+  }
+}
+class ce {
+  *[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, t) {
+    if (t == null)
+      return this.appendChild(e);
+    this.ownerDocument.startTransaction(), e.parentNode && e.parentNode.removeChild(e), e.nextSibling = t, e.previousSibling = t.previousSibling, e.index = t.index, this.firstChild === t ? this.firstChild = e : t.previousSibling && (t.previousSibling.nextSibling = e), t.previousSibling = e, e.parentNode = t.parentNode;
+    let l = t;
+    for (; l; )
+      l.index++, l = l.nextSibling;
+    e.hasSetProps && this.ownerDocument.addNode(e), this.ownerDocument.endTransaction(), this.ownerDocument.queueUpdate();
+  }
+  removeChild(e) {
+    if (e.parentNode !== this)
+      return;
+    this.ownerDocument.startTransaction();
+    let t = e.nextSibling;
+    for (; t; )
+      t.index--, t = t.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 ot = 0;
+class R extends ce {
+  get index() {
+    return this._index;
+  }
+  set index(e) {
+    this._index = e, this.ownerDocument.markDirty(this);
+  }
+  get level() {
+    return this.parentNode instanceof R ? this.parentNode.level + (this.node.type === "item" ? 1 : 0) : 0;
+  }
+  updateNode() {
+    var e, t, l, o;
+    let i = this.ownerDocument.getMutableNode(this);
+    i.index = this.index, i.level = this.level, i.parentKey = this.parentNode instanceof R ? this.parentNode.node.key : null;
+    var a;
+    i.prevKey = (a = (e = this.previousSibling) === null || e === void 0 ? void 0 : e.node.key) !== null && a !== void 0 ? a : null;
+    var n;
+    i.nextKey = (n = (t = this.nextSibling) === null || t === void 0 ? void 0 : t.node.key) !== null && n !== void 0 ? n : null, i.hasChildNodes = !!this.firstChild;
+    var c;
+    i.firstChildKey = (c = (l = this.firstChild) === null || l === void 0 ? void 0 : l.node.key) !== null && c !== void 0 ? c : null;
+    var d;
+    i.lastChildKey = (d = (o = this.lastChild) === null || o === void 0 ? void 0 : o.node.key) !== null && d !== void 0 ? d : null;
+  }
+  setProps(e, t, l) {
+    let o = this.ownerDocument.getMutableNode(this), { value: i, textValue: a, id: n, ...c } = e;
+    if (c.ref = t, o.props = c, o.rendered = l, o.value = i, o.textValue = a || (typeof l == "string" ? l : "") || e["aria-label"] || "", n != null && n !== o.key) {
+      if (this.hasSetProps)
+        throw new Error("Cannot change the id of an item");
+      o.key = n;
+    }
+    this.hasSetProps || (this.ownerDocument.addNode(this), this.ownerDocument.endTransaction(), this.hasSetProps = !0), this.ownerDocument.queueUpdate();
+  }
+  get style() {
+    return {};
+  }
+  hasAttribute() {
+  }
+  setAttribute() {
+  }
+  setAttributeNS() {
+  }
+  removeAttribute() {
+  }
+  constructor(e, t) {
+    super(t), this.nodeType = 8, this._index = 0, this.hasSetProps = !1, this.node = new G(e, `react-aria-${++ot}`), this.ownerDocument.startTransaction();
+  }
+}
+class it {
+  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 t = this.keyMap;
+    return {
+      *[Symbol.iterator]() {
+        let l = t.get(e), o = (l == null ? void 0 : l.firstChildKey) != null ? t.get(l.firstChildKey) : null;
+        for (; o; )
+          yield o, o = o.nextKey != null ? t.get(o.nextKey) : void 0;
+      }
+    };
+  }
+  getKeyBefore(e) {
+    let t = this.keyMap.get(e);
+    if (!t)
+      return null;
+    if (t.prevKey != null) {
+      for (t = this.keyMap.get(t.prevKey); t && t.type !== "item" && t.lastChildKey != null; )
+        t = this.keyMap.get(t.lastChildKey);
+      var l;
+      return (l = t == null ? void 0 : t.key) !== null && l !== void 0 ? l : null;
+    }
+    return t.parentKey;
+  }
+  getKeyAfter(e) {
+    let t = this.keyMap.get(e);
+    if (!t)
+      return null;
+    if (t.type !== "item" && t.firstChildKey != null)
+      return t.firstChildKey;
+    for (; t; ) {
+      if (t.nextKey != null)
+        return t.nextKey;
+      if (t.parentKey != null)
+        t = this.keyMap.get(t.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 t;
+    return (t = e == null ? void 0 : e.key) !== null && t !== void 0 ? t : null;
+  }
+  getItem(e) {
+    var t;
+    return (t = this.keyMap.get(e)) !== null && t !== void 0 ? t : null;
+  }
+  at() {
+    throw new Error("Not implemented");
+  }
+  clone() {
+    let e = this.constructor, t = new e();
+    return t.keyMap = new Map(this.keyMap), t.firstKey = this.firstKey, t.lastKey = this.lastKey, t;
+  }
+  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, t) {
+    if (this.frozen)
+      throw new Error("Cannot commit a frozen collection");
+    this.firstKey = e, this.lastKey = t, this.frozen = !0;
+  }
+  constructor() {
+    this.keyMap = /* @__PURE__ */ new Map(), this.firstKey = null, this.lastKey = null, this.frozen = !1;
+  }
+}
+class nt extends ce {
+  createElement(e) {
+    return new R(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 t = e.node;
+    return this.mutatedNodes.has(e) || (t = e.node.clone(), this.mutatedNodes.add(e), e.node = t), this.markDirty(e), t;
+  }
+  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 t = this.getMutableCollection();
+    if (!t.getItem(e.node.key)) {
+      t.addNode(e.node);
+      for (let l of e)
+        this.addNode(l);
+    }
+    this.markDirty(e);
+  }
+  removeNode(e) {
+    for (let l of e)
+      l.parentNode = null, this.removeNode(l);
+    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 i of this.dirtyNodes)
+      i instanceof R && i.parentNode && i.updateNode();
+    if (this.dirtyNodes.clear(), this.mutatedNodes.size) {
+      var e, t;
+      let i = this.getMutableCollection();
+      for (let a of this.mutatedNodes)
+        a.parentNode && i.addNode(a.node);
+      var l, o;
+      i.commit((l = (e = this.firstChild) === null || e === void 0 ? void 0 : e.node.key) !== null && l !== void 0 ? l : null, (o = (t = this.lastChild) === null || t === void 0 ? void 0 : t.node.key) !== null && o !== void 0 ? o : 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 Q(r) {
+  let { children: e, items: t, idScope: l, addIdAndValue: o } = r, i = k(() => /* @__PURE__ */ new WeakMap(), []);
+  return k(() => {
+    if (t && typeof e == "function") {
+      let c = [];
+      for (let d of t) {
+        let u = i.get(d);
+        if (!u) {
+          if (u = e(d), u.key == null) {
+            var a, n;
+            let f = (n = (a = u.props.id) !== null && a !== void 0 ? a : d.key) !== null && n !== void 0 ? n : d.id;
+            if (f == null)
+              throw new Error("Could not determine key for item");
+            l && (f = l + ":" + f), u = /* @__PURE__ */ Ne(u, o ? {
+              key: f,
+              id: f,
+              value: d
+            } : {
+              key: f
+            });
+          }
+          i.set(d, u);
+        }
+        c.push(u);
+      }
+      return c;
+    } else if (typeof e != "function")
+      return e;
+  }, [
+    e,
+    t,
+    i,
+    l,
+    o
+  ]);
+}
+function ue(r) {
+  return Q({
+    ...r,
+    addIdAndValue: !0
+  });
+}
+const fe = /* @__PURE__ */ p(!1);
+function pe(r, e) {
+  let { collection: t, document: l } = at(e);
+  return {
+    portal: st(r, l),
+    collection: t
+  };
+}
+function at(r) {
+  let e = k(() => new nt(r || new it()), [
+    r
+  ]), t = N((i) => e.subscribe(i), [
+    e
+  ]), l = N(() => e.getCollection(), [
+    e
+  ]);
+  return {
+    collection: Ke.useSyncExternalStore(t, l, l),
+    document: e
+  };
+}
+function st(r, e) {
+  let t = ue(r), l = k(() => /* @__PURE__ */ s.createElement(fe.Provider, {
+    value: !0
+  }, t), [
+    t
+  ]);
+  return rt() ? null : /* @__PURE__ */ Me(l, e);
+}
+function $e(r, e, t) {
+  let l = x(fe);
+  return t = X(e, t, e.children), l ? /* @__PURE__ */ s.createElement(r, {
+    ref: t
+  }) : null;
+}
+function X(r, e, t) {
+  return N((l) => {
+    l == null || l.setProps(r, e, t);
+  }, [
+    r,
+    e,
+    t
+  ]);
+}
+function dt(r, e) {
+  return /* @__PURE__ */ s.createElement("item", {
+    ref: X(r, e, r.children)
+  });
+}
+const $r = /* @__PURE__ */ h(dt);
+function ct(r, e) {
+  let t = ue(r);
+  return /* @__PURE__ */ s.createElement("section", {
+    ref: X(r, e)
+  }, t);
+}
+const br = /* @__PURE__ */ h(ct), be = Symbol("callback"), ne = Symbol("default");
+function F({ values: r, children: e }) {
+  for (let [t, l] of r)
+    e = /* @__PURE__ */ s.createElement(t.Provider, {
+      value: l
+    }, e);
+  return e;
+}
+function v(r) {
+  let { className: e, style: t, children: l, defaultClassName: o, defaultChildren: i, values: a } = r;
+  return k(() => {
+    let n, c, d;
+    return typeof e == "function" ? n = e(a) : n = e, typeof t == "function" ? c = t(a) : c = t, typeof l == "function" ? d = l(a) : l == null ? d = i : d = l, {
+      className: n ?? o,
+      style: c,
+      children: d
+    };
+  }, [
+    e,
+    t,
+    l,
+    o,
+    i,
+    a
+  ]);
+}
+function P(r, e, t) {
+  let l = x(t) || {};
+  if ("slots" in l && l.slots) {
+    if (!r.slot && !l.slots[ne])
+      throw new Error("A slot prop is required");
+    let d = r.slot || ne;
+    if (!l.slots[d])
+      throw new Error(`Invalid slot "${r.slot}". Valid slot names are ` + new Intl.ListFormat().format(Object.keys(l.slots).map((u) => `"${u}"`)) + ".");
+    l = l.slots[d];
+  }
+  let { ref: o, [be]: i, ...a } = l, n = L(k(() => U(e, o), [
+    e,
+    o
+  ])), c = D(a, r);
+  return q(() => {
+    i && i(r);
+  }, [
+    i,
+    r
+  ]), [
+    c,
+    n
+  ];
+}
+function V() {
+  let [r, e] = I(!0), t = y(!1), l = N((o) => {
+    t.current = !0, e(!!o);
+  }, []);
+  return ae(() => {
+    t.current || e(!1);
+  }, []), [
+    l,
+    r
+  ];
+}
+function he(r, e = !0) {
+  let [t, l] = I(!0);
+  return ve(r, t && e, N(() => l(!1), [])), t && e;
+}
+function me(r, e) {
+  let [t, l] = I(!1), [o, i] = I("idle");
+  return !e && r.current && o === "idle" && (t = !0, l(!0), i("exiting")), !r.current && o === "exited" && i("idle"), ve(r, t, N(() => {
+    i("exited"), l(!1);
+  }, [])), t;
+}
+function ve(r, e, t) {
+  let l = y(null);
+  e && r.current && (l.current = window.getComputedStyle(r.current).animation), ae(() => {
+    if (e && r.current) {
+      let o = window.getComputedStyle(r.current);
+      if (o.animationName !== "none" && o.animation !== l.current) {
+        let i = (n) => {
+          n.target === r.current && (a.removeEventListener("animationend", i), Te.flushSync(() => {
+            t();
+          }));
+        }, a = r.current;
+        return a.addEventListener("animationend", i), () => {
+          a.removeEventListener("animationend", i);
+        };
+      } else
+        t();
+    }
+  }, [
+    r,
+    e,
+    t
+  ]);
+}
+const ge = /* @__PURE__ */ p(!1), ut = /* @__PURE__ */ new Set([
+  "form",
+  "formAction",
+  "formEncType",
+  "formMethod",
+  "formNoValidate",
+  "formTarget",
+  "name",
+  "value"
+]), A = /* @__PURE__ */ p({});
+function ft(r, e) {
+  [r, e] = P(r, e, A);
+  let t = r, { buttonProps: l, isPressed: o } = Be(r, e), { focusProps: i, isFocused: a, isFocusVisible: n } = j(r), { hoverProps: c, isHovered: d } = W(r), u = v({
+    ...r,
+    values: {
+      isHovered: d,
+      isPressed: o,
+      isFocused: a,
+      isFocusVisible: n,
+      isDisabled: r.isDisabled || !1
+    },
+    defaultClassName: "react-aria-Button"
+  });
+  return /* @__PURE__ */ s.createElement("button", {
+    ...S(r, {
+      propNames: ut
+    }),
+    ...D(l, i, c),
+    ...u,
+    ref: e,
+    slot: r.slot,
+    "data-pressed": t.isPressed || o || void 0,
+    "data-hovered": d || void 0,
+    "data-focus-visible": n || void 0
+  });
+}
+const hr = /* @__PURE__ */ h(ft), _ = /* @__PURE__ */ p({}), H = /* @__PURE__ */ p({});
+function pt(r, e) {
+  [r, e] = P(r, e, H);
+  let { elementType: t = "label", ...l } = r;
+  return /* @__PURE__ */ s.createElement(t, {
+    className: "react-aria-Label",
+    ...l,
+    ref: e
+  });
+}
+const mr = /* @__PURE__ */ h(pt), Y = /* @__PURE__ */ p({});
+function $t(r, e) {
+  [r, e] = P(r, e, Y);
+  let { hoverProps: t, isHovered: l } = W({}), { isFocused: o, isFocusVisible: i, focusProps: a } = j({
+    isTextInput: !0,
+    autoFocus: r.autoFocus
+  }), n = v({
+    ...r,
+    values: {
+      isHovered: l,
+      isFocused: o,
+      isFocusVisible: i,
+      isDisabled: r.disabled || !1
+    },
+    defaultClassName: "react-aria-Input"
+  });
+  return /* @__PURE__ */ s.createElement("input", {
+    ...D(r, a, t),
+    ...n,
+    ref: e,
+    "data-hovered": l || void 0,
+    "data-focus-visible": i || void 0
+  });
+}
+const vr = /* @__PURE__ */ h($t), ye = /* @__PURE__ */ p(null);
+function bt(r, e) {
+  let { render: t } = x(ye);
+  return /* @__PURE__ */ s.createElement(s.Fragment, null, t(r, e));
+}
+const ht = /* @__PURE__ */ h(bt), mt = /* @__PURE__ */ p({});
+function vt(r, e) {
+  [r, e] = P(r, e, mt);
+  let t = $e("header", r, e);
+  return t || /* @__PURE__ */ s.createElement("header", {
+    className: "react-aria-Header",
+    ...r,
+    ref: e
+  }, r.children);
+}
+const gt = /* @__PURE__ */ h(vt), xe = /* @__PURE__ */ p({});
+function yt(r, e) {
+  [r, e] = P(r, e, xe);
+  let { elementType: t, orientation: l, style: o, className: i } = r, a = t || "hr";
+  a === "hr" && l === "vertical" && (a = "div");
+  let { separatorProps: n } = lt({
+    elementType: t,
+    orientation: l
+  }), c = $e("separator", r, e);
+  return c || /* @__PURE__ */ s.createElement(a, {
+    ...S(r),
+    ...n,
+    style: o,
+    className: i ?? "react-aria-Separator",
+    ref: e,
+    slot: r.slot
+  });
+}
+const xt = /* @__PURE__ */ h(yt), Pe = /* @__PURE__ */ p(null), z = /* @__PURE__ */ p(null);
+function Pt(r, e) {
+  [r, e] = P(r, e, Pe);
+  let t = r.state, l = x(ge);
+  return t ? l ? null : /* @__PURE__ */ s.createElement(Se, {
+    state: t,
+    props: r,
+    listBoxRef: e
+  }) : /* @__PURE__ */ s.createElement(St, {
+    props: r,
+    listBoxRef: e
+  });
+}
+function St({ props: r, listBoxRef: e }) {
+  let { portal: t, collection: l } = pe(r);
+  r = {
+    ...r,
+    collection: l,
+    children: null,
+    items: null
+  };
+  let o = je(r);
+  return /* @__PURE__ */ s.createElement(s.Fragment, null, t, /* @__PURE__ */ s.createElement(Se, {
+    state: o,
+    props: r,
+    listBoxRef: e
+  }));
+}
+const gr = /* @__PURE__ */ h(Pt);
+function Se({ state: r, props: e, listBoxRef: t }) {
+  let { dragAndDropHooks: l, layout: o = "stack", orientation: i = "vertical" } = e, { collection: a, selectionManager: n } = r, c = !!(l != null && l.useDraggableCollectionState), d = !!(l != null && l.useDroppableCollectionState), { direction: u } = de(), { disabledBehavior: f, disabledKeys: m } = n, $ = k(() => e.keyboardDelegate || new Ge({
+    collection: a,
+    ref: t,
+    disabledKeys: f === "selection" ? /* @__PURE__ */ new Set() : m,
+    layout: o,
+    orientation: i,
+    direction: u
+  }), [
+    a,
+    t,
+    f,
+    m,
+    i,
+    u,
+    e.keyboardDelegate,
+    o
+  ]), { listBoxProps: b } = Qe({
+    ...e,
+    shouldSelectOnPressUp: c || e.shouldSelectOnPressUp,
+    keyboardDelegate: $
+  }, r, t), g = Q({
+    items: a,
+    children: (C) => {
+      switch (C.type) {
+        case "section":
+          return /* @__PURE__ */ s.createElement(Ct, {
+            section: C
+          });
+        case "separator":
+          return /* @__PURE__ */ s.createElement(xt, C.props);
+        case "item":
+          return /* @__PURE__ */ s.createElement(Ce, {
+            item: C
+          });
+        default:
+          throw new Error("Unsupported node type in Menu: " + C.type);
+      }
+    }
+  }), T = y(c), M = y(d);
+  q(() => {
+    T.current !== c && console.warn("Drag hooks were provided during one render, but not another. This should be avoided as it may produce unexpected behavior."), M.current !== d && console.warn("Drop hooks were provided during one render, but not another. This should be avoided as it may produce unexpected behavior.");
+  }, [
+    c,
+    d
+  ]);
+  let E, w, K, B = !1, O = null, te = y(null);
+  if (c && l) {
+    E = l.useDraggableCollectionState({
+      collection: a,
+      selectionManager: n,
+      preview: l.renderDragPreview ? te : void 0
+    }), l.useDraggableCollection({}, E, t);
+    let C = l.DragPreview;
+    O = l.renderDragPreview ? /* @__PURE__ */ s.createElement(C, {
+      ref: te
+    }, l.renderDragPreview) : null;
+  }
+  if (d && l) {
+    w = l.useDroppableCollectionState({
+      collection: a,
+      selectionManager: n
+    });
+    let C = l.dropTargetDelegate || new l.ListDropTargetDelegate(a, t, {
+      orientation: i,
+      layout: o,
+      direction: u
+    });
+    K = l.useDroppableCollection({
+      keyboardDelegate: $,
+      dropTargetDelegate: C
+    }, w, t), B = w.isDropTarget({
+      type: "root"
+    });
+  }
+  let { focusProps: Ee, isFocused: re, isFocusVisible: le } = j(), we = v({
+    className: e.className,
+    style: e.style,
+    defaultClassName: "react-aria-ListBox",
+    values: {
+      isDropTarget: B,
+      isEmpty: r.collection.size === 0,
+      isFocused: re,
+      isFocusVisible: le
+    }
+  }), oe = null;
+  return r.collection.size === 0 && e.renderEmptyState && (oe = /* @__PURE__ */ s.createElement("div", {
+    // eslint-disable-next-line
+    role: "option",
+    style: {
+      display: "contents"
+    }
+  }, e.renderEmptyState())), /* @__PURE__ */ s.createElement(Fe, null, /* @__PURE__ */ s.createElement("div", {
+    ...S(e),
+    ...D(b, Ee, K == null ? void 0 : K.collectionProps),
+    ...we,
+    ref: t,
+    slot: e.slot,
+    "data-drop-target": B || void 0,
+    "data-empty": r.collection.size === 0 || void 0,
+    "data-focused": re || void 0,
+    "data-focus-visible": le || void 0,
+    "data-layout": e.layout || "stack",
+    "data-orientation": e.orientation || "vertical"
+  }, /* @__PURE__ */ s.createElement(F, {
+    values: [
+      [
+        z,
+        {
+          state: r,
+          shouldFocusOnHover: e.shouldFocusOnHover,
+          dragAndDropHooks: l,
+          dragState: E,
+          dropState: w
+        }
+      ],
+      [
+        xe,
+        {
+          elementType: "li"
+        }
+      ],
+      [
+        ye,
+        {
+          render: Dt
+        }
+      ]
+    ]
+  }, g), oe, O));
+}
+function Ct({ section: r, className: e, style: t, ...l }) {
+  var o, i;
+  let { state: a } = x(z), [n, c] = V();
+  var d;
+  let { headingProps: u, groupProps: f } = Xe({
+    heading: c,
+    "aria-label": (d = r["aria-label"]) !== null && d !== void 0 ? d : void 0
+  }), m = Q({
+    items: a.collection.getChildren(r.key),
+    children: ($) => {
+      switch ($.type) {
+        case "header": {
+          let { ref: b, ...g } = $.props;
+          return /* @__PURE__ */ s.createElement(gt, {
+            ...u,
+            ...g,
+            ref: U(n, b)
+          }, $.rendered);
+        }
+        case "item":
+          return /* @__PURE__ */ s.createElement(Ce, {
+            item: $
+          });
+        default:
+          throw new Error("Unsupported element type in Section: " + $.type);
+      }
+    }
+  });
+  return /* @__PURE__ */ s.createElement("section", {
+    ...S(l),
+    ...f,
+    className: e || ((o = r.props) === null || o === void 0 ? void 0 : o.className) || "react-aria-Section",
+    style: t || ((i = r.props) === null || i === void 0 ? void 0 : i.style),
+    ref: r.props.ref
+  }, m);
+}
+function Ce({ item: r }) {
+  let e = L(r.props.ref), { state: t, shouldFocusOnHover: l, dragAndDropHooks: o, dragState: i, dropState: a } = x(z), { optionProps: n, labelProps: c, descriptionProps: d, ...u } = Ye({
+    key: r.key
+  }, t, e), { hoverProps: f, isHovered: m } = W({
+    isDisabled: l || !u.allowsSelection && !u.hasAction
+  });
+  l && (f = {}, m = u.isFocused);
+  let $ = null;
+  i && o && ($ = o.useDraggableItem({
+    key: r.key
+  }, i));
+  let b = null;
+  a && o && (b = o.useDroppableItem({
+    target: {
+      type: "item",
+      key: r.key,
+      dropPosition: "on"
+    }
+  }, a, e));
+  let g = r.props, T = i && i.isDragging(r.key), M = v({
+    ...g,
+    id: void 0,
+    children: r.rendered,
+    defaultClassName: "react-aria-Item",
+    values: {
+      ...u,
+      isHovered: m,
+      selectionMode: t.selectionManager.selectionMode,
+      selectionBehavior: t.selectionManager.selectionBehavior,
+      allowsDragging: !!i,
+      isDragging: T,
+      isDropTarget: b == null ? void 0 : b.isDropTarget
+    }
+  }), E = (o == null ? void 0 : o.renderDropIndicator) || ((w) => /* @__PURE__ */ s.createElement(ht, {
+    target: w
+  }));
+  return q(() => {
+    r.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.");
+  }, [
+    r.textValue
+  ]), /* @__PURE__ */ s.createElement(s.Fragment, null, (o == null ? void 0 : o.useDropIndicator) && E({
+    type: "item",
+    key: r.key,
+    dropPosition: "before"
+  }), /* @__PURE__ */ s.createElement("div", {
+    ...D(S(g), n, f, $ == null ? void 0 : $.dragProps, b == null ? void 0 : b.dropProps),
+    ...M,
+    ref: e,
+    "data-hovered": m || void 0,
+    "data-focused": u.isFocused || void 0,
+    "data-focus-visible": u.isFocusVisible || void 0,
+    "data-pressed": u.isPressed || void 0,
+    "data-dragging": T || void 0,
+    "data-drop-target": (b == null ? void 0 : b.isDropTarget) || void 0
+  }, /* @__PURE__ */ s.createElement(F, {
+    values: [
+      [
+        _,
+        {
+          slots: {
+            label: c,
+            description: d
+          }
+        }
+      ]
+    ]
+  }, M.children)), (o == null ? void 0 : o.useDropIndicator) && t.collection.getKeyAfter(r.key) == null && E({
+    type: "item",
+    key: r.key,
+    dropPosition: "after"
+  }));
+}
+function Dt(r, e) {
+  e = L(e);
+  let { dragAndDropHooks: t, dropState: l } = x(z), { dropIndicatorProps: o, isHidden: i, isDropTarget: a } = t.useDropIndicator(r, l, e);
+  return i ? null : /* @__PURE__ */ s.createElement(wt, {
+    ...r,
+    dropIndicatorProps: o,
+    isDropTarget: a,
+    ref: e
+  });
+}
+function Et(r, e) {
+  let { dropIndicatorProps: t, isDropTarget: l, ...o } = r, i = v({
+    ...o,
+    defaultClassName: "react-aria-DropIndicator",
+    values: {
+      isDropTarget: l
+    }
+  });
+  return /* @__PURE__ */ s.createElement("div", {
+    ...t,
+    ...i,
+    // eslint-disable-next-line
+    role: "option",
+    ref: e,
+    "data-drop-target": l || void 0
+  });
+}
+const wt = /* @__PURE__ */ h(Et), J = /* @__PURE__ */ p(null);
+function kt(r, e) {
+  let { arrowProps: t, placement: l } = x(J), o = {
+    ...t.style,
+    position: "absolute",
+    [l]: "100%",
+    transform: l === "top" || l === "bottom" ? "translateX(-50%)" : "translateY(-50%)"
+  }, i = v({
+    ...r,
+    defaultClassName: "react-aria-OverlayArrow",
+    values: {
+      placement: l
+    }
+  });
+  return /* @__PURE__ */ s.createElement("div", {
+    ...D(t, r),
+    ...i,
+    style: {
+      ...i.style,
+      ...o
+    },
+    ref: e,
+    "data-placement": l
+  });
+}
+const yr = /* @__PURE__ */ h(kt), Z = /* @__PURE__ */ p(null);
+function Nt(r, e) {
+  [r, e] = P(r, e, Z);
+  let t = r, l = se(r), o = r.isOpen != null || r.defaultOpen != null || !(t != null && t.state) ? l : t.state, i = me(e, o.isOpen);
+  if (o && !o.isOpen && !i) {
+    let a = r.children;
+    return typeof a == "function" && (a = a({
+      placement: "bottom",
+      isEntering: !1,
+      isExiting: !1
+    })), t.preserveChildren ? /* @__PURE__ */ s.createElement(ge.Provider, {
+      value: !0
+    }, a) : null;
+  }
+  return /* @__PURE__ */ s.createElement(Tt, {
+    ...r,
+    triggerRef: t.triggerRef,
+    state: o,
+    popoverRef: e,
+    isExiting: i
+  });
+}
+const xr = /* @__PURE__ */ h(Nt);
+function Tt({ state: r, isExiting: e, ...t }) {
+  var l;
+  let { popoverProps: o, underlayProps: i, arrowProps: a, placement: n } = Re({
+    ...t,
+    offset: (l = t.offset) !== null && l !== void 0 ? l : 8
+  }, r), c = t.popoverRef, d = he(c, !!n), u = v({
+    ...t,
+    defaultClassName: "react-aria-Popover",
+    values: {
+      placement: n,
+      isEntering: d,
+      isExiting: e
+    }
+  }), f = {
+    ...u.style,
+    ...o.style
+  };
+  return /* @__PURE__ */ s.createElement(Ve, null, !t.isNonModal && /* @__PURE__ */ s.createElement("div", {
+    ...i,
+    style: {
+      position: "fixed",
+      inset: 0
+    }
+  }), /* @__PURE__ */ s.createElement("div", {
+    ...D(S(t), o),
+    ...u,
+    ref: c,
+    slot: t.slot,
+    style: f,
+    "data-placement": n,
+    "data-entering": d || void 0,
+    "data-exiting": e || void 0
+  }, !t.isNonModal && /* @__PURE__ */ s.createElement(ie, {
+    onDismiss: r.close
+  }), /* @__PURE__ */ s.createElement(J.Provider, {
+    value: {
+      arrowProps: a,
+      placement: n
+    }
+  }, u.children), /* @__PURE__ */ s.createElement(ie, {
+    onDismiss: r.close
+  })));
+}
+const Mt = /* @__PURE__ */ p(null), Kt = /* @__PURE__ */ p(null);
+function Pr(r) {
+  let e = se(r), t = y(null), { triggerProps: l, overlayProps: o } = Oe({
+    type: "dialog"
+  }, e, t);
+  return /* @__PURE__ */ s.createElement(F, {
+    values: [
+      [
+        Mt,
+        {
+          state: e
+        }
+      ],
+      [
+        Kt,
+        {
+          ...o,
+          onClose: e.close
+        }
+      ],
+      [
+        A,
+        {
+          ...l,
+          isPressed: e.isOpen,
+          ref: t
+        }
+      ],
+      [
+        Z,
+        {
+          state: e,
+          triggerRef: t
+        }
+      ]
+    ]
+  }, r.children);
+}
+const It = /* @__PURE__ */ p({}), Ft = /* @__PURE__ */ p(null);
+function Bt(r, e) {
+  [r, e] = P(r, e, Ft);
+  let { locale: t } = de(), l = Le({
+    ...r,
+    locale: t
+  }), o = y(null), [i, a] = V(), { labelProps: n, groupProps: c, inputProps: d, incrementButtonProps: u, decrementButtonProps: f, descriptionProps: m, errorMessageProps: $ } = Ae({
+    ...r,
+    label: a
+  }, l, o), b = v({
+    ...r,
+    values: l,
+    defaultClassName: "react-aria-NumberField"
+  }), g = S(r);
+  return delete g.id, /* @__PURE__ */ s.createElement(F, {
+    values: [
+      [
+        It,
+        c
+      ],
+      [
+        Y,
+        {
+          ...d,
+          ref: o
+        }
+      ],
+      [
+        H,
+        {
+          ...n,
+          ref: i
+        }
+      ],
+      [
+        A,
+        {
+          slots: {
+            increment: u,
+            decrement: f
+          }
+        }
+      ],
+      [
+        _,
+        {
+          slots: {
+            description: m,
+            errorMessage: $
+          }
+        }
+      ]
+    ]
+  }, /* @__PURE__ */ s.createElement("div", {
+    ...g,
+    ...b,
+    ref: e,
+    slot: r.slot
+  }));
+}
+const Sr = /* @__PURE__ */ h(Bt), Ot = /* @__PURE__ */ p(null);
+function Rt(r, e) {
+  [r, e] = P(r, e, Ot);
+  let { value: t = 0, minValue: l = 0, maxValue: o = 100, isIndeterminate: i = !1 } = r, [a, n] = V(), { progressBarProps: c, labelProps: d } = Je({
+    ...r,
+    label: n
+  }), u = i ? void 0 : (t - l) / (o - l) * 100, f = v({
+    ...r,
+    defaultClassName: "react-aria-ProgressBar",
+    values: {
+      percentage: u,
+      valueText: c["aria-valuetext"],
+      isIndeterminate: i
+    }
+  });
+  return /* @__PURE__ */ s.createElement("div", {
+    ...c,
+    ...f,
+    ref: e,
+    slot: r.slot
+  }, /* @__PURE__ */ s.createElement(H.Provider, {
+    value: {
+      ...d,
+      ref: a,
+      elementType: "span"
+    }
+  }, f.children));
+}
+const Cr = /* @__PURE__ */ h(Rt), Vt = /* @__PURE__ */ p(null), De = /* @__PURE__ */ p(null);
+function _t(r, e) {
+  [r, e] = P(r, e, Vt);
+  let [t, l] = I({
+    children: []
+  });
+  var o;
+  let { portal: i, collection: a } = pe({
+    items: (o = r.items) !== null && o !== void 0 ? o : t.items,
+    children: t.children
+  }), n = Ze({
+    ...r,
+    collection: a,
+    children: void 0
+  }), c = k(() => ({
+    isOpen: n.isOpen,
+    isFocused: n.isFocused
+  }), [
+    n.isOpen,
+    n.isFocused
+  ]), d = y(null), [u, f] = V(), { labelProps: m, triggerProps: $, valueProps: b, menuProps: g, descriptionProps: T, errorMessageProps: M } = et({
+    ...r,
+    label: f
+  }, n, d), [E, w] = I(null), K = N(() => {
+    d.current && w(d.current.offsetWidth + "px");
+  }, [
+    d
+  ]);
+  ke({
+    ref: d,
+    onResize: K
+  });
+  let B = v({
+    ...r,
+    values: c,
+    defaultClassName: "react-aria-Select"
+  }), O = S(r);
+  return delete O.id, /* @__PURE__ */ s.createElement(F, {
+    values: [
+      [
+        De,
+        {
+          state: n,
+          valueProps: b,
+          placeholder: r.placeholder
+        }
+      ],
+      [
+        H,
+        {
+          ...m,
+          ref: u,
+          elementType: "span"
+        }
+      ],
+      [
+        A,
+        {
+          ...$,
+          ref: d,
+          isPressed: n.isOpen
+        }
+      ],
+      [
+        Z,
+        {
+          state: n,
+          triggerRef: d,
+          preserveChildren: !0,
+          placement: "bottom start",
+          style: {
+            "--trigger-width": E
+          }
+        }
+      ],
+      [
+        Pe,
+        {
+          state: n,
+          [be]: l,
+          ...g
+        }
+      ],
+      [
+        _,
+        {
+          slots: {
+            description: T,
+            errorMessage: M
+          }
+        }
+      ]
+    ]
+  }, /* @__PURE__ */ s.createElement("div", {
+    ...O,
+    ...B,
+    ref: e,
+    slot: r.slot,
+    "data-focused": n.isFocused || void 0,
+    "data-open": n.isOpen || void 0
+  }), i, /* @__PURE__ */ s.createElement(tt, {
+    state: n,
+    triggerRef: d,
+    label: f,
+    name: r.name
+  }));
+}
+const Dr = /* @__PURE__ */ h(_t);
+function Ht(r, e) {
+  var t, l, o;
+  let { state: i, valueProps: a, placeholder: n } = x(De), c = (t = i.selectedItem) === null || t === void 0 ? void 0 : t.rendered;
+  typeof c == "function" && (c = c({
+    isHovered: !1,
+    isPressed: !1,
+    isSelected: !1,
+    isFocused: !1,
+    isFocusVisible: !1,
+    isDisabled: !1,
+    selectionMode: "single",
+    selectionBehavior: "toggle"
+  }));
+  var d, u;
+  let f = v({
+    ...r,
+    // TODO: localize this.
+    defaultChildren: c || n || "Select an item",
+    defaultClassName: "react-aria-SelectValue",
+    values: {
+      selectedItem: (d = (l = i.selectedItem) === null || l === void 0 ? void 0 : l.value) !== null && d !== void 0 ? d : null,
+      selectedText: (u = (o = i.selectedItem) === null || o === void 0 ? void 0 : o.textValue) !== null && u !== void 0 ? u : null,
+      isPlaceholder: !i.selectedItem
+    }
+  }), m = S(r);
+  return delete m.id, /* @__PURE__ */ s.createElement("span", {
+    ref: e,
+    ...m,
+    ...a,
+    ...f,
+    "data-placeholder": !i.selectedItem || void 0
+  }, /* @__PURE__ */ s.createElement(_.Provider, {
+    value: void 0
+  }, f.children));
+}
+const Er = /* @__PURE__ */ h(Ht), Lt = /* @__PURE__ */ p(null);
+function At(r, e) {
+  [r, e] = P(r, e, Lt);
+  let t = y(null), [l, o] = V(), { labelProps: i, inputProps: a, descriptionProps: n, errorMessageProps: c } = ze({
+    ...r,
+    label: o
+  }, t);
+  var d;
+  return /* @__PURE__ */ s.createElement("div", {
+    ...S(r),
+    ref: e,
+    slot: r.slot,
+    className: (d = r.className) !== null && d !== void 0 ? d : "react-aria-TextField",
+    style: r.style
+  }, /* @__PURE__ */ s.createElement(F, {
+    values: [
+      [
+        H,
+        {
+          ...i,
+          ref: l
+        }
+      ],
+      [
+        Y,
+        {
+          ...a,
+          ref: t
+        }
+      ],
+      [
+        _,
+        {
+          slots: {
+            description: n,
+            errorMessage: c
+          }
+        }
+      ]
+    ]
+  }, r.children));
+}
+const wr = /* @__PURE__ */ h(At), ee = /* @__PURE__ */ p(null);
+function kr(r) {
+  let e = Ue(r), t = y(null), { triggerProps: l, tooltipProps: o } = qe(r, e, t);
+  return /* @__PURE__ */ s.createElement(ee.Provider, {
+    value: {
+      state: e,
+      triggerRef: t,
+      tooltipProps: o
+    }
+  }, /* @__PURE__ */ s.createElement(Ie, {
+    ...l,
+    ref: t
+  }, r.children));
+}
+function zt(r, e) {
+  let { state: t } = x(ee), l = L(e), o = me(l, t.isOpen);
+  return !t.isOpen && !o ? null : /* @__PURE__ */ s.createElement(_e, null, /* @__PURE__ */ s.createElement(Ut, {
+    ...r,
+    tooltipRef: l,
+    isExiting: o
+  }));
+}
+const Nr = /* @__PURE__ */ h(zt);
+function Ut(r) {
+  let { state: e, triggerRef: t, tooltipProps: l } = x(ee), o = y(null), { overlayProps: i, arrowProps: a, placement: n } = He({
+    placement: r.placement || "top",
+    targetRef: t,
+    overlayRef: o,
+    offset: r.offset,
+    crossOffset: r.crossOffset,
+    isOpen: e.isOpen
+  }), c = he(o, !!n), d = v({
+    ...r,
+    defaultClassName: "react-aria-Tooltip",
+    values: {
+      placement: n,
+      isEntering: c,
+      isExiting: r.isExiting
+    }
+  });
+  r = D(r, i);
+  let { tooltipProps: u } = We(r, e);
+  return /* @__PURE__ */ s.createElement("div", {
+    ...D(l, u),
+    ref: U(o, r.tooltipRef),
+    ...d,
+    style: {
+      ...d.style,
+      ...i.style
+    },
+    "data-placement": n,
+    "data-entering": c || void 0,
+    "data-exiting": r.isExiting || void 0
+  }, /* @__PURE__ */ s.createElement(J.Provider, {
+    value: {
+      arrowProps: a,
+      placement: n
+    }
+  }, d.children));
+}
 export {
-  r as default
+  hr as Button,
+  A as ButtonContext,
+  Kt as DialogContext,
+  Pr as DialogTrigger,
+  ht as DropIndicator,
+  ye as DropIndicatorContext,
+  It as GroupContext,
+  gt as Header,
+  vr as Input,
+  Y as InputContext,
+  $r as Item,
+  mr as Label,
+  H as LabelContext,
+  gr as ListBox,
+  Pe as ListBoxContext,
+  Mt as ModalContext,
+  Sr as NumberField,
+  Ft as NumberFieldContext,
+  yr as OverlayArrow,
+  xr as Popover,
+  Z as PopoverContext,
+  Cr as ProgressBar,
+  Ot as ProgressBarContext,
+  F as Provider,
+  Kr as SSRProvider,
+  br as Section,
+  Dr as Select,
+  Vt as SelectContext,
+  Er as SelectValue,
+  xt as Separator,
+  xe as SeparatorContext,
+  _ as TextContext,
+  wr as TextField,
+  Lt as TextFieldContext,
+  Nr as Tooltip,
+  kr as TooltipTrigger,
+  P as useContextProps
 };