@px-ui/core 1.23.0 → 1.24.0

package/dist/node_modules/.pnpm/@base-ui-components_react@1.0.0-beta.4_@types_react@19.2.0_react-dom@19.2.0_react@19.2.0/node_modules/@base-ui-components/react/esm/utils/useScrollLock.js

@@ -0,0 +1,123 @@
+var U = Object.defineProperty;
+var E = (r, e, t) => e in r ? U(r, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : r[e] = t;
+var i = (r, e, t) => E(r, typeof e != "symbol" ? e + "" : e, t);
+import { isWebKit as W, isIOS as F } from "../../../../../../@base-ui-components_utils@0.1.2_@types_react@19.2.0_react-dom@19.2.0_react@19.2.0/node_modules/@base-ui-components/utils/esm/detectBrowser.js";
+import { ownerDocument as a } from "../../../../../../@base-ui-components_utils@0.1.2_@types_react@19.2.0_react-dom@19.2.0_react@19.2.0/node_modules/@base-ui-components/utils/esm/owner.js";
+import { useIsoLayoutEffect as C } from "../../../../../../@base-ui-components_utils@0.1.2_@types_react@19.2.0_react-dom@19.2.0_react@19.2.0/node_modules/@base-ui-components/utils/esm/useIsoLayoutEffect.js";
+import { Timeout as L } from "../../../../../../@base-ui-components_utils@0.1.2_@types_react@19.2.0_react-dom@19.2.0_react@19.2.0/node_modules/@base-ui-components/utils/esm/useTimeout.js";
+import { AnimationFrame as T } from "../../../../../../@base-ui-components_utils@0.1.2_@types_react@19.2.0_react-dom@19.2.0_react@19.2.0/node_modules/@base-ui-components/utils/esm/useAnimationFrame.js";
+import { getWindow as d } from "../../../../../../@floating-ui_utils@0.2.10/node_modules/@floating-ui/utils/dist/floating-ui.utils.dom.js";
+import { NOOP as j } from "../../../../../../@base-ui-components_utils@0.1.2_@types_react@19.2.0_react-dom@19.2.0_react@19.2.0/node_modules/@base-ui-components/utils/esm/empty.js";
+let O = {}, Y = {}, B = "";
+function G(r) {
+  if (typeof document > "u")
+    return !1;
+  const e = a(r);
+  return d(e).innerWidth - e.documentElement.clientWidth > 0;
+}
+function R(r) {
+  const t = a(r).documentElement, o = t.style.overflow;
+  return t.style.overflow = "hidden", () => {
+    t.style.overflow = o;
+  };
+}
+function q(r) {
+  var y;
+  const e = a(r), t = e.documentElement, o = e.body, l = d(t);
+  let s = 0, c = 0;
+  const u = T.create();
+  if (W && (((y = l.visualViewport) == null ? void 0 : y.scale) ?? 1) !== 1)
+    return () => {
+    };
+  function h() {
+    var k;
+    const v = l.getComputedStyle(t), n = l.getComputedStyle(o);
+    s = t.scrollTop, c = t.scrollLeft, O = {
+      scrollbarGutter: t.style.scrollbarGutter,
+      overflowY: t.style.overflowY,
+      overflowX: t.style.overflowX
+    }, B = t.style.scrollBehavior, Y = {
+      position: o.style.position,
+      height: o.style.height,
+      width: o.style.width,
+      boxSizing: o.style.boxSizing,
+      overflowY: o.style.overflowY,
+      overflowX: o.style.overflowX,
+      scrollBehavior: o.style.scrollBehavior
+    };
+    const b = typeof CSS < "u" && ((k = CSS.supports) == null ? void 0 : k.call(CSS, "scrollbar-gutter", "stable")), X = t.scrollHeight > t.clientHeight, x = t.scrollWidth > t.clientWidth, H = v.overflowY === "scroll" || n.overflowY === "scroll", z = v.overflowX === "scroll" || n.overflowX === "scroll", w = Math.max(0, l.innerWidth - t.clientWidth), p = Math.max(0, l.innerHeight - t.clientHeight), S = parseFloat(n.marginTop) + parseFloat(n.marginBottom), g = parseFloat(n.marginLeft) + parseFloat(n.marginRight);
+    Object.assign(t.style, {
+      scrollbarGutter: "stable",
+      overflowY: !b && (X || H) ? "scroll" : "hidden",
+      overflowX: !b && (x || z) ? "scroll" : "hidden"
+    }), Object.assign(o.style, {
+      position: "relative",
+      height: S || p ? `calc(100dvh - ${S + p}px)` : "100dvh",
+      width: g || w ? `calc(100vw - ${g + w}px)` : "100vw",
+      boxSizing: "border-box",
+      overflow: "hidden",
+      scrollBehavior: "unset"
+    }), o.scrollTop = s, o.scrollLeft = c, t.setAttribute("data-base-ui-scroll-locked", ""), t.style.scrollBehavior = "unset";
+  }
+  function f() {
+    Object.assign(t.style, O), Object.assign(o.style, Y), t.scrollTop = s, t.scrollLeft = c, t.removeAttribute("data-base-ui-scroll-locked"), t.style.scrollBehavior = B;
+  }
+  function m() {
+    f(), u.request(h);
+  }
+  return h(), l.addEventListener("resize", m), () => {
+    u.cancel(), f(), l.removeEventListener("resize", m);
+  };
+}
+class A {
+  constructor() {
+    i(this, "lockCount", 0);
+    i(this, "restore", null);
+    i(this, "timeoutLock", L.create());
+    i(this, "timeoutUnlock", L.create());
+    i(this, "release", () => {
+      this.lockCount -= 1, this.lockCount === 0 && this.restore && this.timeoutUnlock.start(0, this.unlock);
+    });
+    i(this, "unlock", () => {
+      var e;
+      this.lockCount === 0 && this.restore && ((e = this.restore) == null || e.call(this), this.restore = null);
+    });
+  }
+  acquire(e) {
+    return this.lockCount += 1, this.lockCount === 1 && this.restore === null && this.timeoutLock.start(0, () => this.lock(e)), this.release;
+  }
+  lock(e) {
+    if (this.lockCount === 0 || this.restore !== null)
+      return;
+    const o = a(e).documentElement, l = d(o).getComputedStyle(o).overflowY;
+    if (l === "hidden" || l === "clip") {
+      this.restore = j;
+      return;
+    }
+    const s = F || !G(e);
+    this.restore = s ? R(e) : q(e);
+  }
+}
+const I = new A();
+function J(r) {
+  const {
+    enabled: e = !0,
+    mounted: t,
+    open: o,
+    referenceElement: l = null
+  } = r;
+  C(() => {
+    if (e && W && t && !o) {
+      const s = a(l), c = s.body.style.userSelect, u = s.body.style.webkitUserSelect;
+      return s.body.style.userSelect = "none", s.body.style.webkitUserSelect = "none", () => {
+        s.body.style.userSelect = c, s.body.style.webkitUserSelect = u;
+      };
+    }
+  }, [e, t, o, l]), C(() => {
+    if (e)
+      return I.acquire(l);
+  }, [e, l]);
+}
+export {
+  J as useScrollLock
+};

package/dist/node_modules/.pnpm/@base-ui-components_react@1.0.0-beta.4_@types_react@19.2.0_react-dom@19.2.0_react@19.2.0/node_modules/@base-ui-components/react/esm/utils/useTransitionStatus.js

@@ -0,0 +1,45 @@
+import * as c from "react";
+import * as d from "react-dom";
+import { useIsoLayoutEffect as a } from "../../../../../../@base-ui-components_utils@0.1.2_@types_react@19.2.0_react-dom@19.2.0_react@19.2.0/node_modules/@base-ui-components/utils/esm/useIsoLayoutEffect.js";
+import { AnimationFrame as u } from "../../../../../../@base-ui-components_utils@0.1.2_@types_react@19.2.0_react-dom@19.2.0_react@19.2.0/node_modules/@base-ui-components/utils/esm/useAnimationFrame.js";
+function q(t, s = !1, f = !1) {
+  const [r, n] = c.useState(t && s ? "idle" : void 0), [i, m] = c.useState(t);
+  return t && !i && (m(!0), n("starting")), !t && i && r !== "ending" && !f && n("ending"), !t && !i && r === "ending" && n(void 0), a(() => {
+    if (!t && i && r !== "ending" && f) {
+      const e = u.request(() => {
+        n("ending");
+      });
+      return () => {
+        u.cancel(e);
+      };
+    }
+  }, [t, i, r, f]), a(() => {
+    if (!t || s)
+      return;
+    const e = u.request(() => {
+      d.flushSync(() => {
+        n(void 0);
+      });
+    });
+    return () => {
+      u.cancel(e);
+    };
+  }, [s, t]), a(() => {
+    if (!t || !s)
+      return;
+    t && i && r !== "idle" && n("starting");
+    const e = u.request(() => {
+      n("idle");
+    });
+    return () => {
+      u.cancel(e);
+    };
+  }, [s, t, i, n, r]), c.useMemo(() => ({
+    mounted: i,
+    setMounted: m,
+    transitionStatus: r
+  }), [i, r]);
+}
+export {
+  q as useTransitionStatus
+};

package/dist/node_modules/.pnpm/@base-ui-components_utils@0.1.2_@types_react@19.2.0_react-dom@19.2.0_react@19.2.0/node_modules/@base-ui-components/utils/esm/detectBrowser.js

@@ -0,0 +1,42 @@
+const o = typeof navigator < "u", a = e(), n = u(), r = f(), c = typeof CSS > "u" || !CSS.supports ? !1 : CSS.supports("-webkit-backdrop-filter:none"), m = (
+  // iPads can claim to be MacIntel
+  a.platform === "MacIntel" && a.maxTouchPoints > 1 ? !0 : /iP(hone|ad|od)|iOS/.test(a.platform)
+), p = o && /apple/i.test(navigator.vendor), g = o && /android/i.test(n) || /android/i.test(r), d = o && n.toLowerCase().startsWith("mac") && !navigator.maxTouchPoints, l = r.includes("jsdom/");
+function e() {
+  if (!o)
+    return {
+      platform: "",
+      maxTouchPoints: -1
+    };
+  const t = navigator.userAgentData;
+  return t != null && t.platform ? {
+    platform: t.platform,
+    maxTouchPoints: navigator.maxTouchPoints
+  } : {
+    platform: navigator.platform ?? "",
+    maxTouchPoints: navigator.maxTouchPoints ?? -1
+  };
+}
+function f() {
+  if (!o)
+    return "";
+  const t = navigator.userAgentData;
+  return t && Array.isArray(t.brands) ? t.brands.map(({
+    brand: i,
+    version: s
+  }) => `${i}/${s}`).join(" ") : navigator.userAgent;
+}
+function u() {
+  if (!o)
+    return "";
+  const t = navigator.userAgentData;
+  return t != null && t.platform ? t.platform : navigator.platform ?? "";
+}
+export {
+  g as isAndroid,
+  m as isIOS,
+  l as isJSDOM,
+  d as isMac,
+  p as isSafari,
+  c as isWebKit
+};

package/dist/node_modules/.pnpm/@base-ui-components_utils@0.1.2_@types_react@19.2.0_react-dom@19.2.0_react@19.2.0/node_modules/@base-ui-components/utils/esm/empty.js

@@ -0,0 +1,8 @@
+function e() {
+}
+const t = Object.freeze([]), c = Object.freeze({});
+export {
+  t as EMPTY_ARRAY,
+  c as EMPTY_OBJECT,
+  e as NOOP
+};

package/dist/node_modules/.pnpm/@base-ui-components_utils@0.1.2_@types_react@19.2.0_react-dom@19.2.0_react@19.2.0/node_modules/@base-ui-components/utils/esm/error.js

@@ -0,0 +1,11 @@
+let o;
+process.env.NODE_ENV !== "production" && (o = /* @__PURE__ */ new Set());
+function s(...r) {
+  if (process.env.NODE_ENV !== "production") {
+    const e = r.join(" ");
+    o.has(e) || (o.add(e), console.error(`Base UI: ${e}`));
+  }
+}
+export {
+  s as error
+};

package/dist/node_modules/.pnpm/@base-ui-components_utils@0.1.2_@types_react@19.2.0_react-dom@19.2.0_react@19.2.0/node_modules/@base-ui-components/utils/esm/generateId.js

@@ -0,0 +1,7 @@
+let t = 0;
+function n(e) {
+  return t += 1, `${e}-${Math.random().toString(36).slice(2, 6)}-${t}`;
+}
+export {
+  n as generateId
+};

package/dist/node_modules/.pnpm/@base-ui-components_utils@0.1.2_@types_react@19.2.0_react-dom@19.2.0_react@19.2.0/node_modules/@base-ui-components/utils/esm/inertValue.js

@@ -0,0 +1,7 @@
+import { isReactVersionAtLeast as r } from "./reactVersion.js";
+function n(e) {
+  return r(19) ? e : e ? "true" : void 0;
+}
+export {
+  n as inertValue
+};

package/dist/node_modules/.pnpm/@base-ui-components_utils@0.1.2_@types_react@19.2.0_react-dom@19.2.0_react@19.2.0/node_modules/@base-ui-components/utils/esm/isElementDisabled.js

@@ -0,0 +1,6 @@
+function i(t) {
+  return t == null || t.hasAttribute("disabled") || t.getAttribute("aria-disabled") === "true";
+}
+export {
+  i as isElementDisabled
+};

package/dist/node_modules/.pnpm/@base-ui-components_utils@0.1.2_@types_react@19.2.0_react-dom@19.2.0_react@19.2.0/node_modules/@base-ui-components/utils/esm/isMouseWithinBounds.js

@@ -0,0 +1,7 @@
+function o(t) {
+  const i = t.currentTarget.getBoundingClientRect();
+  return i.top + 1 <= t.clientY && t.clientY <= i.bottom - 1 && i.left + 1 <= t.clientX && t.clientX <= i.right - 1;
+}
+export {
+  o as isMouseWithinBounds
+};

package/dist/node_modules/.pnpm/@base-ui-components_utils@0.1.2_@types_react@19.2.0_react-dom@19.2.0_react@19.2.0/node_modules/@base-ui-components/utils/esm/mergeObjects.js

@@ -0,0 +1,14 @@
+function n(e, r) {
+  if (e && !r)
+    return e;
+  if (!e && r)
+    return r;
+  if (e || r)
+    return {
+      ...e,
+      ...r
+    };
+}
+export {
+  n as mergeObjects
+};

package/dist/node_modules/.pnpm/@base-ui-components_utils@0.1.2_@types_react@19.2.0_react-dom@19.2.0_react@19.2.0/node_modules/@base-ui-components/utils/esm/owner.js

@@ -0,0 +1,6 @@
+function r(t) {
+  return (t == null ? void 0 : t.ownerDocument) || document;
+}
+export {
+  r as ownerDocument
+};

package/dist/node_modules/.pnpm/@base-ui-components_utils@0.1.2_@types_react@19.2.0_react-dom@19.2.0_react@19.2.0/node_modules/@base-ui-components/utils/esm/reactVersion.js

@@ -0,0 +1,8 @@
+import * as t from "react";
+const e = parseInt(t.version, 10);
+function o(r) {
+  return e >= r;
+}
+export {
+  o as isReactVersionAtLeast
+};

package/dist/node_modules/.pnpm/@base-ui-components_utils@0.1.2_@types_react@19.2.0_react-dom@19.2.0_react@19.2.0/node_modules/@base-ui-components/utils/esm/safeReact.js

@@ -0,0 +1,7 @@
+import * as t from "react";
+const a = {
+  ...t
+};
+export {
+  a as SafeReact
+};

package/dist/node_modules/.pnpm/@base-ui-components_utils@0.1.2_@types_react@19.2.0_react-dom@19.2.0_react@19.2.0/node_modules/@base-ui-components/utils/esm/store/ReactStore.js

@@ -0,0 +1,149 @@
+var c = Object.defineProperty;
+var a = (n, o, t) => o in n ? c(n, o, { enumerable: !0, configurable: !0, writable: !0, value: t }) : n[o] = t;
+var u = (n, o, t) => a(n, typeof o != "symbol" ? o + "" : o, t);
+import * as h from "react";
+import { Store as d } from "./Store.js";
+import { useStore as p } from "./useStore.js";
+import { useEventCallback as f } from "../useEventCallback.js";
+import { useIsoLayoutEffect as i } from "../useIsoLayoutEffect.js";
+import { NOOP as m } from "../empty.js";
+class w extends d {
+  constructor(t, e = {}, s) {
+    super(t);
+    /**
+     * Non-reactive values such as refs, callbacks, etc.
+     * Unlike `state`, this property can be accessed directly.
+     */
+    /**
+     * Keeps track of which properties are controlled.
+     */
+    u(this, "controlledValues", /* @__PURE__ */ new Map());
+    this.context = e, this.selectors = s;
+  }
+  /**
+   * Synchronizes a single external value into the store during layout phase.
+   */
+  useSyncedValue(t, e) {
+    i(() => {
+      this.state[t] !== e && this.set(t, e);
+    }, [t, e]);
+  }
+  /**
+   * Synchronizes a single external value into the store during layout phase and
+   * cleans it up (sets to `undefined`) on unmount.
+   */
+  useSyncedValueWithCleanup(t, e) {
+    i(() => (this.state[t] !== e && this.set(t, e), () => {
+      this.set(t, void 0);
+    }), [t, e]);
+  }
+  /**
+   * Synchronizes multiple external values into the store during layout phase.
+   */
+  useSyncedValues(t) {
+    i(() => {
+      this.apply(t);
+    }, [t]);
+  }
+  /**
+   * 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, s) {
+    const r = e !== void 0;
+    if (process.env.NODE_ENV !== "production") {
+      const l = this.controlledValues.get(t);
+      l !== void 0 && l !== r && console.error(`A component is changing the ${r ? "" : "un"}controlled state of ${t.toString()} to be ${r ? "un" : ""}controlled. Elements should not switch from uncontrolled to controlled (or vice versa).`);
+    }
+    this.controlledValues.has(t) || (this.controlledValues.set(t, r), !r && !Object.is(this.state[t], s) && super.update({
+      ...this.state,
+      [t]: s
+    })), i(() => {
+      r && !Object.is(this.state[t], e) && super.update({
+        ...this.state,
+        [t]: e
+      });
+    }, [t, e, s, r]);
+  }
+  /**
+   * 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.
+   */
+  apply(t) {
+    const e = {
+      ...t
+    };
+    for (const s in e)
+      this.controlledValues.get(s) === !0 && delete e[s];
+    super.apply(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.
+   */
+  update(t) {
+    const e = {
+      ...t
+    };
+    for (const s in e)
+      this.controlledValues.get(s) === !0 && delete e[s];
+    super.update({
+      ...this.state,
+      ...e
+    });
+  }
+  /**
+   * 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) {
+    if (!this.selectors)
+      throw new Error("Base UI: selectors are required to call useState.");
+    return p(this, this.selectors[t]);
+  }
+  /**
+   * Wraps a function with `useEventCallback` 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) {
+    const s = f(e ?? m);
+    this.context[t] = s;
+  }
+  /**
+   * 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.
+   */
+  getElementSetter(t) {
+    return h.useCallback((e) => {
+      this.set(t, e);
+    }, [t]);
+  }
+}
+export {
+  w as ReactStore
+};

package/dist/node_modules/.pnpm/@base-ui-components_utils@0.1.2_@types_react@19.2.0_react-dom@19.2.0_react@19.2.0/node_modules/@base-ui-components/utils/esm/store/Store.js

@@ -0,0 +1,67 @@
+var r = Object.defineProperty;
+var h = (e, t, s) => t in e ? r(e, t, { enumerable: !0, configurable: !0, writable: !0, value: s }) : e[t] = s;
+var i = (e, t, s) => h(e, typeof t != "symbol" ? t + "" : t, s);
+class o {
+  /**
+   * The current state of the store.
+   * This property is updated immediately when the state changes as a result of calling {@link update}, {@link apply}, 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.
+   */
+  constructor(t) {
+    /**
+     * 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.
+     */
+    i(this, "subscribe", (t) => (this.listeners.add(t), () => {
+      this.listeners.delete(t);
+    }));
+    /**
+     * Returns the current state of the store.
+     */
+    i(this, "getSnapshot", () => this.state);
+    this.state = t, this.listeners = /* @__PURE__ */ new Set();
+  }
+  /**
+   * Updates the entire store's state and notifies all registered listeners.
+   *
+   * @param newState The new state to set for the store.
+   */
+  update(t) {
+    this.state !== t && (this.state = t, this.listeners.forEach((s) => s(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.
+   */
+  apply(t) {
+    for (const s in t)
+      if (!Object.is(this.state[s], t[s])) {
+        this.update({
+          ...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, s) {
+    Object.is(this.state[t], s) || this.update({
+      ...this.state,
+      [t]: s
+    });
+  }
+}
+export {
+  o as Store
+};

package/dist/node_modules/.pnpm/@base-ui-components_utils@0.1.2_@types_react@19.2.0_react-dom@19.2.0_react@19.2.0/node_modules/@base-ui-components/utils/esm/store/createSelector.js

@@ -0,0 +1,21 @@
+import { createSelectorCreator as o, lruMemoize as i } from "../../../../../../reselect@5.1.1/node_modules/reselect/dist/reselect.js";
+o({
+  memoize: i,
+  memoizeOptions: {
+    maxSize: 1,
+    equalityCheck: Object.is
+  }
+});
+const a = (e, s, c, m, n, l, ...t) => {
+  if (t.length > 0)
+    throw new Error("Unsupported number of selectors");
+  let r;
+  if (e)
+    r = e;
+  else
+    throw new Error("Missing arguments");
+  return r;
+};
+export {
+  a as createSelector
+};

package/dist/node_modules/.pnpm/@base-ui-components_utils@0.1.2_@types_react@19.2.0_react-dom@19.2.0_react@19.2.0/node_modules/@base-ui-components/utils/esm/store/useStore.js

@@ -0,0 +1,8 @@
+import { w as S } from "../../../../../../../../_virtual/with-selector.js";
+function h(t, e, r, o, s) {
+  const n = (c) => e(c, r, o, s);
+  return S.useSyncExternalStoreWithSelector(t.subscribe, t.getSnapshot, t.getSnapshot, n);
+}
+export {
+  h as useStore
+};

package/dist/node_modules/.pnpm/@base-ui-components_utils@0.1.2_@types_react@19.2.0_react-dom@19.2.0_react@19.2.0/node_modules/@base-ui-components/utils/esm/useAnimationFrame.js

@@ -0,0 +1,76 @@
+var o = Object.defineProperty;
+var d = (c, t, e) => t in c ? o(c, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : c[t] = e;
+var s = (c, t, e) => d(c, typeof t != "symbol" ? t + "" : t, e);
+import { useRefWithInit as f } from "./useRefWithInit.js";
+import { useOnMount as m } from "./useOnMount.js";
+const n = null;
+let h = globalThis.requestAnimationFrame;
+class I {
+  constructor() {
+    /* This implementation uses an array as a backing data-structure for frame callbacks.
+     * It allows `O(1)` callback cancelling by inserting a `null` in the array, though it
+     * never calls the native `cancelAnimationFrame` if there are no frames left. This can
+     * be much more efficient if there is a call pattern that alterns as
+     * "request-cancel-request-cancel-…".
+     * But in the case of "request-request-…-cancel-cancel-…", it leaves the final animation
+     * frame to run anyway. We turn that frame into a `O(1)` no-op via `callbacksCount`. */
+    s(this, "callbacks", []);
+    s(this, "callbacksCount", 0);
+    s(this, "nextId", 1);
+    s(this, "startId", 1);
+    s(this, "isScheduled", !1);
+    s(this, "tick", (t) => {
+      var u;
+      this.isScheduled = !1;
+      const e = this.callbacks, r = this.callbacksCount;
+      if (this.callbacks = [], this.callbacksCount = 0, this.startId = this.nextId, r > 0)
+        for (let a = 0; a < e.length; a += 1)
+          (u = e[a]) == null || u.call(e, t);
+    });
+  }
+  request(t) {
+    const e = this.nextId;
+    this.nextId += 1, this.callbacks.push(t), this.callbacksCount += 1;
+    const r = process.env.NODE_ENV === "test" && h !== requestAnimationFrame && (h = requestAnimationFrame, !0);
+    return (!this.isScheduled || r) && (requestAnimationFrame(this.tick), this.isScheduled = !0), e;
+  }
+  cancel(t) {
+    const e = t - this.startId;
+    e < 0 || e >= this.callbacks.length || (this.callbacks[e] = null, this.callbacksCount -= 1);
+  }
+}
+const i = new I();
+class l {
+  constructor() {
+    s(this, "currentId", n);
+    s(this, "cancel", () => {
+      this.currentId !== n && (i.cancel(this.currentId), this.currentId = n);
+    });
+    s(this, "disposeEffect", () => this.cancel);
+  }
+  static create() {
+    return new l();
+  }
+  static request(t) {
+    return i.request(t);
+  }
+  static cancel(t) {
+    return i.cancel(t);
+  }
+  /**
+   * Executes `fn` after `delay`, clearing any previously scheduled call.
+   */
+  request(t) {
+    this.cancel(), this.currentId = i.request(() => {
+      this.currentId = n, t();
+    });
+  }
+}
+function A() {
+  const c = f(l.create).current;
+  return m(c.disposeEffect), c;
+}
+export {
+  l as AnimationFrame,
+  A as useAnimationFrame
+};

package/dist/node_modules/.pnpm/@base-ui-components_utils@0.1.2_@types_react@19.2.0_react-dom@19.2.0_react@19.2.0/node_modules/@base-ui-components/utils/esm/useControlled.js

@@ -0,0 +1,31 @@
+import * as n from "react";
+function d({
+  controlled: o,
+  default: s,
+  name: t,
+  state: i = "value"
+}) {
+  const {
+    current: e
+  } = n.useRef(o !== void 0), [l, c] = n.useState(s), u = e ? o : l;
+  if (process.env.NODE_ENV !== "production") {
+    n.useEffect(() => {
+      e !== (o !== void 0) && console.error([`Base UI: A component is changing the ${e ? "" : "un"}controlled ${i} state of ${t} to be ${e ? "un" : ""}controlled.`, "Elements should not switch from uncontrolled to controlled (or vice versa).", `Decide between using a controlled or uncontrolled ${t} element for the lifetime of the component.`, "The nature of the state is determined during the first render. It's considered controlled if the value is not `undefined`.", "More info: https://fb.me/react-controlled-components"].join(`
+`));
+    }, [i, t, o]);
+    const {
+      current: r
+    } = n.useRef(s);
+    n.useEffect(() => {
+      !e && JSON.stringify(r) !== JSON.stringify(s) && console.error([`Base UI: A component is changing the default ${i} state of an uncontrolled ${t} after being initialized. To suppress this warning opt to use a controlled ${t}.`].join(`
+`));
+    }, [JSON.stringify(s)]);
+  }
+  const f = n.useCallback((r) => {
+    e || c(r);
+  }, []);
+  return [u, f];
+}
+export {
+  d as useControlled
+};