@pautena/react-design-system 2.0.0-alpha.1b → 2.0.0-alpha.5

package/dist/node_modules/@base-ui/utils/esm/store/ReactStore.mjs

@@ -0,0 +1,146 @@
+import * as u from "react";
+import { Store as l } from "./Store.mjs";
+import { useStore as a } from "./useStore.mjs";
+import { useStableCallback as f } from "../useStableCallback.mjs";
+import { useIsoLayoutEffect as c } from "../useIsoLayoutEffect.mjs";
+import { NOOP as h } from "../empty.mjs";
+class g extends l {
+  /**
+   * 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(e, t = {}, s) {
+    super(e), this.context = t, this.selectors = s;
+  }
+  /**
+   * Non-reactive values such as refs, callbacks, etc.
+   */
+  /**
+   * 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(e, t) {
+    u.useDebugValue(e), c(() => {
+      this.state[e] !== t && this.set(e, t);
+    }, [e, t]);
+  }
+  /**
+   * 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(e, t) {
+    const s = this;
+    c(() => (s.state[e] !== t && s.set(e, t), () => {
+      s.set(e, void 0);
+    }), [s, e, t]);
+  }
+  /**
+   * 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(e) {
+    const t = this;
+    if (process.env.NODE_ENV !== "production") {
+      u.useDebugValue(e, (r) => Object.keys(r));
+      const o = u.useRef(Object.keys(e)).current, n = Object.keys(e);
+      (o.length !== n.length || o.some((r, i) => r !== n[i])) && console.error("ReactStore.useSyncedValues expects the same prop keys on every render. Keys should be stable.");
+    }
+    const s = Object.values(e);
+    c(() => {
+      t.update(e);
+    }, [t, ...s]);
+  }
+  /**
+   * Registers a controllable prop pair (`controlled`, `defaultValue`) for a specific key. If `controlled`
+   * is non-undefined, the store's state at `key` is updated to match `controlled`.
+   */
+  useControlledProp(e, t) {
+    u.useDebugValue(e);
+    const s = t !== void 0;
+    if (c(() => {
+      s && !Object.is(this.state[e], t) && super.setState({
+        ...this.state,
+        [e]: t
+      });
+    }, [e, t, s]), process.env.NODE_ENV !== "production") {
+      const o = this.controlledValues ??= /* @__PURE__ */ new Map();
+      o.has(e) || o.set(e, s);
+      const n = o.get(e);
+      n !== void 0 && n !== s && console.error(`A component is changing the ${s ? "" : "un"}controlled state of ${e.toString()} to be ${s ? "un" : ""}controlled. Elements should not switch from uncontrolled to controlled (or vice versa).`);
+    }
+  }
+  /** Gets the current value from the store using a selector with the provided key.
+   *
+   * @param key Key of the selector to use.
+   */
+  select(e, t, s, o) {
+    const n = this.selectors[e];
+    return n(this.state, t, s, 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(e, t, s, o) {
+    return u.useDebugValue(e), a(this, this.selectors[e], t, s, 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(e, t) {
+    u.useDebugValue(e);
+    const s = f(t ?? h);
+    this.context[e] = 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.
+   */
+  useStateSetter(e) {
+    const t = u.useRef(void 0);
+    return t.current === void 0 && (t.current = (s) => {
+      this.set(e, s);
+    }), t.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(e, t) {
+    let s;
+    typeof e == "function" ? s = e : s = this.selectors[e];
+    let o = s(this.state);
+    return t(o, o, this), this.subscribe((n) => {
+      const r = s(n);
+      if (!Object.is(o, r)) {
+        const i = o;
+        o = r, t(r, i, this);
+      }
+    });
+  }
+}
+export {
+  g as ReactStore
+};
+//# sourceMappingURL=ReactStore.mjs.map

package/dist/node_modules/@base-ui/utils/esm/store/ReactStore.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ReactStore.mjs","sources":["../../../../../../node_modules/@base-ui/utils/esm/store/ReactStore.js"],"sourcesContent":["/* False positives - ESLint thinks we're calling a hook from a class component. */\n/* eslint-disable react-hooks/rules-of-hooks */\n'use client';\n\nimport * as React from 'react';\nimport { Store } from \"./Store.js\";\nimport { useStore } from \"./useStore.js\";\nimport { useStableCallback } from \"../useStableCallback.js\";\nimport { useIsoLayoutEffect } from \"../useIsoLayoutEffect.js\";\nimport { NOOP } from \"../empty.js\";\n\n/**\n * A Store that supports controlled state keys, non-reactive values and provides utility methods for React.\n */\nexport class ReactStore extends Store {\n  /**\n   * Creates a new ReactStore instance.\n   *\n   * @param state Initial state of the store.\n   * @param context Non-reactive context values.\n   * @param selectors Optional selectors for use with `useState`.\n   */\n  constructor(state, context = {}, selectors) {\n    super(state);\n    this.context = context;\n    this.selectors = selectors;\n  }\n\n  /**\n   * Non-reactive values such as refs, callbacks, etc.\n   */\n\n  /**\n   * Synchronizes a single external value into the store.\n   *\n   * Note that the while the value in `state` is updated immediately, the value returned\n   * by `useState` is updated before the next render (similarly to React's `useState`).\n   */\n  useSyncedValue(key, value) {\n    React.useDebugValue(key);\n    useIsoLayoutEffect(() => {\n      if (this.state[key] !== value) {\n        this.set(key, value);\n      }\n    }, [key, value]);\n  }\n\n  /**\n   * Synchronizes a single external value into the store and\n   * cleans it up (sets to `undefined`) on unmount.\n   *\n   * Note that the while the value in `state` is updated immediately, the value returned\n   * by `useState` is updated before the next render (similarly to React's `useState`).\n   */\n  useSyncedValueWithCleanup(key, value) {\n    // eslint-disable-next-line consistent-this\n    const store = this;\n    useIsoLayoutEffect(() => {\n      if (store.state[key] !== value) {\n        store.set(key, value);\n      }\n      return () => {\n        store.set(key, undefined);\n      };\n    }, [store, key, value]);\n  }\n\n  /**\n   * Synchronizes multiple external values into the store.\n   *\n   * Note that the while the values in `state` are updated immediately, the values returned\n   * by `useState` are updated before the next render (similarly to React's `useState`).\n   */\n  useSyncedValues(statePart) {\n    // eslint-disable-next-line consistent-this\n    const store = this;\n    if (process.env.NODE_ENV !== 'production') {\n      // Check that an object with the same shape is passed on every render\n      React.useDebugValue(statePart, p => Object.keys(p));\n      const keys = React.useRef(Object.keys(statePart)).current;\n      const nextKeys = Object.keys(statePart);\n      if (keys.length !== nextKeys.length || keys.some((key, index) => key !== nextKeys[index])) {\n        console.error('ReactStore.useSyncedValues expects the same prop keys on every render. Keys should be stable.');\n      }\n    }\n    const dependencies = Object.values(statePart);\n    useIsoLayoutEffect(() => {\n      store.update(statePart);\n      // eslint-disable-next-line react-hooks/exhaustive-deps\n    }, [store, ...dependencies]);\n  }\n\n  /**\n   * Registers a controllable prop pair (`controlled`, `defaultValue`) for a specific key. If `controlled`\n   * is non-undefined, the store's state at `key` is updated to match `controlled`.\n   */\n  useControlledProp(key, controlled) {\n    React.useDebugValue(key);\n    const isControlled = controlled !== undefined;\n    useIsoLayoutEffect(() => {\n      if (isControlled && !Object.is(this.state[key], controlled)) {\n        // Set the internal state to match the controlled value.\n        super.setState({\n          ...this.state,\n          [key]: controlled\n        });\n      }\n    }, [key, controlled, isControlled]);\n    if (process.env.NODE_ENV !== 'production') {\n      // eslint-disable-next-line\n      const cache = this.controlledValues ??= new Map();\n      if (!cache.has(key)) {\n        cache.set(key, isControlled);\n      }\n      const previouslyControlled = cache.get(key);\n      if (previouslyControlled !== undefined && previouslyControlled !== isControlled) {\n        console.error(`A component is changing the ${isControlled ? '' : 'un'}controlled state of ${key.toString()} to be ${isControlled ? 'un' : ''}controlled. Elements should not switch from uncontrolled to controlled (or vice versa).`);\n      }\n    }\n  }\n\n  /** Gets the current value from the store using a selector with the provided key.\n   *\n   * @param key Key of the selector to use.\n   */\n\n  select(key, a1, a2, a3) {\n    const selector = this.selectors[key];\n    return selector(this.state, a1, a2, a3);\n  }\n\n  /**\n   * Returns a value from the store's state using a selector function.\n   * Used to subscribe to specific parts of the state.\n   * This methods causes a rerender whenever the selected state changes.\n   *\n   * @param key Key of the selector to use.\n   */\n\n  useState(key, a1, a2, a3) {\n    React.useDebugValue(key);\n    return useStore(this, this.selectors[key], a1, a2, a3);\n  }\n\n  /**\n   * Wraps a function with `useStableCallback` to ensure it has a stable reference\n   * and assigns it to the context.\n   *\n   * @param key Key of the event callback. Must be a function in the context.\n   * @param fn Function to assign.\n   */\n  useContextCallback(key, fn) {\n    React.useDebugValue(key);\n    const stableFunction = useStableCallback(fn ?? NOOP);\n    this.context[key] = stableFunction;\n  }\n\n  /**\n   * Returns a stable setter function for a specific key in the store's state.\n   * It's commonly used to pass as a ref callback to React elements.\n   *\n   * @param key Key of the state to set.\n   */\n  useStateSetter(key) {\n    const ref = React.useRef(undefined);\n    if (ref.current === undefined) {\n      ref.current = value => {\n        this.set(key, value);\n      };\n    }\n    return ref.current;\n  }\n\n  /**\n   * Observes changes derived from the store's selectors and calls the listener when the selected value changes.\n   *\n   * @param key Key of the selector to observe.\n   * @param listener Listener function called when the selector result changes.\n   */\n\n  observe(selector, listener) {\n    let selectFn;\n    if (typeof selector === 'function') {\n      selectFn = selector;\n    } else {\n      selectFn = this.selectors[selector];\n    }\n    let prevValue = selectFn(this.state);\n    listener(prevValue, prevValue, this);\n    return this.subscribe(nextState => {\n      const nextValue = selectFn(nextState);\n      if (!Object.is(prevValue, nextValue)) {\n        const oldValue = prevValue;\n        prevValue = nextValue;\n        listener(nextValue, oldValue, this);\n      }\n    });\n  }\n}"],"names":["ReactStore","Store","state","context","selectors","key","value","React","useIsoLayoutEffect","store","statePart","p","keys","nextKeys","index","dependencies","controlled","isControlled","cache","previouslyControlled","a1","a2","a3","selector","useStore","fn","stableFunction","useStableCallback","NOOP","ref","listener","selectFn","prevValue","nextState","nextValue","oldValue"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/node_modules/@base-ui/utils/esm/store/Store.mjs

@@ -0,0 +1,87 @@
+import { useStore as r } from "./useStore.mjs";
+class n {
+  /**
+   * 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 s = this.updateTick;
+    for (const e of this.listeners) {
+      if (s !== this.updateTick)
+        return;
+      e(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 s in t)
+      if (!Object.is(this.state[s], t[s])) {
+        this.setState({
+          ...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.setState({
+      ...this.state,
+      [t]: s
+    });
+  }
+  /**
+   * Gives the state a new reference and updates all registered listeners.
+   */
+  notifyAll() {
+    const t = {
+      ...this.state
+    };
+    this.setState(t);
+  }
+  use(t, s, e, i) {
+    return r(this, t, s, e, i);
+  }
+}
+export {
+  n as Store
+};
+//# sourceMappingURL=Store.mjs.map

package/dist/node_modules/@base-ui/utils/esm/store/Store.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Store.mjs","sources":["../../../../../../node_modules/@base-ui/utils/esm/store/Store.js"],"sourcesContent":["import { useStore } from \"./useStore.js\";\n/**\n * A data store implementation that allows subscribing to state changes and updating the state.\n * It uses an observer pattern to notify subscribers when the state changes.\n */\nexport class Store {\n  /**\n   * The current state of the store.\n   * This property is updated immediately when the state changes as a result of calling {@link setState}, {@link update}, or {@link set}.\n   * 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).\n   * The values can be used directly (to avoid subscribing to the store) in effects or event handlers.\n   *\n   * Do not modify properties in state directly. Instead, use the provided methods to ensure proper state management and listener notification.\n   */\n\n  // Internal state to handle recursive `setState()` calls\n\n  constructor(state) {\n    this.state = state;\n    this.listeners = new Set();\n    this.updateTick = 0;\n  }\n\n  /**\n   * Registers a listener that will be called whenever the store's state changes.\n   *\n   * @param fn The listener function to be called on state changes.\n   * @returns A function to unsubscribe the listener.\n   */\n  subscribe = fn => {\n    this.listeners.add(fn);\n    return () => {\n      this.listeners.delete(fn);\n    };\n  };\n\n  /**\n   * Returns the current state of the store.\n   */\n  getSnapshot = () => {\n    return this.state;\n  };\n\n  /**\n   * Updates the entire store's state and notifies all registered listeners.\n   *\n   * @param newState The new state to set for the store.\n   */\n  setState(newState) {\n    if (this.state === newState) {\n      return;\n    }\n    this.state = newState;\n    this.updateTick += 1;\n    const currentTick = this.updateTick;\n    for (const listener of this.listeners) {\n      if (currentTick !== this.updateTick) {\n        // If the tick has changed, a recursive `setState` call has been made,\n        // and it has already notified all listeners.\n        return;\n      }\n      listener(newState);\n    }\n  }\n\n  /**\n   * Merges the provided changes into the current state and notifies listeners if there are changes.\n   *\n   * @param changes An object containing the changes to apply to the current state.\n   */\n  update(changes) {\n    for (const key in changes) {\n      if (!Object.is(this.state[key], changes[key])) {\n        this.setState({\n          ...this.state,\n          ...changes\n        });\n        return;\n      }\n    }\n  }\n\n  /**\n   * Sets a specific key in the store's state to a new value and notifies listeners if the value has changed.\n   *\n   * @param key The key in the store's state to update.\n   * @param value The new value to set for the specified key.\n   */\n  set(key, value) {\n    if (!Object.is(this.state[key], value)) {\n      this.setState({\n        ...this.state,\n        [key]: value\n      });\n    }\n  }\n\n  /**\n   * Gives the state a new reference and updates all registered listeners.\n   */\n  notifyAll() {\n    const newState = {\n      ...this.state\n    };\n    this.setState(newState);\n  }\n  use(selector, a1, a2, a3) {\n    // eslint-disable-next-line react-hooks/rules-of-hooks\n    return useStore(this, selector, a1, a2, a3);\n  }\n}"],"names":["Store","state","fn","newState","currentTick","listener","changes","key","value","selector","a1","a2","a3","useStore"],"mappings":";AAKO,MAAMA,EAAM;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAYjB,YAAYC,GAAO;AACjB,SAAK,QAAQA,GACb,KAAK,YAAY,oBAAI,IAAG,GACxB,KAAK,aAAa;AAAA,EACpB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,YAAY,CAAAC,OACV,KAAK,UAAU,IAAIA,CAAE,GACd,MAAM;AACX,SAAK,UAAU,OAAOA,CAAE;AAAA,EAC1B;AAAA;AAAA;AAAA;AAAA,EAMF,cAAc,MACL,KAAK;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQd,SAASC,GAAU;AACjB,QAAI,KAAK,UAAUA;AACjB;AAEF,SAAK,QAAQA,GACb,KAAK,cAAc;AACnB,UAAMC,IAAc,KAAK;AACzB,eAAWC,KAAY,KAAK,WAAW;AACrC,UAAID,MAAgB,KAAK;AAGvB;AAEF,MAAAC,EAASF,CAAQ;AAAA,IACnB;AAAA,EACF;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,OAAOG,GAAS;AACd,eAAWC,KAAOD;AAChB,UAAI,CAAC,OAAO,GAAG,KAAK,MAAMC,CAAG,GAAGD,EAAQC,CAAG,CAAC,GAAG;AAC7C,aAAK,SAAS;AAAA,UACZ,GAAG,KAAK;AAAA,UACR,GAAGD;AAAA,QACb,CAAS;AACD;AAAA,MACF;AAAA,EAEJ;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQA,IAAIC,GAAKC,GAAO;AACd,IAAK,OAAO,GAAG,KAAK,MAAMD,CAAG,GAAGC,CAAK,KACnC,KAAK,SAAS;AAAA,MACZ,GAAG,KAAK;AAAA,MACR,CAACD,CAAG,GAAGC;AAAA,IACf,CAAO;AAAA,EAEL;AAAA;AAAA;AAAA;AAAA,EAKA,YAAY;AACV,UAAML,IAAW;AAAA,MACf,GAAG,KAAK;AAAA,IACd;AACI,SAAK,SAASA,CAAQ;AAAA,EACxB;AAAA,EACA,IAAIM,GAAUC,GAAIC,GAAIC,GAAI;AAExB,WAAOC,EAAS,MAAMJ,GAAUC,GAAIC,GAAIC,CAAE;AAAA,EAC5C;AACF;","x_google_ignoreList":[0]}

package/dist/node_modules/@base-ui/utils/esm/store/createSelector.mjs

@@ -0,0 +1,26 @@
+import t from "../formatErrorMessage.mjs";
+import { createSelectorCreator as s, lruMemoize as i } from "../../../../reselect/dist/reselect.mjs";
+s({
+  memoize: i,
+  memoizeOptions: {
+    maxSize: 1,
+    equalityCheck: Object.is
+  }
+});
+const u = (e, m, c, n, l, p, ...o) => {
+  if (o.length > 0)
+    throw new Error(process.env.NODE_ENV !== "production" ? "Unsupported number of selectors" : t(1));
+  let r;
+  if (e)
+    r = e;
+  else
+    throw (
+      /* minify-error-disabled */
+      new Error("Missing arguments")
+    );
+  return r;
+};
+export {
+  u as createSelector
+};
+//# sourceMappingURL=createSelector.mjs.map

package/dist/node_modules/@base-ui/utils/esm/store/createSelector.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createSelector.mjs","sources":["../../../../../../node_modules/@base-ui/utils/esm/store/createSelector.js"],"sourcesContent":["import _formatErrorMessage from \"../formatErrorMessage.js\";\nimport { lruMemoize, createSelectorCreator } from 'reselect';\n\n/* eslint-disable no-underscore-dangle */ // __cacheKey__\n\nconst reselectCreateSelector = createSelectorCreator({\n  memoize: lruMemoize,\n  memoizeOptions: {\n    maxSize: 1,\n    equalityCheck: Object.is\n  }\n});\n/**\n * Creates a selector function that can be used to derive values from the store's state.\n * The selector can take up to three additional arguments that can be used in the selector logic.\n * This function accepts up to six functions and combines them into a single selector function.\n * The last parameter is the combiner function that combines the results of the previous selectors.\n *\n * @example\n * const selector = createSelector(\n *  (state) => state.disabled\n * );\n *\n * @example\n * const selector = createSelector(\n *   (state) => state.disabled,\n *   (state) => state.open,\n *   (disabled, open) => ({ disabled, open })\n * );\n *\n */\n/* eslint-disable id-denylist */\nexport const createSelector = (a, b, c, d, e, f, ...other) => {\n  if (other.length > 0) {\n    throw new Error(process.env.NODE_ENV !== \"production\" ? 'Unsupported number of selectors' : _formatErrorMessage(1));\n  }\n  let selector;\n  if (a && b && c && d && e && f) {\n    selector = (state, a1, a2, a3) => {\n      const va = a(state, a1, a2, a3);\n      const vb = b(state, a1, a2, a3);\n      const vc = c(state, a1, a2, a3);\n      const vd = d(state, a1, a2, a3);\n      const ve = e(state, a1, a2, a3);\n      return f(va, vb, vc, vd, ve, a1, a2, a3);\n    };\n  } else if (a && b && c && d && e) {\n    selector = (state, a1, a2, a3) => {\n      const va = a(state, a1, a2, a3);\n      const vb = b(state, a1, a2, a3);\n      const vc = c(state, a1, a2, a3);\n      const vd = d(state, a1, a2, a3);\n      return e(va, vb, vc, vd, a1, a2, a3);\n    };\n  } else if (a && b && c && d) {\n    selector = (state, a1, a2, a3) => {\n      const va = a(state, a1, a2, a3);\n      const vb = b(state, a1, a2, a3);\n      const vc = c(state, a1, a2, a3);\n      return d(va, vb, vc, a1, a2, a3);\n    };\n  } else if (a && b && c) {\n    selector = (state, a1, a2, a3) => {\n      const va = a(state, a1, a2, a3);\n      const vb = b(state, a1, a2, a3);\n      return c(va, vb, a1, a2, a3);\n    };\n  } else if (a && b) {\n    selector = (state, a1, a2, a3) => {\n      const va = a(state, a1, a2, a3);\n      return b(va, a1, a2, a3);\n    };\n  } else if (a) {\n    selector = a;\n  } else {\n    throw /* minify-error-disabled */new Error('Missing arguments');\n  }\n  return selector;\n};\n/* eslint-enable id-denylist */\n\nexport const createSelectorMemoized = (...selectors) => {\n  const cache = new WeakMap();\n  let nextCacheId = 1;\n  const combiner = selectors[selectors.length - 1];\n  const nSelectors = selectors.length - 1 || 1;\n  // (s1, s2, ..., sN, a1, a2, a3) => { ... }\n  const argsLength = combiner.length - nSelectors;\n  if (argsLength > 3) {\n    throw new Error(process.env.NODE_ENV !== \"production\" ? 'Unsupported number of arguments' : _formatErrorMessage(2));\n  }\n  const selector = (state, a1, a2, a3) => {\n    let cacheKey = state.__cacheKey__;\n    if (!cacheKey) {\n      cacheKey = {\n        id: nextCacheId\n      };\n      state.__cacheKey__ = cacheKey;\n      nextCacheId += 1;\n    }\n    let fn = cache.get(cacheKey);\n    if (!fn) {\n      let reselectArgs = selectors;\n      const selectorArgs = [undefined, undefined, undefined];\n      switch (argsLength) {\n        case 0:\n          break;\n        case 1:\n          {\n            reselectArgs = [...selectors.slice(0, -1), () => selectorArgs[0], combiner];\n            break;\n          }\n        case 2:\n          {\n            reselectArgs = [...selectors.slice(0, -1), () => selectorArgs[0], () => selectorArgs[1], combiner];\n            break;\n          }\n        case 3:\n          {\n            reselectArgs = [...selectors.slice(0, -1), () => selectorArgs[0], () => selectorArgs[1], () => selectorArgs[2], combiner];\n            break;\n          }\n        default:\n          throw new Error(process.env.NODE_ENV !== \"production\" ? 'Unsupported number of arguments' : _formatErrorMessage(2));\n      }\n      fn = reselectCreateSelector(...reselectArgs);\n      fn.selectorArgs = selectorArgs;\n      cache.set(cacheKey, fn);\n    }\n    fn.selectorArgs[0] = a1;\n    fn.selectorArgs[1] = a2;\n    fn.selectorArgs[2] = a3;\n\n    // prettier-ignore\n    switch (argsLength) {\n      case 0:\n        return fn(state);\n      case 1:\n        return fn(state, a1);\n      case 2:\n        return fn(state, a1, a2);\n      case 3:\n        return fn(state, a1, a2, a3);\n      default:\n        throw /* minify-error-disabled */new Error('unreachable');\n    }\n  };\n  return selector;\n};"],"names":["createSelectorCreator","lruMemoize","createSelector","a","b","d","e","f","other","_formatErrorMessage","selector"],"mappings":";;AAK+BA,EAAsB;AAAA,EACnD,SAASC;AAAA,EACT,gBAAgB;AAAA,IACd,SAAS;AAAA,IACT,eAAe,OAAO;AAAA,EAC1B;AACA,CAAC;AAqBW,MAACC,IAAiB,CAACC,GAAGC,GAAG,GAAGC,GAAGC,GAAGC,MAAMC,MAAU;AAC5D,MAAIA,EAAM,SAAS;AACjB,UAAM,IAAI,MAAM,QAAQ,IAAI,aAAa,eAAe,oCAAoCC,EAAoB,CAAC,CAAC;AAEpH,MAAIC;AAoCG,MAAIP;AACT,IAAAO,IAAWP;AAAA;AAEX;AAAA;AAAA,MAAiC,IAAI,MAAM,mBAAmB;AAAA;AAEhE,SAAOO;AACT;","x_google_ignoreList":[0]}

package/dist/node_modules/@base-ui/utils/esm/store/useStore.mjs

@@ -0,0 +1,63 @@
+import * as f from "react";
+import { s as u } from "../../../../../_virtual/index.mjs";
+import { w as d } from "../../../../../_virtual/with-selector.mjs";
+import { isReactVersionAtLeast as S } from "../reactVersion.mjs";
+import { getInstance as a, register as h } from "../fastHooks.mjs";
+const l = S(19), g = l ? p : y;
+function H(e, r, s, o, t) {
+  return g(e, r, s, o, t);
+}
+function b(e, r, s, o, t) {
+  const i = f.useCallback(() => r(e.getSnapshot(), s, o, t), [e, r, s, o, t]);
+  return u.useSyncExternalStore(e.subscribe, i, i);
+}
+h({
+  before(e) {
+    e.syncIndex = 0, e.didInitialize || (e.syncTick = 1, e.syncHooks = [], e.didChangeStore = !0, e.getSnapshot = () => {
+      let r = !1;
+      for (let s = 0; s < e.syncHooks.length; s += 1) {
+        const o = e.syncHooks[s], t = o.selector(o.store.state, o.a1, o.a2, o.a3);
+        (o.didChange || !Object.is(o.value, t)) && (r = !0, o.value = t, o.didChange = !1);
+      }
+      return r && (e.syncTick += 1), e.syncTick;
+    });
+  },
+  after(e) {
+    e.syncHooks.length > 0 && (e.didChangeStore && (e.didChangeStore = !1, e.subscribe = (r) => {
+      const s = /* @__PURE__ */ new Set();
+      for (const t of e.syncHooks)
+        s.add(t.store);
+      const o = [];
+      for (const t of s)
+        o.push(t.subscribe(r));
+      return () => {
+        for (const t of o)
+          t();
+      };
+    }), u.useSyncExternalStore(e.subscribe, e.getSnapshot, e.getSnapshot));
+  }
+});
+function p(e, r, s, o, t) {
+  const i = a();
+  if (!i)
+    return b(e, r, s, o, t);
+  const c = i.syncIndex;
+  i.syncIndex += 1;
+  let n;
+  return i.didInitialize ? (n = i.syncHooks[c], (n.store !== e || n.selector !== r || !Object.is(n.a1, s) || !Object.is(n.a2, o) || !Object.is(n.a3, t)) && (n.store !== e && (i.didChangeStore = !0), n.store = e, n.selector = r, n.a1 = s, n.a2 = o, n.a3 = t, n.didChange = !0)) : (n = {
+    store: e,
+    selector: r,
+    a1: s,
+    a2: o,
+    a3: t,
+    value: r(e.getSnapshot(), s, o, t),
+    didChange: !1
+  }, i.syncHooks.push(n)), n.value;
+}
+function y(e, r, s, o, t) {
+  return d.useSyncExternalStoreWithSelector(e.subscribe, e.getSnapshot, e.getSnapshot, (i) => r(i, s, o, t));
+}
+export {
+  H as useStore
+};
+//# sourceMappingURL=useStore.mjs.map

package/dist/node_modules/@base-ui/utils/esm/store/useStore.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useStore.mjs","sources":["../../../../../../node_modules/@base-ui/utils/esm/store/useStore.js"],"sourcesContent":["import * as React from 'react';\n/* We need to import the shim because React 17 does not support the `useSyncExternalStore` API.\n * More info: https://github.com/mui/mui-x/issues/18303#issuecomment-2958392341 */\nimport { useSyncExternalStore } from 'use-sync-external-store/shim';\nimport { useSyncExternalStoreWithSelector } from 'use-sync-external-store/shim/with-selector';\nimport { isReactVersionAtLeast } from \"../reactVersion.js\";\nimport { register, getInstance } from \"../fastHooks.js\";\n/* Some tests fail in R18 with the raw useSyncExternalStore. It may be possible to make it work\n * but for now we only enable it for R19+. */\nconst canUseRawUseSyncExternalStore = isReactVersionAtLeast(19);\nconst useStoreImplementation = canUseRawUseSyncExternalStore ? useStoreFast : useStoreLegacy;\nexport function useStore(store, selector, a1, a2, a3) {\n  return useStoreImplementation(store, selector, a1, a2, a3);\n}\nfunction useStoreR19(store, selector, a1, a2, a3) {\n  const getSelection = React.useCallback(() => selector(store.getSnapshot(), a1, a2, a3), [store, selector, a1, a2, a3]);\n  return useSyncExternalStore(store.subscribe, getSelection, getSelection);\n}\nregister({\n  before(instance) {\n    instance.syncIndex = 0;\n    if (!instance.didInitialize) {\n      instance.syncTick = 1;\n      instance.syncHooks = [];\n      instance.didChangeStore = true;\n      instance.getSnapshot = () => {\n        let didChange = false;\n        for (let i = 0; i < instance.syncHooks.length; i += 1) {\n          const hook = instance.syncHooks[i];\n          const value = hook.selector(hook.store.state, hook.a1, hook.a2, hook.a3);\n          if (hook.didChange || !Object.is(hook.value, value)) {\n            didChange = true;\n            hook.value = value;\n            hook.didChange = false;\n          }\n        }\n        if (didChange) {\n          instance.syncTick += 1;\n        }\n        return instance.syncTick;\n      };\n    }\n  },\n  after(instance) {\n    if (instance.syncHooks.length > 0) {\n      if (instance.didChangeStore) {\n        instance.didChangeStore = false;\n        instance.subscribe = onStoreChange => {\n          const stores = new Set();\n          for (const hook of instance.syncHooks) {\n            stores.add(hook.store);\n          }\n          const unsubscribes = [];\n          for (const store of stores) {\n            unsubscribes.push(store.subscribe(onStoreChange));\n          }\n          return () => {\n            for (const unsubscribe of unsubscribes) {\n              unsubscribe();\n            }\n          };\n        };\n      }\n      // eslint-disable-next-line react-hooks/rules-of-hooks\n      useSyncExternalStore(instance.subscribe, instance.getSnapshot, instance.getSnapshot);\n    }\n  }\n});\nfunction useStoreFast(store, selector, a1, a2, a3) {\n  const instance = getInstance();\n  if (!instance) {\n    // eslint-disable-next-line react-hooks/rules-of-hooks\n    return useStoreR19(store, selector, a1, a2, a3);\n  }\n  const index = instance.syncIndex;\n  instance.syncIndex += 1;\n  let hook;\n  if (!instance.didInitialize) {\n    hook = {\n      store,\n      selector,\n      a1,\n      a2,\n      a3,\n      value: selector(store.getSnapshot(), a1, a2, a3),\n      didChange: false\n    };\n    instance.syncHooks.push(hook);\n  } else {\n    hook = instance.syncHooks[index];\n    if (hook.store !== store || hook.selector !== selector || !Object.is(hook.a1, a1) || !Object.is(hook.a2, a2) || !Object.is(hook.a3, a3)) {\n      if (hook.store !== store) {\n        instance.didChangeStore = true;\n      }\n      hook.store = store;\n      hook.selector = selector;\n      hook.a1 = a1;\n      hook.a2 = a2;\n      hook.a3 = a3;\n      hook.didChange = true;\n    }\n  }\n  return hook.value;\n}\nfunction useStoreLegacy(store, selector, a1, a2, a3) {\n  return useSyncExternalStoreWithSelector(store.subscribe, store.getSnapshot, store.getSnapshot, state => selector(state, a1, a2, a3));\n}"],"names":["canUseRawUseSyncExternalStore","isReactVersionAtLeast","useStoreImplementation","useStoreFast","useStoreLegacy","useStore","store","selector","a1","a2","a3","useStoreR19","getSelection","React","useSyncExternalStore","register","instance","didChange","i","hook","value","onStoreChange","stores","unsubscribes","unsubscribe","getInstance","index","useSyncExternalStoreWithSelector","state"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/node_modules/@base-ui/utils/esm/useAnimationFrame.mjs

@@ -0,0 +1,69 @@
+import { useRefWithInit as u } from "./useRefWithInit.mjs";
+import { useOnMount as h } from "./useOnMount.mjs";
+const s = null;
+let l = globalThis.requestAnimationFrame;
+class o {
+  /* 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`. */
+  callbacks = [];
+  callbacksCount = 0;
+  nextId = 1;
+  startId = 1;
+  isScheduled = !1;
+  tick = (t) => {
+    this.isScheduled = !1;
+    const e = this.callbacks, r = this.callbacksCount;
+    if (this.callbacks = [], this.callbacksCount = 0, this.startId = this.nextId, r > 0)
+      for (let i = 0; i < e.length; i += 1)
+        e[i]?.(t);
+  };
+  request(t) {
+    const e = this.nextId;
+    this.nextId += 1, this.callbacks.push(t), this.callbacksCount += 1;
+    const r = process.env.NODE_ENV !== "production" && l !== requestAnimationFrame && (l = 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 c = new o();
+class a {
+  static create() {
+    return new a();
+  }
+  static request(t) {
+    return c.request(t);
+  }
+  static cancel(t) {
+    return c.cancel(t);
+  }
+  currentId = s;
+  /**
+   * Executes `fn` after `delay`, clearing any previously scheduled call.
+   */
+  request(t) {
+    this.cancel(), this.currentId = c.request(() => {
+      this.currentId = s, t();
+    });
+  }
+  cancel = () => {
+    this.currentId !== s && (c.cancel(this.currentId), this.currentId = s);
+  };
+  disposeEffect = () => this.cancel;
+}
+function k() {
+  const n = u(a.create).current;
+  return h(n.disposeEffect), n;
+}
+export {
+  a as AnimationFrame,
+  k as useAnimationFrame
+};
+//# sourceMappingURL=useAnimationFrame.mjs.map

package/dist/node_modules/@base-ui/utils/esm/useAnimationFrame.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAnimationFrame.mjs","sources":["../../../../../node_modules/@base-ui/utils/esm/useAnimationFrame.js"],"sourcesContent":["'use client';\n\nimport { useRefWithInit } from \"./useRefWithInit.js\";\nimport { useOnMount } from \"./useOnMount.js\";\n/** Unlike `setTimeout`, rAF doesn't guarantee a positive integer return value, so we can't have\n * a monomorphic `uint` type with `0` meaning empty.\n * See warning note at:\n * https://developer.mozilla.org/en-US/docs/Web/API/Window/requestAnimationFrame#return_value */\nconst EMPTY = null;\nlet LAST_RAF = globalThis.requestAnimationFrame;\nclass Scheduler {\n  /* This implementation uses an array as a backing data-structure for frame callbacks.\n   * It allows `O(1)` callback cancelling by inserting a `null` in the array, though it\n   * never calls the native `cancelAnimationFrame` if there are no frames left. This can\n   * be much more efficient if there is a call pattern that alterns as\n   * \"request-cancel-request-cancel-…\".\n   * But in the case of \"request-request-…-cancel-cancel-…\", it leaves the final animation\n   * frame to run anyway. We turn that frame into a `O(1)` no-op via `callbacksCount`. */\n\n  callbacks = [];\n  callbacksCount = 0;\n  nextId = 1;\n  startId = 1;\n  isScheduled = false;\n  tick = timestamp => {\n    this.isScheduled = false;\n    const currentCallbacks = this.callbacks;\n    const currentCallbacksCount = this.callbacksCount;\n\n    // Update these before iterating, callbacks could call `requestAnimationFrame` again.\n    this.callbacks = [];\n    this.callbacksCount = 0;\n    this.startId = this.nextId;\n    if (currentCallbacksCount > 0) {\n      for (let i = 0; i < currentCallbacks.length; i += 1) {\n        currentCallbacks[i]?.(timestamp);\n      }\n    }\n  };\n  request(fn) {\n    const id = this.nextId;\n    this.nextId += 1;\n    this.callbacks.push(fn);\n    this.callbacksCount += 1;\n\n    /* In a test environment with fake timers, a fake `requestAnimationFrame` can be called\n     * but there's no guarantee that the animation frame will actually run before the fake\n     * timers are teared, which leaves `isScheduled` set, but won't run our `tick()`. */\n    const didRAFChange = process.env.NODE_ENV !== 'production' && LAST_RAF !== requestAnimationFrame && (LAST_RAF = requestAnimationFrame, true);\n    if (!this.isScheduled || didRAFChange) {\n      requestAnimationFrame(this.tick);\n      this.isScheduled = true;\n    }\n    return id;\n  }\n  cancel(id) {\n    const index = id - this.startId;\n    if (index < 0 || index >= this.callbacks.length) {\n      return;\n    }\n    this.callbacks[index] = null;\n    this.callbacksCount -= 1;\n  }\n}\nconst scheduler = new Scheduler();\nexport class AnimationFrame {\n  static create() {\n    return new AnimationFrame();\n  }\n  static request(fn) {\n    return scheduler.request(fn);\n  }\n  static cancel(id) {\n    return scheduler.cancel(id);\n  }\n  currentId = EMPTY;\n\n  /**\n   * Executes `fn` after `delay`, clearing any previously scheduled call.\n   */\n  request(fn) {\n    this.cancel();\n    this.currentId = scheduler.request(() => {\n      this.currentId = EMPTY;\n      fn();\n    });\n  }\n  cancel = () => {\n    if (this.currentId !== EMPTY) {\n      scheduler.cancel(this.currentId);\n      this.currentId = EMPTY;\n    }\n  };\n  disposeEffect = () => {\n    return this.cancel;\n  };\n}\n\n/**\n * A `requestAnimationFrame` with automatic cleanup and guard.\n */\nexport function useAnimationFrame() {\n  const timeout = useRefWithInit(AnimationFrame.create).current;\n  useOnMount(timeout.disposeEffect);\n  return timeout;\n}"],"names":["EMPTY","LAST_RAF","Scheduler","timestamp","currentCallbacks","currentCallbacksCount","fn","id","didRAFChange","index","scheduler","AnimationFrame","useAnimationFrame","timeout","useRefWithInit","useOnMount"],"mappings":";;AAQA,MAAMA,IAAQ;AACd,IAAIC,IAAW,WAAW;AAC1B,MAAMC,EAAU;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASd,YAAY,CAAA;AAAA,EACZ,iBAAiB;AAAA,EACjB,SAAS;AAAA,EACT,UAAU;AAAA,EACV,cAAc;AAAA,EACd,OAAO,CAAAC,MAAa;AAClB,SAAK,cAAc;AACnB,UAAMC,IAAmB,KAAK,WACxBC,IAAwB,KAAK;AAMnC,QAHA,KAAK,YAAY,CAAA,GACjB,KAAK,iBAAiB,GACtB,KAAK,UAAU,KAAK,QAChBA,IAAwB;AAC1B,eAAS,IAAI,GAAG,IAAID,EAAiB,QAAQ,KAAK;AAChD,QAAAA,EAAiB,CAAC,IAAID,CAAS;AAAA,EAGrC;AAAA,EACA,QAAQG,GAAI;AACV,UAAMC,IAAK,KAAK;AAChB,SAAK,UAAU,GACf,KAAK,UAAU,KAAKD,CAAE,GACtB,KAAK,kBAAkB;AAKvB,UAAME,IAAe,QAAQ,IAAI,aAAa,gBAAgBP,MAAa,0BAA0BA,IAAW,uBAAuB;AACvI,YAAI,CAAC,KAAK,eAAeO,OACvB,sBAAsB,KAAK,IAAI,GAC/B,KAAK,cAAc,KAEdD;AAAA,EACT;AAAA,EACA,OAAOA,GAAI;AACT,UAAME,IAAQF,IAAK,KAAK;AACxB,IAAIE,IAAQ,KAAKA,KAAS,KAAK,UAAU,WAGzC,KAAK,UAAUA,CAAK,IAAI,MACxB,KAAK,kBAAkB;AAAA,EACzB;AACF;AACA,MAAMC,IAAY,IAAIR,EAAS;AACxB,MAAMS,EAAe;AAAA,EAC1B,OAAO,SAAS;AACd,WAAO,IAAIA,EAAc;AAAA,EAC3B;AAAA,EACA,OAAO,QAAQL,GAAI;AACjB,WAAOI,EAAU,QAAQJ,CAAE;AAAA,EAC7B;AAAA,EACA,OAAO,OAAOC,GAAI;AAChB,WAAOG,EAAU,OAAOH,CAAE;AAAA,EAC5B;AAAA,EACA,YAAYP;AAAA;AAAA;AAAA;AAAA,EAKZ,QAAQM,GAAI;AACV,SAAK,OAAM,GACX,KAAK,YAAYI,EAAU,QAAQ,MAAM;AACvC,WAAK,YAAYV,GACjBM,EAAE;AAAA,IACJ,CAAC;AAAA,EACH;AAAA,EACA,SAAS,MAAM;AACb,IAAI,KAAK,cAAcN,MACrBU,EAAU,OAAO,KAAK,SAAS,GAC/B,KAAK,YAAYV;AAAA,EAErB;AAAA,EACA,gBAAgB,MACP,KAAK;AAEhB;AAKO,SAASY,IAAoB;AAClC,QAAMC,IAAUC,EAAeH,EAAe,MAAM,EAAE;AACtD,SAAAI,EAAWF,EAAQ,aAAa,GACzBA;AACT;","x_google_ignoreList":[0]}

package/dist/node_modules/@base-ui/utils/esm/useControlled.mjs

@@ -0,0 +1,32 @@
+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
+};
+//# sourceMappingURL=useControlled.mjs.map

package/dist/node_modules/@base-ui/utils/esm/useControlled.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useControlled.mjs","sources":["../../../../../node_modules/@base-ui/utils/esm/useControlled.js"],"sourcesContent":["'use client';\n\n// TODO: uncomment once we enable eslint-plugin-react-compiler // eslint-disable-next-line react-compiler/react-compiler -- process.env never changes, dependency arrays are intentionally ignored\n/* eslint-disable react-hooks/rules-of-hooks, react-hooks/exhaustive-deps */\nimport * as React from 'react';\nexport function useControlled({\n  controlled,\n  default: defaultProp,\n  name,\n  state = 'value'\n}) {\n  // isControlled is ignored in the hook dependency lists as it should never change.\n  const {\n    current: isControlled\n  } = React.useRef(controlled !== undefined);\n  const [valueState, setValue] = React.useState(defaultProp);\n  const value = isControlled ? controlled : valueState;\n  if (process.env.NODE_ENV !== 'production') {\n    React.useEffect(() => {\n      if (isControlled !== (controlled !== undefined)) {\n        console.error([`Base UI: A component is changing the ${isControlled ? '' : 'un'}controlled ${state} state of ${name} to be ${isControlled ? 'un' : ''}controlled.`, 'Elements should not switch from uncontrolled to controlled (or vice versa).', `Decide between using a controlled or uncontrolled ${name} ` + '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('\\n'));\n      }\n    }, [state, name, controlled]);\n    const {\n      current: defaultValue\n    } = React.useRef(defaultProp);\n    React.useEffect(() => {\n      // See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is for more details.\n      if (!isControlled && JSON.stringify(defaultValue) !== JSON.stringify(defaultProp)) {\n        console.error([`Base UI: A component is changing the default ${state} state of an uncontrolled ${name} after being initialized. ` + `To suppress this warning opt to use a controlled ${name}.`].join('\\n'));\n      }\n    }, [JSON.stringify(defaultProp)]);\n  }\n  const setValueIfUncontrolled = React.useCallback(newValue => {\n    if (!isControlled) {\n      setValue(newValue);\n    }\n  }, []);\n  return [value, setValueIfUncontrolled];\n}"],"names":["useControlled","controlled","defaultProp","name","state","isControlled","React","valueState","setValue","value","defaultValue","setValueIfUncontrolled","newValue"],"mappings":";AAKO,SAASA,EAAc;AAAA,EAC5B,YAAAC;AAAA,EACA,SAASC;AAAA,EACT,MAAAC;AAAA,EACA,OAAAC,IAAQ;AACV,GAAG;AAED,QAAM;AAAA,IACJ,SAASC;AAAA,EACb,IAAMC,EAAM,OAAOL,MAAe,MAAS,GACnC,CAACM,GAAYC,CAAQ,IAAIF,EAAM,SAASJ,CAAW,GACnDO,IAAQJ,IAAeJ,IAAaM;AAC1C,MAAI,QAAQ,IAAI,aAAa,cAAc;AACzC,IAAAD,EAAM,UAAU,MAAM;AACpB,MAAID,OAAkBJ,MAAe,WACnC,QAAQ,MAAM,CAAC,wCAAwCI,IAAe,KAAK,IAAI,cAAcD,CAAK,aAAaD,CAAI,UAAUE,IAAe,OAAO,EAAE,eAAe,+EAA+E,qDAAqDF,CAAI,+CAAoD,8HAA8H,sDAAsD,EAAE,KAAK;AAAA,CAAI,CAAC;AAAA,IAEpiB,GAAG,CAACC,GAAOD,GAAMF,CAAU,CAAC;AAC5B,UAAM;AAAA,MACJ,SAASS;AAAA,IACf,IAAQJ,EAAM,OAAOJ,CAAW;AAC5B,IAAAI,EAAM,UAAU,MAAM;AAEpB,MAAI,CAACD,KAAgB,KAAK,UAAUK,CAAY,MAAM,KAAK,UAAUR,CAAW,KAC9E,QAAQ,MAAM,CAAC,gDAAgDE,CAAK,6BAA6BD,CAAI,8EAAmFA,CAAI,GAAG,EAAE,KAAK;AAAA,CAAI,CAAC;AAAA,IAE/M,GAAG,CAAC,KAAK,UAAUD,CAAW,CAAC,CAAC;AAAA,EAClC;AACA,QAAMS,IAAyBL,EAAM,YAAY,CAAAM,MAAY;AAC3D,IAAKP,KACHG,EAASI,CAAQ;AAAA,EAErB,GAAG,CAAA,CAAE;AACL,SAAO,CAACH,GAAOE,CAAsB;AACvC;","x_google_ignoreList":[0]}

package/dist/node_modules/@base-ui/utils/esm/useEnhancedClickHandler.mjs

@@ -0,0 +1,20 @@
+import * as e from "react";
+function t(i) {
+  const o = e.useRef(""), n = e.useCallback((r) => {
+    r.defaultPrevented || (o.current = r.pointerType, i(r, r.pointerType));
+  }, [i]);
+  return {
+    onClick: e.useCallback((r) => {
+      if (r.detail === 0) {
+        i(r, "keyboard");
+        return;
+      }
+      "pointerType" in r ? i(r, r.pointerType) : i(r, o.current), o.current = "";
+    }, [i]),
+    onPointerDown: n
+  };
+}
+export {
+  t as useEnhancedClickHandler
+};
+//# sourceMappingURL=useEnhancedClickHandler.mjs.map

package/dist/node_modules/@base-ui/utils/esm/useEnhancedClickHandler.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useEnhancedClickHandler.mjs","sources":["../../../../../node_modules/@base-ui/utils/esm/useEnhancedClickHandler.js"],"sourcesContent":["'use client';\n\nimport * as React from 'react';\n/**\n * Provides a cross-browser way to determine the type of the pointer used to click.\n * Safari and Firefox do not provide the PointerEvent to the click handler (they use MouseEvent) yet.\n * Additionally, this implementation detects if the click was triggered by the keyboard.\n *\n * @param handler The function to be called when the button is clicked. The first parameter is the original event and the second parameter is the pointer type.\n */\nexport function useEnhancedClickHandler(handler) {\n  const lastClickInteractionTypeRef = React.useRef('');\n  const handlePointerDown = React.useCallback(event => {\n    if (event.defaultPrevented) {\n      return;\n    }\n    lastClickInteractionTypeRef.current = event.pointerType;\n    handler(event, event.pointerType);\n  }, [handler]);\n  const handleClick = React.useCallback(event => {\n    // event.detail has the number of clicks performed on the element. 0 means it was triggered by the keyboard.\n    if (event.detail === 0) {\n      handler(event, 'keyboard');\n      return;\n    }\n    if ('pointerType' in event) {\n      // Chrome and Edge correctly use PointerEvent\n      handler(event, event.pointerType);\n    } else {\n      handler(event, lastClickInteractionTypeRef.current);\n    }\n    lastClickInteractionTypeRef.current = '';\n  }, [handler]);\n  return {\n    onClick: handleClick,\n    onPointerDown: handlePointerDown\n  };\n}"],"names":["useEnhancedClickHandler","handler","lastClickInteractionTypeRef","React","handlePointerDown","event"],"mappings":";AAUO,SAASA,EAAwBC,GAAS;AAC/C,QAAMC,IAA8BC,EAAM,OAAO,EAAE,GAC7CC,IAAoBD,EAAM,YAAY,CAAAE,MAAS;AACnD,IAAIA,EAAM,qBAGVH,EAA4B,UAAUG,EAAM,aAC5CJ,EAAQI,GAAOA,EAAM,WAAW;AAAA,EAClC,GAAG,CAACJ,CAAO,CAAC;AAeZ,SAAO;AAAA,IACL,SAfkBE,EAAM,YAAY,CAAAE,MAAS;AAE7C,UAAIA,EAAM,WAAW,GAAG;AACtB,QAAAJ,EAAQI,GAAO,UAAU;AACzB;AAAA,MACF;AACA,MAAI,iBAAiBA,IAEnBJ,EAAQI,GAAOA,EAAM,WAAW,IAEhCJ,EAAQI,GAAOH,EAA4B,OAAO,GAEpDA,EAA4B,UAAU;AAAA,IACxC,GAAG,CAACD,CAAO,CAAC;AAAA,IAGV,eAAeG;AAAA,EACnB;AACA;","x_google_ignoreList":[0]}

package/dist/node_modules/@base-ui/utils/esm/useId.mjs

@@ -0,0 +1,21 @@
+import * as n from "react";
+import { SafeReact as f } from "./safeReact.mjs";
+let o = 0;
+function l(u, t = "mui") {
+  const [e, s] = n.useState(u), c = u || e;
+  return n.useEffect(() => {
+    e == null && (o += 1, s(`${t}-${o}`));
+  }, [e, t]), c;
+}
+const a = f.useId;
+function I(u, t) {
+  if (a !== void 0) {
+    const e = a();
+    return u ?? (t ? `${t}-${e}` : e);
+  }
+  return l(u, t);
+}
+export {
+  I as useId
+};
+//# sourceMappingURL=useId.mjs.map

package/dist/node_modules/@base-ui/utils/esm/useId.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useId.mjs","sources":["../../../../../node_modules/@base-ui/utils/esm/useId.js"],"sourcesContent":["'use client';\n\nimport * as React from 'react';\nimport { SafeReact } from \"./safeReact.js\";\nlet globalId = 0;\n\n// TODO React 17: Remove `useGlobalId` once React 17 support is removed\nfunction useGlobalId(idOverride, prefix = 'mui') {\n  const [defaultId, setDefaultId] = React.useState(idOverride);\n  const id = idOverride || defaultId;\n  React.useEffect(() => {\n    if (defaultId == null) {\n      // Fallback to this default id when possible.\n      // Use the incrementing value for client-side rendering only.\n      // We can't use it server-side.\n      // If you want to use random values please consider the Birthday Problem: https://en.wikipedia.org/wiki/Birthday_problem\n      globalId += 1;\n      setDefaultId(`${prefix}-${globalId}`);\n    }\n  }, [defaultId, prefix]);\n  return id;\n}\nconst maybeReactUseId = SafeReact.useId;\n\n/**\n *\n * @example <div id={useId()} />\n * @param idOverride\n * @returns {string}\n */\nexport function useId(idOverride, prefix) {\n  // React.useId() is only available from React 17.0.0.\n  if (maybeReactUseId !== undefined) {\n    const reactId = maybeReactUseId();\n    return idOverride ?? (prefix ? `${prefix}-${reactId}` : reactId);\n  }\n\n  // TODO: uncomment once we enable eslint-plugin-react-compiler // eslint-disable-next-line react-compiler/react-compiler\n  // eslint-disable-next-line react-hooks/rules-of-hooks -- `React.useId` is invariant at runtime.\n  return useGlobalId(idOverride, prefix);\n}"],"names":["globalId","useGlobalId","idOverride","prefix","defaultId","setDefaultId","React","id","maybeReactUseId","SafeReact","useId","reactId"],"mappings":";;AAIA,IAAIA,IAAW;AAGf,SAASC,EAAYC,GAAYC,IAAS,OAAO;AAC/C,QAAM,CAACC,GAAWC,CAAY,IAAIC,EAAM,SAASJ,CAAU,GACrDK,IAAKL,KAAcE;AACzB,SAAAE,EAAM,UAAU,MAAM;AACpB,IAAIF,KAAa,SAKfJ,KAAY,GACZK,EAAa,GAAGF,CAAM,IAAIH,CAAQ,EAAE;AAAA,EAExC,GAAG,CAACI,GAAWD,CAAM,CAAC,GACfI;AACT;AACA,MAAMC,IAAkBC,EAAU;AAQ3B,SAASC,EAAMR,GAAYC,GAAQ;AAExC,MAAIK,MAAoB,QAAW;AACjC,UAAMG,IAAUH,EAAe;AAC/B,WAAON,MAAeC,IAAS,GAAGA,CAAM,IAAIQ,CAAO,KAAKA;AAAA,EAC1D;AAIA,SAAOV,EAAYC,GAAYC,CAAM;AACvC;","x_google_ignoreList":[0]}

package/dist/node_modules/@base-ui/utils/esm/useOnFirstRender.mjs

@@ -0,0 +1,9 @@
+import * as t from "react";
+function n(r) {
+  const e = t.useRef(!0);
+  e.current && (e.current = !1, r());
+}
+export {
+  n as useOnFirstRender
+};
+//# sourceMappingURL=useOnFirstRender.mjs.map

package/dist/node_modules/@base-ui/utils/esm/useOnFirstRender.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useOnFirstRender.mjs","sources":["../../../../../node_modules/@base-ui/utils/esm/useOnFirstRender.js"],"sourcesContent":["'use client';\n\nimport * as React from 'react';\nexport function useOnFirstRender(fn) {\n  const ref = React.useRef(true);\n  if (ref.current) {\n    ref.current = false;\n    fn();\n  }\n}"],"names":["useOnFirstRender","fn","ref","React"],"mappings":";AAGO,SAASA,EAAiBC,GAAI;AACnC,QAAMC,IAAMC,EAAM,OAAO,EAAI;AAC7B,EAAID,EAAI,YACNA,EAAI,UAAU,IACdD,EAAE;AAEN;","x_google_ignoreList":[0]}

package/dist/node_modules/@base-ui/utils/esm/useOnMount.mjs

@@ -0,0 +1,9 @@
+import * as o from "react";
+const e = [];
+function n(t) {
+  o.useEffect(t, e);
+}
+export {
+  n as useOnMount
+};
+//# sourceMappingURL=useOnMount.mjs.map

package/dist/node_modules/@base-ui/utils/esm/useOnMount.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useOnMount.mjs","sources":["../../../../../node_modules/@base-ui/utils/esm/useOnMount.js"],"sourcesContent":["'use client';\n\nimport * as React from 'react';\nconst EMPTY = [];\n\n/**\n * A React.useEffect equivalent that runs once, when the component is mounted.\n */\nexport function useOnMount(fn) {\n  // TODO: uncomment once we enable eslint-plugin-react-compiler // eslint-disable-next-line react-compiler/react-compiler -- no need to put `fn` in the dependency array\n  /* eslint-disable react-hooks/exhaustive-deps */\n  React.useEffect(fn, EMPTY);\n  /* eslint-enable react-hooks/exhaustive-deps */\n}"],"names":["EMPTY","useOnMount","fn","React"],"mappings":";AAGA,MAAMA,IAAQ,CAAA;AAKP,SAASC,EAAWC,GAAI;AAG7B,EAAAC,EAAM,UAAUD,GAAIF,CAAK;AAE3B;","x_google_ignoreList":[0]}