@koide-labs/ui 0.0.0 → 0.0.1

package/dist/transitions.module-CWX8e5cx.js

@@ -0,0 +1,1343 @@
+import * as v from "react";
+import se from "react";
+import { a as z, o as de, n as lt, i as ft, g as dt, h as pe, l as pt } from "./floating-ui.utils.dom-C7FS5id0.js";
+import { u as Ie, T as ht } from "./useTimeout-CflX-kz3.js";
+import { u as L } from "./useStableCallback-CkTrVkNX.js";
+import { u as mt } from "./useId-C5kyn6tA.js";
+import { u as q } from "./useIsoLayoutEffect-CIDbvm3Q.js";
+import { a as Et, i as gt, N as yt } from "./useRenderElement-DwToLA61.js";
+import { jsx as ze } from "react/jsx-runtime";
+import { c as U, e as St, o as vt, a as Me, n as Ot } from "./createBaseUIEventDetails-D8M2Yl-a.js";
+import { c as _t } from "./FloatingPortal-tWyuKRSN.js";
+import { d as Rt, c as bt } from "./event-CKoGyQEJ.js";
+import { e as B, d as De, f as Q, k as Tt, l as k, F as Ct, n as Be, S as Ge } from "./element-CZEOj04G.js";
+import { f as Ue } from "./formatErrorMessage-BqPuTBN-.js";
+import { T as xe } from "./useOpenChangeComplete-Dse9kY9E.js";
+import './transitions.css';function re(n, t, e = !0) {
+  return n.filter((o) => o.parentId === t && (!e || o.context?.open)).flatMap((o) => [o, ...re(n, o.id, e)]);
+}
+function Mn(n, t) {
+  let e = [], r = n.find((o) => o.id === t)?.parentId;
+  for (; r; ) {
+    const o = n.find((s) => s.id === r);
+    r = o?.parentId, o && (e = e.concat(o));
+  }
+  return e;
+}
+function $e() {
+  const n = /* @__PURE__ */ new Map();
+  return {
+    emit(t, e) {
+      n.get(t)?.forEach((r) => r(e));
+    },
+    on(t, e) {
+      n.has(t) || n.set(t, /* @__PURE__ */ new Set()), n.get(t).add(e);
+    },
+    off(t, e) {
+      n.get(t)?.delete(e);
+    }
+  };
+}
+class wt {
+  nodesRef = {
+    current: []
+  };
+  events = $e();
+  addNode(t) {
+    this.nodesRef.current.push(t);
+  }
+  removeNode(t) {
+    const e = this.nodesRef.current.findIndex((r) => r === t);
+    e !== -1 && this.nodesRef.current.splice(e, 1);
+  }
+}
+const Se = /* @__PURE__ */ v.createContext(null);
+process.env.NODE_ENV !== "production" && (Se.displayName = "FloatingNodeContext");
+const ve = /* @__PURE__ */ v.createContext(null);
+process.env.NODE_ENV !== "production" && (ve.displayName = "FloatingTreeContext");
+const qe = () => v.useContext(Se)?.id || null, Ye = (n) => {
+  const t = v.useContext(ve);
+  return n ?? t;
+};
+function Dn(n) {
+  const t = mt(), e = Ye(n), r = qe();
+  return q(() => {
+    if (!t)
+      return;
+    const o = {
+      id: t,
+      parentId: r
+    };
+    return e?.addNode(o), () => {
+      e?.removeNode(o);
+    };
+  }, [e, t, r]), t;
+}
+function xn(n) {
+  const {
+    children: t,
+    id: e
+  } = n, r = qe();
+  return /* @__PURE__ */ ze(Se.Provider, {
+    value: v.useMemo(() => ({
+      id: e,
+      parentId: r
+    }), [e, r]),
+    children: t
+  });
+}
+function Vn(n) {
+  const {
+    children: t,
+    externalTree: e
+  } = n, r = Et(() => e ?? new wt()).current;
+  return /* @__PURE__ */ ze(ve.Provider, {
+    value: r,
+    children: t
+  });
+}
+const Lt = {
+  intentional: "onClick",
+  sloppy: "onPointerDown"
+};
+function It(n) {
+  return {
+    escapeKey: typeof n == "boolean" ? n : n?.escapeKey ?? !1,
+    outsidePress: typeof n == "boolean" ? n : n?.outsidePress ?? !0
+  };
+}
+function Nn(n, t = {}) {
+  const e = "rootStore" in n ? n.rootStore : n, r = e.useState("open"), o = e.useState("floatingElement"), s = e.useState("referenceElement"), a = e.useState("domReferenceElement"), {
+    onOpenChange: u,
+    dataRef: h
+  } = e.context, {
+    enabled: c = !0,
+    escapeKey: f = !0,
+    outsidePress: m = !0,
+    outsidePressEvent: g = "sloppy",
+    referencePress: l = !1,
+    referencePressEvent: d = "sloppy",
+    ancestorScroll: E = !1,
+    bubbles: _,
+    externalTree: w
+  } = t, b = Ye(w), x = L(typeof m == "function" ? m : () => !1), T = typeof m == "function" ? x : m, N = v.useRef(!1), {
+    escapeKey: O,
+    outsidePress: C
+  } = It(_), R = v.useRef(null), A = Ie(), X = Ie(), F = L(() => {
+    X.clear(), h.current.insideReactTree = !1;
+  }), ie = v.useRef(!1), Re = v.useRef(""), ce = L((i) => {
+    Re.current = i.pointerType;
+  }), W = L(() => {
+    const i = Re.current, y = i === "pen" || !i ? "mouse" : i, p = typeof g == "function" ? g() : g;
+    return typeof p == "string" ? p : p[y];
+  }), P = L((i) => {
+    if (!r || !c || !f || i.key !== "Escape" || ie.current)
+      return;
+    const y = h.current.floatingContext?.nodeId, p = b ? re(b.nodesRef.current, y) : [];
+    if (!O && p.length > 0) {
+      let M = !0;
+      if (p.forEach((I) => {
+        I.context?.open && !I.context.dataRef.current.__escapeKeyBubbles && (M = !1);
+      }), !M)
+        return;
+    }
+    const V = Rt(i) ? i.nativeEvent : i, S = U(St, V);
+    e.setOpen(!1, S), !O && !S.isPropagationAllowed && i.stopPropagation();
+  }), Qe = L((i) => {
+    const y = W();
+    return y === "intentional" && i.type !== "click" || y === "sloppy" && i.type === "click";
+  }), j = L(() => {
+    h.current.insideReactTree = !0, X.start(0, F);
+  }), G = L((i, y = !1) => {
+    if (Qe(i)) {
+      F();
+      return;
+    }
+    if (h.current.insideReactTree) {
+      F();
+      return;
+    }
+    if (W() === "intentional" && y || typeof T == "function" && !T(i))
+      return;
+    const p = B(i), V = `[${_t("inert")}]`, S = De(e.select("floatingElement")).querySelectorAll(V), M = e.context.triggerElements;
+    if (p && (M.hasElement(p) || M.hasMatchingElement((D) => Q(D, p))))
+      return;
+    let I = z(p) ? p : null;
+    for (; I && !de(I); ) {
+      const D = lt(I);
+      if (de(D) || !z(D))
+        break;
+      I = D;
+    }
+    if (S.length && z(p) && !Tt(p) && // Clicked on a direct ancestor (e.g. FloatingOverlay).
+    !Q(p, e.select("floatingElement")) && // If the target root element contains none of the markers, then the
+    // element was injected after the floating element rendered.
+    Array.from(S).every((D) => !Q(I, D)))
+      return;
+    if (ft(p) && !("touches" in i)) {
+      const D = de(p), H = dt(p), Le = /auto|scroll/, rt = D || Le.test(H.overflowX), ot = D || Le.test(H.overflowY), st = rt && p.clientWidth > 0 && p.scrollWidth > p.clientWidth, it = ot && p.clientHeight > 0 && p.scrollHeight > p.clientHeight, ct = H.direction === "rtl", ut = it && (ct ? i.offsetX <= p.offsetWidth - p.clientWidth : i.offsetX > p.clientWidth), at = st && i.offsetY > p.clientHeight;
+      if (ut || at)
+        return;
+    }
+    const Ce = h.current.floatingContext?.nodeId, nt = b && re(b.nodesRef.current, Ce).some((D) => k(i, D.context?.elements.floating));
+    if (k(i, e.select("floatingElement")) || k(i, e.select("domReferenceElement")) || nt)
+      return;
+    const we = b ? re(b.nodesRef.current, Ce) : [];
+    if (we.length > 0) {
+      let D = !0;
+      if (we.forEach((H) => {
+        H.context?.open && !H.context.dataRef.current.__outsidePressBubbles && (D = !1);
+      }), !D)
+        return;
+    }
+    e.setOpen(!1, U(vt, i)), F();
+  }), be = L((i) => {
+    W() !== "sloppy" || i.pointerType === "touch" || !e.select("open") || !c || k(i, e.select("floatingElement")) || k(i, e.select("domReferenceElement")) || G(i);
+  }), Ze = L((i) => {
+    if (W() !== "sloppy" || !e.select("open") || !c || k(i, e.select("floatingElement")) || k(i, e.select("domReferenceElement")))
+      return;
+    const y = i.touches[0];
+    y && (R.current = {
+      startTime: Date.now(),
+      startX: y.clientX,
+      startY: y.clientY,
+      dismissOnTouchEnd: !1,
+      dismissOnMouseDown: !0
+    }, A.start(1e3, () => {
+      R.current && (R.current.dismissOnTouchEnd = !1, R.current.dismissOnMouseDown = !1);
+    }));
+  }), ue = L((i) => {
+    const y = B(i);
+    function p() {
+      Ze(i), y?.removeEventListener(i.type, p);
+    }
+    y?.addEventListener(i.type, p);
+  }), K = L((i) => {
+    const y = N.current;
+    if (N.current = !1, A.clear(), i.type === "mousedown" && R.current && !R.current.dismissOnMouseDown)
+      return;
+    const p = B(i);
+    function V() {
+      i.type === "pointerdown" ? be(i) : G(i, y), p?.removeEventListener(i.type, V);
+    }
+    p?.addEventListener(i.type, V);
+  }), et = L((i) => {
+    if (W() !== "sloppy" || !R.current || k(i, e.select("floatingElement")) || k(i, e.select("domReferenceElement")))
+      return;
+    const y = i.touches[0];
+    if (!y)
+      return;
+    const p = Math.abs(y.clientX - R.current.startX), V = Math.abs(y.clientY - R.current.startY), S = Math.sqrt(p * p + V * V);
+    S > 5 && (R.current.dismissOnTouchEnd = !0), S > 10 && (G(i), A.clear(), R.current = null);
+  }), ae = L((i) => {
+    const y = B(i);
+    function p() {
+      et(i), y?.removeEventListener(i.type, p);
+    }
+    y?.addEventListener(i.type, p);
+  }), tt = L((i) => {
+    W() !== "sloppy" || !R.current || k(i, e.select("floatingElement")) || k(i, e.select("domReferenceElement")) || (R.current.dismissOnTouchEnd && G(i), A.clear(), R.current = null);
+  }), le = L((i) => {
+    const y = B(i);
+    function p() {
+      tt(i), y?.removeEventListener(i.type, p);
+    }
+    y?.addEventListener(i.type, p);
+  });
+  v.useEffect(() => {
+    if (!r || !c)
+      return;
+    h.current.__escapeKeyBubbles = O, h.current.__outsidePressBubbles = C;
+    const i = new ht();
+    function y(I) {
+      e.setOpen(!1, U(Ot, I));
+    }
+    function p() {
+      i.clear(), ie.current = !0;
+    }
+    function V() {
+      i.start(
+        // 0ms or 1ms don't work in Safari. 5ms appears to consistently work.
+        // Only apply to WebKit for the test to remain 0ms.
+        pt() ? 5 : 0,
+        () => {
+          ie.current = !1;
+        }
+      );
+    }
+    const S = De(o);
+    S.addEventListener("pointerdown", ce, !0), f && (S.addEventListener("keydown", P), S.addEventListener("compositionstart", p), S.addEventListener("compositionend", V)), T && (S.addEventListener("click", K, !0), S.addEventListener("pointerdown", K, !0), S.addEventListener("touchstart", ue, !0), S.addEventListener("touchmove", ae, !0), S.addEventListener("touchend", le, !0), S.addEventListener("mousedown", K, !0));
+    let M = [];
+    return E && (z(a) && (M = pe(a)), z(o) && (M = M.concat(pe(o))), !z(s) && s && s.contextElement && (M = M.concat(pe(s.contextElement)))), M = M.filter((I) => I !== S.defaultView?.visualViewport), M.forEach((I) => {
+      I.addEventListener("scroll", y, {
+        passive: !0
+      });
+    }), () => {
+      S.removeEventListener("pointerdown", ce, !0), f && (S.removeEventListener("keydown", P), S.removeEventListener("compositionstart", p), S.removeEventListener("compositionend", V)), T && (S.removeEventListener("click", K, !0), S.removeEventListener("pointerdown", K, !0), S.removeEventListener("touchstart", ue, !0), S.removeEventListener("touchmove", ae, !0), S.removeEventListener("touchend", le, !0), S.removeEventListener("mousedown", K, !0)), M.forEach((I) => {
+        I.removeEventListener("scroll", y);
+      }), i.clear();
+    };
+  }, [h, o, s, a, f, T, r, u, E, c, O, C, P, G, K, be, ue, ae, le, ce, e]), v.useEffect(F, [T, F]);
+  const fe = v.useMemo(() => ({
+    onKeyDown: P,
+    ...l && {
+      [Lt[d]]: (i) => {
+        e.setOpen(!1, U(Me, i.nativeEvent));
+      },
+      ...d !== "intentional" && {
+        onClick(i) {
+          e.setOpen(!1, U(Me, i.nativeEvent));
+        }
+      }
+    }
+  }), [P, e, l, d]), J = L((i) => {
+    const y = B(i.nativeEvent);
+    !Q(e.select("floatingElement"), y) || i.button !== 0 || (N.current = !0);
+  }), Te = v.useMemo(() => ({
+    onKeyDown: P,
+    // `onMouseDown` may be blocked if `event.preventDefault()` is called in
+    // `onPointerDown`, such as with <NumberField.ScrubArea>.
+    // See https://github.com/mui/base-ui/pull/3379
+    onPointerDown: J,
+    onMouseDown: J,
+    onMouseUp: J,
+    onClickCapture: j,
+    onMouseDownCapture: j,
+    onPointerDownCapture: j,
+    onMouseUpCapture: j,
+    onTouchEndCapture: j,
+    onTouchMoveCapture: j
+  }), [P, J, j]);
+  return v.useMemo(() => c ? {
+    reference: fe,
+    floating: Te,
+    trigger: fe
+  } : {}, [c, fe, Te]);
+}
+var Mt = (n, t, e) => {
+  if (t.length === 1 && t[0] === e) {
+    let r = !1;
+    try {
+      const o = {};
+      n(o) === o && (r = !0);
+    } catch {
+    }
+    if (r) {
+      let o;
+      try {
+        throw new Error();
+      } catch (s) {
+        ({ stack: o } = s);
+      }
+      console.warn(
+        `The result function returned its own inputs without modification. e.g
+\`createSelector([state => state.todos], todos => todos)\`
+This could lead to inefficient memoization and unnecessary re-renders.
+Ensure transformation logic is in the result function, and extraction logic is in the input selectors.`,
+        { stack: o }
+      );
+    }
+  }
+}, Dt = (n, t, e) => {
+  const { memoize: r, memoizeOptions: o } = t, { inputSelectorResults: s, inputSelectorResultsCopy: a } = n, u = r(() => ({}), ...o);
+  if (!(u.apply(null, s) === u.apply(null, a))) {
+    let c;
+    try {
+      throw new Error();
+    } catch (f) {
+      ({ stack: c } = f);
+    }
+    console.warn(
+      `An input selector returned a different result when passed same arguments.
+This means your output selector will likely run more frequently than intended.
+Avoid returning a new reference inside your input selector, e.g.
+\`createSelector([state => state.todos.map(todo => todo.id)], todoIds => todoIds.length)\``,
+      {
+        arguments: e,
+        firstInputs: s,
+        secondInputs: a,
+        stack: c
+      }
+    );
+  }
+}, xt = {
+  inputStabilityCheck: "once",
+  identityFunctionCheck: "once"
+}, oe = /* @__PURE__ */ Symbol("NOT_FOUND");
+function Vt(n, t = `expected a function, instead received ${typeof n}`) {
+  if (typeof n != "function")
+    throw new TypeError(t);
+}
+function Nt(n, t = `expected an object, instead received ${typeof n}`) {
+  if (typeof n != "object")
+    throw new TypeError(t);
+}
+function kt(n, t = "expected all items to be functions, instead received the following types: ") {
+  if (!n.every((e) => typeof e == "function")) {
+    const e = n.map(
+      (r) => typeof r == "function" ? `function ${r.name || "unnamed"}()` : typeof r
+    ).join(", ");
+    throw new TypeError(`${t}[${e}]`);
+  }
+}
+var Ve = (n) => Array.isArray(n) ? n : [n];
+function At(n) {
+  const t = Array.isArray(n[0]) ? n[0] : n;
+  return kt(
+    t,
+    "createSelector expects all input-selectors to be functions, but received the following types: "
+  ), t;
+}
+function Ne(n, t) {
+  const e = [], { length: r } = n;
+  for (let o = 0; o < r; o++)
+    e.push(n[o].apply(null, t));
+  return e;
+}
+var Pt = (n, t) => {
+  const { identityFunctionCheck: e, inputStabilityCheck: r } = {
+    ...xt,
+    ...t
+  };
+  return {
+    identityFunctionCheck: {
+      shouldRun: e === "always" || e === "once" && n,
+      run: Mt
+    },
+    inputStabilityCheck: {
+      shouldRun: r === "always" || r === "once" && n,
+      run: Dt
+    }
+  };
+};
+function jt(n) {
+  let t;
+  return {
+    get(e) {
+      return t && n(t.key, e) ? t.value : oe;
+    },
+    put(e, r) {
+      t = { key: e, value: r };
+    },
+    getEntries() {
+      return t ? [t] : [];
+    },
+    clear() {
+      t = void 0;
+    }
+  };
+}
+function Kt(n, t) {
+  let e = [];
+  function r(u) {
+    const h = e.findIndex((c) => t(u, c.key));
+    if (h > -1) {
+      const c = e[h];
+      return h > 0 && (e.splice(h, 1), e.unshift(c)), c.value;
+    }
+    return oe;
+  }
+  function o(u, h) {
+    r(u) === oe && (e.unshift({ key: u, value: h }), e.length > n && e.pop());
+  }
+  function s() {
+    return e;
+  }
+  function a() {
+    e = [];
+  }
+  return { get: r, put: o, getEntries: s, clear: a };
+}
+var Ft = (n, t) => n === t;
+function Wt(n) {
+  return function(e, r) {
+    if (e === null || r === null || e.length !== r.length)
+      return !1;
+    const { length: o } = e;
+    for (let s = 0; s < o; s++)
+      if (!n(e[s], r[s]))
+        return !1;
+    return !0;
+  };
+}
+function Ht(n, t) {
+  const e = typeof t == "object" ? t : { equalityCheck: t }, {
+    equalityCheck: r = Ft,
+    maxSize: o = 1,
+    resultEqualityCheck: s
+  } = e, a = Wt(r);
+  let u = 0;
+  const h = o <= 1 ? jt(a) : Kt(o, a);
+  function c() {
+    let f = h.get(arguments);
+    if (f === oe) {
+      if (f = n.apply(null, arguments), u++, s) {
+        const g = h.getEntries().find(
+          (l) => s(l.value, f)
+        );
+        g && (f = g.value, u !== 0 && u--);
+      }
+      h.put(arguments, f);
+    }
+    return f;
+  }
+  return c.clearCache = () => {
+    h.clear(), c.resetResultsCount();
+  }, c.resultsCount = () => u, c.resetResultsCount = () => {
+    u = 0;
+  }, c;
+}
+var zt = class {
+  constructor(n) {
+    this.value = n;
+  }
+  deref() {
+    return this.value;
+  }
+}, Bt = typeof WeakRef < "u" ? WeakRef : zt, Gt = 0, ke = 1;
+function Z() {
+  return {
+    s: Gt,
+    v: void 0,
+    o: null,
+    p: null
+  };
+}
+function Xe(n, t = {}) {
+  let e = Z();
+  const { resultEqualityCheck: r } = t;
+  let o, s = 0;
+  function a() {
+    let u = e;
+    const { length: h } = arguments;
+    for (let m = 0, g = h; m < g; m++) {
+      const l = arguments[m];
+      if (typeof l == "function" || typeof l == "object" && l !== null) {
+        let d = u.o;
+        d === null && (u.o = d = /* @__PURE__ */ new WeakMap());
+        const E = d.get(l);
+        E === void 0 ? (u = Z(), d.set(l, u)) : u = E;
+      } else {
+        let d = u.p;
+        d === null && (u.p = d = /* @__PURE__ */ new Map());
+        const E = d.get(l);
+        E === void 0 ? (u = Z(), d.set(l, u)) : u = E;
+      }
+    }
+    const c = u;
+    let f;
+    if (u.s === ke)
+      f = u.v;
+    else if (f = n.apply(null, arguments), s++, r) {
+      const m = o?.deref?.() ?? o;
+      m != null && r(m, f) && (f = m, s !== 0 && s--), o = typeof f == "object" && f !== null || typeof f == "function" ? new Bt(f) : f;
+    }
+    return c.s = ke, c.v = f, f;
+  }
+  return a.clearCache = () => {
+    e = Z(), a.resetResultsCount();
+  }, a.resultsCount = () => s, a.resetResultsCount = () => {
+    s = 0;
+  }, a;
+}
+function Je(n, ...t) {
+  const e = typeof n == "function" ? {
+    memoize: n,
+    memoizeOptions: t
+  } : n, r = (...o) => {
+    let s = 0, a = 0, u, h = {}, c = o.pop();
+    typeof c == "object" && (h = c, c = o.pop()), Vt(
+      c,
+      `createSelector expects an output function after the inputs, but received: [${typeof c}]`
+    );
+    const f = {
+      ...e,
+      ...h
+    }, {
+      memoize: m,
+      memoizeOptions: g = [],
+      argsMemoize: l = Xe,
+      argsMemoizeOptions: d = [],
+      devModeChecks: E = {}
+    } = f, _ = Ve(g), w = Ve(d), b = At(o), x = m(function() {
+      return s++, c.apply(
+        null,
+        arguments
+      );
+    }, ..._);
+    let T = !0;
+    const N = l(function() {
+      a++;
+      const C = Ne(
+        b,
+        arguments
+      );
+      if (u = x.apply(null, C), process.env.NODE_ENV !== "production") {
+        const { identityFunctionCheck: R, inputStabilityCheck: A } = Pt(T, E);
+        if (R.shouldRun && R.run(
+          c,
+          C,
+          u
+        ), A.shouldRun) {
+          const X = Ne(
+            b,
+            arguments
+          );
+          A.run(
+            { inputSelectorResults: C, inputSelectorResultsCopy: X },
+            { memoize: m, memoizeOptions: _ },
+            arguments
+          );
+        }
+        T && (T = !1);
+      }
+      return u;
+    }, ...w);
+    return Object.assign(N, {
+      resultFunc: c,
+      memoizedResultFunc: x,
+      dependencies: b,
+      dependencyRecomputations: () => a,
+      resetDependencyRecomputations: () => {
+        a = 0;
+      },
+      lastResult: () => u,
+      recomputations: () => s,
+      resetRecomputations: () => {
+        s = 0;
+      },
+      memoize: m,
+      argsMemoize: l
+    });
+  };
+  return Object.assign(r, {
+    withTypes: () => r
+  }), r;
+}
+var Ut = /* @__PURE__ */ Je(Xe), $t = Object.assign(
+  (n, t = Ut) => {
+    Nt(
+      n,
+      `createStructuredSelector expects first argument to be an object where each property is a selector, instead received a ${typeof n}`
+    );
+    const e = Object.keys(n), r = e.map(
+      (s) => n[s]
+    );
+    return t(
+      r,
+      (...s) => s.reduce((a, u, h) => (a[e[h]] = u, a), {})
+    );
+  },
+  { withTypes: () => $t }
+);
+Je({
+  memoize: Ht,
+  memoizeOptions: {
+    maxSize: 1,
+    equalityCheck: Object.is
+  }
+});
+const $ = (n, t, e, r, o, s, ...a) => {
+  if (a.length > 0)
+    throw new Error(process.env.NODE_ENV !== "production" ? "Unsupported number of selectors" : Ue(1));
+  let u;
+  if (n)
+    u = n;
+  else
+    throw new Error("Missing arguments");
+  return u;
+};
+var ee = { exports: {} }, he = {};
+var Ae;
+function qt() {
+  if (Ae) return he;
+  Ae = 1;
+  var n = se;
+  function t(m, g) {
+    return m === g && (m !== 0 || 1 / m === 1 / g) || m !== m && g !== g;
+  }
+  var e = typeof Object.is == "function" ? Object.is : t, r = n.useState, o = n.useEffect, s = n.useLayoutEffect, a = n.useDebugValue;
+  function u(m, g) {
+    var l = g(), d = r({ inst: { value: l, getSnapshot: g } }), E = d[0].inst, _ = d[1];
+    return s(
+      function() {
+        E.value = l, E.getSnapshot = g, h(E) && _({ inst: E });
+      },
+      [m, l, g]
+    ), o(
+      function() {
+        return h(E) && _({ inst: E }), m(function() {
+          h(E) && _({ inst: E });
+        });
+      },
+      [m]
+    ), a(l), l;
+  }
+  function h(m) {
+    var g = m.getSnapshot;
+    m = m.value;
+    try {
+      var l = g();
+      return !e(m, l);
+    } catch {
+      return !0;
+    }
+  }
+  function c(m, g) {
+    return g();
+  }
+  var f = typeof window > "u" || typeof window.document > "u" || typeof window.document.createElement > "u" ? c : u;
+  return he.useSyncExternalStore = n.useSyncExternalStore !== void 0 ? n.useSyncExternalStore : f, he;
+}
+var me = {};
+var Pe;
+function Yt() {
+  return Pe || (Pe = 1, process.env.NODE_ENV !== "production" && (function() {
+    function n(l, d) {
+      return l === d && (l !== 0 || 1 / l === 1 / d) || l !== l && d !== d;
+    }
+    function t(l, d) {
+      f || o.startTransition === void 0 || (f = !0, console.error(
+        "You are using an outdated, pre-release alpha of React 18 that does not support useSyncExternalStore. The use-sync-external-store shim will not work correctly. Upgrade to a newer pre-release."
+      ));
+      var E = d();
+      if (!m) {
+        var _ = d();
+        s(E, _) || (console.error(
+          "The result of getSnapshot should be cached to avoid an infinite loop"
+        ), m = !0);
+      }
+      _ = a({
+        inst: { value: E, getSnapshot: d }
+      });
+      var w = _[0].inst, b = _[1];
+      return h(
+        function() {
+          w.value = E, w.getSnapshot = d, e(w) && b({ inst: w });
+        },
+        [l, E, d]
+      ), u(
+        function() {
+          return e(w) && b({ inst: w }), l(function() {
+            e(w) && b({ inst: w });
+          });
+        },
+        [l]
+      ), c(E), E;
+    }
+    function e(l) {
+      var d = l.getSnapshot;
+      l = l.value;
+      try {
+        var E = d();
+        return !s(l, E);
+      } catch {
+        return !0;
+      }
+    }
+    function r(l, d) {
+      return d();
+    }
+    typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ < "u" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart == "function" && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error());
+    var o = se, s = typeof Object.is == "function" ? Object.is : n, a = o.useState, u = o.useEffect, h = o.useLayoutEffect, c = o.useDebugValue, f = !1, m = !1, g = typeof window > "u" || typeof window.document > "u" || typeof window.document.createElement > "u" ? r : t;
+    me.useSyncExternalStore = o.useSyncExternalStore !== void 0 ? o.useSyncExternalStore : g, typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ < "u" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop == "function" && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
+  })()), me;
+}
+var je;
+function Oe() {
+  return je || (je = 1, process.env.NODE_ENV === "production" ? ee.exports = qt() : ee.exports = Yt()), ee.exports;
+}
+var Xt = Oe(), te = { exports: {} }, Ee = {};
+var Ke;
+function Jt() {
+  if (Ke) return Ee;
+  Ke = 1;
+  var n = se, t = Oe();
+  function e(c, f) {
+    return c === f && (c !== 0 || 1 / c === 1 / f) || c !== c && f !== f;
+  }
+  var r = typeof Object.is == "function" ? Object.is : e, o = t.useSyncExternalStore, s = n.useRef, a = n.useEffect, u = n.useMemo, h = n.useDebugValue;
+  return Ee.useSyncExternalStoreWithSelector = function(c, f, m, g, l) {
+    var d = s(null);
+    if (d.current === null) {
+      var E = { hasValue: !1, value: null };
+      d.current = E;
+    } else E = d.current;
+    d = u(
+      function() {
+        function w(O) {
+          if (!b) {
+            if (b = !0, x = O, O = g(O), l !== void 0 && E.hasValue) {
+              var C = E.value;
+              if (l(C, O))
+                return T = C;
+            }
+            return T = O;
+          }
+          if (C = T, r(x, O)) return C;
+          var R = g(O);
+          return l !== void 0 && l(C, R) ? (x = O, C) : (x = O, T = R);
+        }
+        var b = !1, x, T, N = m === void 0 ? null : m;
+        return [
+          function() {
+            return w(f());
+          },
+          N === null ? void 0 : function() {
+            return w(N());
+          }
+        ];
+      },
+      [f, m, g, l]
+    );
+    var _ = o(c, d[0], d[1]);
+    return a(
+      function() {
+        E.hasValue = !0, E.value = _;
+      },
+      [_]
+    ), h(_), _;
+  }, Ee;
+}
+var ge = {};
+var Fe;
+function Qt() {
+  return Fe || (Fe = 1, process.env.NODE_ENV !== "production" && (function() {
+    function n(c, f) {
+      return c === f && (c !== 0 || 1 / c === 1 / f) || c !== c && f !== f;
+    }
+    typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ < "u" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart == "function" && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error());
+    var t = se, e = Oe(), r = typeof Object.is == "function" ? Object.is : n, o = e.useSyncExternalStore, s = t.useRef, a = t.useEffect, u = t.useMemo, h = t.useDebugValue;
+    ge.useSyncExternalStoreWithSelector = function(c, f, m, g, l) {
+      var d = s(null);
+      if (d.current === null) {
+        var E = { hasValue: !1, value: null };
+        d.current = E;
+      } else E = d.current;
+      d = u(
+        function() {
+          function w(O) {
+            if (!b) {
+              if (b = !0, x = O, O = g(O), l !== void 0 && E.hasValue) {
+                var C = E.value;
+                if (l(C, O))
+                  return T = C;
+              }
+              return T = O;
+            }
+            if (C = T, r(x, O))
+              return C;
+            var R = g(O);
+            return l !== void 0 && l(C, R) ? (x = O, C) : (x = O, T = R);
+          }
+          var b = !1, x, T, N = m === void 0 ? null : m;
+          return [
+            function() {
+              return w(f());
+            },
+            N === null ? void 0 : function() {
+              return w(N());
+            }
+          ];
+        },
+        [f, m, g, l]
+      );
+      var _ = o(c, d[0], d[1]);
+      return a(
+        function() {
+          E.hasValue = !0, E.value = _;
+        },
+        [_]
+      ), h(_), _;
+    }, typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ < "u" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop == "function" && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
+  })()), ge;
+}
+var We;
+function Zt() {
+  return We || (We = 1, process.env.NODE_ENV === "production" ? te.exports = Jt() : te.exports = Qt()), te.exports;
+}
+var en = Zt();
+const tn = gt(19), nn = tn ? on : sn;
+function rn(n, t, e, r, o) {
+  return nn(n, t, e, r, o);
+}
+function on(n, t, e, r, o) {
+  const s = v.useCallback(() => t(n.getSnapshot(), e, r, o), [n, t, e, r, o]);
+  return Xt.useSyncExternalStore(n.subscribe, s, s);
+}
+function sn(n, t, e, r, o) {
+  return en.useSyncExternalStoreWithSelector(n.subscribe, n.getSnapshot, n.getSnapshot, (s) => t(s, e, r, o));
+}
+class Y {
+  /**
+   * The current state of the store.
+   * This property is updated immediately when the state changes as a result of calling {@link setState}, {@link update}, or {@link set}.
+   * To subscribe to state changes, use the {@link useState} method. The value returned by {@link useState} is updated after the component renders (similarly to React's useState).
+   * The values can be used directly (to avoid subscribing to the store) in effects or event handlers.
+   *
+   * Do not modify properties in state directly. Instead, use the provided methods to ensure proper state management and listener notification.
+   */
+  // Internal state to handle recursive `setState()` calls
+  constructor(t) {
+    this.state = t, this.listeners = /* @__PURE__ */ new Set(), this.updateTick = 0;
+  }
+  /**
+   * Registers a listener that will be called whenever the store's state changes.
+   *
+   * @param fn The listener function to be called on state changes.
+   * @returns A function to unsubscribe the listener.
+   */
+  subscribe = (t) => (this.listeners.add(t), () => {
+    this.listeners.delete(t);
+  });
+  /**
+   * Returns the current state of the store.
+   */
+  getSnapshot = () => this.state;
+  /**
+   * Updates the entire store's state and notifies all registered listeners.
+   *
+   * @param newState The new state to set for the store.
+   */
+  setState(t) {
+    if (this.state === t)
+      return;
+    this.state = t, this.updateTick += 1;
+    const e = this.updateTick;
+    for (const r of this.listeners) {
+      if (e !== this.updateTick)
+        return;
+      r(t);
+    }
+  }
+  /**
+   * Merges the provided changes into the current state and notifies listeners if there are changes.
+   *
+   * @param changes An object containing the changes to apply to the current state.
+   */
+  update(t) {
+    for (const e in t)
+      if (!Object.is(this.state[e], t[e])) {
+        Y.prototype.setState.call(this, {
+          ...this.state,
+          ...t
+        });
+        return;
+      }
+  }
+  /**
+   * Sets a specific key in the store's state to a new value and notifies listeners if the value has changed.
+   *
+   * @param key The key in the store's state to update.
+   * @param value The new value to set for the specified key.
+   */
+  set(t, e) {
+    Object.is(this.state[t], e) || Y.prototype.setState.call(this, {
+      ...this.state,
+      [t]: e
+    });
+  }
+  /**
+   * Gives the state a new reference and updates all registered listeners.
+   */
+  notifyAll() {
+    const t = {
+      ...this.state
+    };
+    Y.prototype.setState.call(this, t);
+  }
+}
+class cn extends Y {
+  /**
+   * Creates a new ReactStore instance.
+   *
+   * @param state Initial state of the store.
+   * @param context Non-reactive context values.
+   * @param selectors Optional selectors for use with `useState`.
+   */
+  constructor(t, e = {}, r) {
+    super(t), this.context = e, this.selectors = r;
+  }
+  /**
+   * Non-reactive values such as refs, callbacks, etc.
+   */
+  /**
+   * Keeps track of which properties are controlled.
+   */
+  controlledValues = /* @__PURE__ */ new Map();
+  /**
+   * Synchronizes a single external value into the store.
+   *
+   * Note that the while the value in `state` is updated immediately, the value returned
+   * by `useState` is updated before the next render (similarly to React's `useState`).
+   */
+  useSyncedValue(t, e) {
+    v.useDebugValue(t), q(() => {
+      this.state[t] !== e && this.set(t, e);
+    }, [t, e]);
+  }
+  /**
+   * Synchronizes a single external value into the store and
+   * cleans it up (sets to `undefined`) on unmount.
+   *
+   * Note that the while the value in `state` is updated immediately, the value returned
+   * by `useState` is updated before the next render (similarly to React's `useState`).
+   */
+  useSyncedValueWithCleanup(t, e) {
+    q(() => (this.state[t] !== e && this.set(t, e), () => {
+      this.set(t, void 0);
+    }), [t, e]);
+  }
+  /**
+   * Synchronizes multiple external values into the store.
+   *
+   * Note that the while the values in `state` are updated immediately, the values returned
+   * by `useState` are updated before the next render (similarly to React's `useState`).
+   */
+  useSyncedValues(t) {
+    if (process.env.NODE_ENV !== "production") {
+      v.useDebugValue(t, (s) => Object.keys(s));
+      const r = v.useRef(Object.keys(t)).current, o = Object.keys(t);
+      (r.length !== o.length || r.some((s, a) => s !== o[a])) && console.error("ReactStore.useSyncedValues expects the same prop keys on every render. Keys should be stable.");
+    }
+    const e = Object.values(t);
+    q(() => {
+      this.update(t);
+    }, e);
+  }
+  /**
+   * Registers a controllable prop pair (`controlled`, `defaultValue`) for a specific key.
+   * - If `controlled` is non-undefined, the key is marked as controlled and the store's
+   *   state at `key` is updated to match `controlled`. Local writes to that key are ignored.
+   * - If `controlled` is undefined, the key is marked as uncontrolled. The store's state
+   *   is initialized to `defaultValue` on first render and can be updated with local writes.
+   */
+  useControlledProp(t, e, r) {
+    v.useDebugValue(t);
+    const o = e !== void 0;
+    if (process.env.NODE_ENV !== "production") {
+      const s = this.controlledValues.get(t);
+      s !== void 0 && s !== o && console.error(`A component is changing the ${o ? "" : "un"}controlled state of ${t.toString()} to be ${o ? "un" : ""}controlled. Elements should not switch from uncontrolled to controlled (or vice versa).`);
+    }
+    this.controlledValues.has(t) || (this.controlledValues.set(t, o), !o && !Object.is(this.state[t], r) && super.setState({
+      ...this.state,
+      [t]: r
+    })), q(() => {
+      o && !Object.is(this.state[t], e) && super.setState({
+        ...this.state,
+        [t]: e
+      });
+    }, [t, e, r, o]);
+  }
+  /**
+   * Sets a specific key in the store's state to a new value and notifies listeners if the value has changed.
+   * If the key is controlled (registered via {@link useControlledProp} with a non-undefined value),
+   * the update is ignored and no listeners are notified.
+   *
+   * @param key The state key to update.
+   * @param value The new value to set for the specified key.
+   */
+  set(t, e) {
+    this.controlledValues.get(t) !== !0 && super.set(t, e);
+  }
+  /**
+   * Merges the provided changes into the current state and notifies listeners if there are changes.
+   * Controlled keys are filtered out and not updated.
+   *
+   * @param values An object containing the changes to apply to the current state.
+   */
+  update(t) {
+    const e = {
+      ...t
+    };
+    for (const r in e)
+      if (Object.hasOwn(e, r) && this.controlledValues.get(r) === !0) {
+        delete e[r];
+        continue;
+      }
+    super.update(e);
+  }
+  /**
+   * Updates the entire store's state and notifies all registered listeners.
+   * Controlled keys are left unchanged; only uncontrolled keys from `newState` are applied.
+   *
+   * @param newState The new state to set for the store.
+   */
+  setState(t) {
+    const e = {
+      ...t
+    };
+    for (const r in e)
+      if (Object.hasOwn(e, r) && this.controlledValues.get(r) === !0) {
+        delete e[r];
+        continue;
+      }
+    super.setState({
+      ...this.state,
+      ...e
+    });
+  }
+  /** Gets the current value from the store using a selector with the provided key.
+   *
+   * @param key Key of the selector to use.
+   */
+  select = (t, e, r, o) => {
+    const s = this.selectors[t];
+    return s(this.state, e, r, o);
+  };
+  /**
+   * Returns a value from the store's state using a selector function.
+   * Used to subscribe to specific parts of the state.
+   * This methods causes a rerender whenever the selected state changes.
+   *
+   * @param key Key of the selector to use.
+   */
+  useState = (t, e, r, o) => {
+    v.useDebugValue(t);
+    const s = this.selectors[t];
+    return rn(this, s, e, r, o);
+  };
+  /**
+   * Wraps a function with `useStableCallback` to ensure it has a stable reference
+   * and assigns it to the context.
+   *
+   * @param key Key of the event callback. Must be a function in the context.
+   * @param fn Function to assign.
+   */
+  useContextCallback(t, e) {
+    v.useDebugValue(t);
+    const r = L(e ?? yt);
+    this.context[t] = r;
+  }
+  /**
+   * Returns a stable setter function for a specific key in the store's state.
+   * It's commonly used to pass as a ref callback to React elements.
+   *
+   * @param key Key of the state to set.
+   */
+  useStateSetter(t) {
+    const e = v.useRef(void 0);
+    return e.current === void 0 && (e.current = (r) => {
+      this.set(t, r);
+    }), e.current;
+  }
+  /**
+   * Observes changes derived from the store's selectors and calls the listener when the selected value changes.
+   *
+   * @param key Key of the selector to observe.
+   * @param listener Listener function called when the selector result changes.
+   */
+  observe(t, e) {
+    let r;
+    typeof t == "function" ? r = t : r = this.selectors[t];
+    let o = r(this.state);
+    return e(o, o, this), this.subscribe((s) => {
+      const a = r(s);
+      if (!Object.is(o, a)) {
+        const u = o;
+        o = a, e(a, u, this);
+      }
+    });
+  }
+}
+const un = {
+  open: $((n) => n.open),
+  domReferenceElement: $((n) => n.domReferenceElement),
+  referenceElement: $((n) => n.positionReference ?? n.referenceElement),
+  floatingElement: $((n) => n.floatingElement),
+  floatingId: $((n) => n.floatingId)
+};
+class kn extends cn {
+  constructor(t) {
+    const {
+      nested: e,
+      noEmit: r,
+      onOpenChange: o,
+      triggerElements: s,
+      ...a
+    } = t;
+    super({
+      ...a,
+      positionReference: a.referenceElement,
+      domReferenceElement: a.referenceElement
+    }, {
+      onOpenChange: o,
+      dataRef: {
+        current: {}
+      },
+      events: $e(),
+      nested: e,
+      noEmit: r,
+      triggerElements: s
+    }, un);
+  }
+  /**
+   * Emits the `openchange` event through the internal event emitter and calls the `onOpenChange` handler with the provided arguments.
+   *
+   * @param newOpen The new open state.
+   * @param eventDetails Details about the event that triggered the open state change.
+   */
+  setOpen = (t, e) => {
+    if ((!t || !this.state.open || // Prevent a pending hover-open from overwriting a click-open event, while allowing
+    // click events to upgrade a hover-open.
+    bt(e.event)) && (this.context.dataRef.current.openEvent = t ? e.event : void 0), !this.context.noEmit) {
+      const r = {
+        open: t,
+        reason: e.reason,
+        nativeEvent: e.event,
+        nested: this.context.nested,
+        triggerElement: e.trigger
+      };
+      this.context.events.emit("openchange", r);
+    }
+    this.context.onOpenChange?.(t, e);
+  };
+}
+class An {
+  constructor() {
+    this.elements = /* @__PURE__ */ new Set(), this.idMap = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Adds a trigger element with the given ID.
+   *
+   * Note: The provided element is assumed to not be registered under multiple IDs.
+   */
+  add(t, e) {
+    const r = this.idMap.get(t);
+    if (r !== e && (r !== void 0 && this.elements.delete(r), this.elements.add(e), this.idMap.set(t, e), process.env.NODE_ENV !== "production" && this.elements.size !== this.idMap.size))
+      throw new Error(process.env.NODE_ENV !== "production" ? "Base UI: A trigger element cannot be registered under multiple IDs in PopupTriggerMap." : Ue(87));
+  }
+  /**
+   * Removes the trigger element with the given ID.
+   */
+  delete(t) {
+    const e = this.idMap.get(t);
+    e && (this.elements.delete(e), this.idMap.delete(t));
+  }
+  /**
+   * Whether the given element is registered as a trigger.
+   */
+  hasElement(t) {
+    return this.elements.has(t);
+  }
+  /**
+   * Whether there is a registered trigger element matching the given predicate.
+   */
+  hasMatchingElement(t) {
+    for (const e of this.elements)
+      if (t(e))
+        return !0;
+    return !1;
+  }
+  getById(t) {
+    return this.idMap.get(t);
+  }
+  entries() {
+    return this.idMap.entries();
+  }
+  get size() {
+    return this.idMap.size;
+  }
+}
+function Pn(n = []) {
+  const t = n.map((c) => c?.reference), e = n.map((c) => c?.floating), r = n.map((c) => c?.item), o = n.map((c) => c?.trigger), s = v.useCallback(
+    (c) => ne(c, n, "reference"),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    t
+  ), a = v.useCallback(
+    (c) => ne(c, n, "floating"),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    e
+  ), u = v.useCallback(
+    (c) => ne(c, n, "item"),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    r
+  ), h = v.useCallback(
+    (c) => ne(c, n, "trigger"),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    o
+  );
+  return v.useMemo(() => ({
+    getReferenceProps: s,
+    getFloatingProps: a,
+    getItemProps: u,
+    getTriggerProps: h
+  }), [s, a, u, h]);
+}
+function ne(n, t, e) {
+  const r = /* @__PURE__ */ new Map(), o = e === "item", s = {};
+  e === "floating" && (s.tabIndex = -1, s[Ct] = "");
+  for (const a in n)
+    o && n && (a === Be || a === Ge) || (s[a] = n[a]);
+  for (let a = 0; a < t.length; a += 1) {
+    let u;
+    const h = t[a]?.[e];
+    typeof h == "function" ? u = n ? h(n) : null : u = h, u && He(s, u, o, r);
+  }
+  return He(s, n, o, r), s;
+}
+function He(n, t, e, r) {
+  for (const o in t) {
+    const s = t[o];
+    e && (o === Be || o === Ge) || (o.startsWith("on") ? (r.has(o) || r.set(o, []), typeof s == "function" && (r.get(o)?.push(s), n[o] = (...a) => r.get(o)?.map((u) => u(...a)).find((u) => u !== void 0))) : n[o] = s);
+  }
+}
+let _e = (function(n) {
+  return n.open = "data-open", n.closed = "data-closed", n[n.startingStyle = xe.startingStyle] = "startingStyle", n[n.endingStyle = xe.endingStyle] = "endingStyle", n.anchorHidden = "data-anchor-hidden", n;
+})({}), ye = /* @__PURE__ */ (function(n) {
+  return n.popupOpen = "data-popup-open", n.pressed = "data-pressed", n;
+})({});
+const an = {
+  [ye.popupOpen]: ""
+}, ln = {
+  [ye.popupOpen]: "",
+  [ye.pressed]: ""
+}, fn = {
+  [_e.open]: ""
+}, dn = {
+  [_e.closed]: ""
+}, pn = {
+  [_e.anchorHidden]: ""
+}, jn = {
+  open(n) {
+    return n ? an : null;
+  }
+}, Kn = {
+  open(n) {
+    return n ? ln : null;
+  }
+}, Fn = {
+  open(n) {
+    return n ? fn : dn;
+  },
+  anchorHidden(n) {
+    return n ? pn : null;
+  }
+}, hn = "_transition_opacity_18csa_1", mn = "_transition_scale_18csa_19", Wn = {
+  transition_opacity: hn,
+  "transition_fade-out": "_transition_fade-out_18csa_11",
+  transition_scale: mn
+};
+export {
+  _e as C,
+  kn as F,
+  An as P,
+  cn as R,
+  Y as S,
+  Ye as a,
+  Mn as b,
+  $ as c,
+  Nn as d,
+  Pn as e,
+  jn as f,
+  re as g,
+  Vn as h,
+  Kn as i,
+  Dn as j,
+  xn as k,
+  rn as l,
+  wt as m,
+  Fn as p,
+  Wn as t,
+  qe as u
+};