@neynar/ui 0.4.0 → 1.0.0

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

@@ -0,0 +1,94 @@
+"use client";
+import { useRefWithInit } from "./useRefWithInit.js";
+import { useOnMount } from "./useOnMount.js";
+const EMPTY = null;
+let LAST_RAF = globalThis.requestAnimationFrame;
+class Scheduler {
+  /* 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 = false;
+  tick = (timestamp) => {
+    this.isScheduled = false;
+    const currentCallbacks = this.callbacks;
+    const currentCallbacksCount = this.callbacksCount;
+    this.callbacks = [];
+    this.callbacksCount = 0;
+    this.startId = this.nextId;
+    if (currentCallbacksCount > 0) {
+      for (let i = 0; i < currentCallbacks.length; i += 1) {
+        currentCallbacks[i]?.(timestamp);
+      }
+    }
+  };
+  request(fn) {
+    const id = this.nextId;
+    this.nextId += 1;
+    this.callbacks.push(fn);
+    this.callbacksCount += 1;
+    const didRAFChange = process.env.NODE_ENV === "test" && LAST_RAF !== requestAnimationFrame && (LAST_RAF = requestAnimationFrame, true);
+    if (!this.isScheduled || didRAFChange) {
+      requestAnimationFrame(this.tick);
+      this.isScheduled = true;
+    }
+    return id;
+  }
+  cancel(id) {
+    const index = id - this.startId;
+    if (index < 0 || index >= this.callbacks.length) {
+      return;
+    }
+    this.callbacks[index] = null;
+    this.callbacksCount -= 1;
+  }
+}
+const scheduler = new Scheduler();
+class AnimationFrame {
+  static create() {
+    return new AnimationFrame();
+  }
+  static request(fn) {
+    return scheduler.request(fn);
+  }
+  static cancel(id) {
+    return scheduler.cancel(id);
+  }
+  currentId = EMPTY;
+  /**
+   * Executes `fn` after `delay`, clearing any previously scheduled call.
+   */
+  request(fn) {
+    this.cancel();
+    this.currentId = scheduler.request(() => {
+      this.currentId = EMPTY;
+      fn();
+    });
+  }
+  cancel = () => {
+    if (this.currentId !== EMPTY) {
+      scheduler.cancel(this.currentId);
+      this.currentId = EMPTY;
+    }
+  };
+  disposeEffect = () => {
+    return this.cancel;
+  };
+}
+function useAnimationFrame() {
+  const timeout = useRefWithInit(AnimationFrame.create).current;
+  useOnMount(timeout.disposeEffect);
+  return timeout;
+}
+export {
+  AnimationFrame,
+  useAnimationFrame
+};
+//# sourceMappingURL=useAnimationFrame.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useAnimationFrame.js","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 === 'test' && 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":[],"mappings":";;;AAQA;AACA;AACA;AAAgB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AASF;AACK;AACR;AACC;AACI;AAEZ;AACA;AACA;AAGA;AACA;AACA;AACA;AACE;AACE;AAA+B;AACjC;AACF;AACF;AAEE;AACA;AACA;AACA;AAKA;AACA;AACE;AACA;AAAmB;AAErB;AAAO;AACT;AAEE;AACA;AACE;AAAA;AAEF;AACA;AAAuB;AAE3B;AACA;AACO;AAAqB;AAExB;AAAyB;AAC3B;AAEE;AAA2B;AAC7B;AAEE;AAA0B;AAC5B;AACY;AAAA;AAAA;AAAA;AAMV;AACA;AACE;AACA;AAAE;AACH;AACH;AAEE;AACE;AACA;AAAiB;AACnB;AACF;AAEE;AAAY;AAEhB;AAKO;AACL;AACA;AACA;AACF;;;;;","x_google_ignoreList":[0]}

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

@@ -0,0 +1,39 @@
+"use client";
+import * as React from "react";
+function useControlled({
+  controlled,
+  default: defaultProp,
+  name,
+  state = "value"
+}) {
+  const {
+    current: isControlled
+  } = React.useRef(controlled !== void 0);
+  const [valueState, setValue] = React.useState(defaultProp);
+  const value = isControlled ? controlled : valueState;
+  if (process.env.NODE_ENV !== "production") {
+    React.useEffect(() => {
+      if (isControlled !== (controlled !== void 0)) {
+        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"));
+      }
+    }, [state, name, controlled]);
+    const {
+      current: defaultValue
+    } = React.useRef(defaultProp);
+    React.useEffect(() => {
+      if (!isControlled && JSON.stringify(defaultValue) !== JSON.stringify(defaultProp)) {
+        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"));
+      }
+    }, [JSON.stringify(defaultProp)]);
+  }
+  const setValueIfUncontrolled = React.useCallback((newValue) => {
+    if (!isControlled) {
+      setValue(newValue);
+    }
+  }, []);
+  return [value, setValueIfUncontrolled];
+}
+export {
+  useControlled
+};
+//# sourceMappingURL=useControlled.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useControlled.js","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":[],"mappings":";;AAKO;AAAuB;AAC5B;AACS;AACT;AAEF;AAEE;AAAM;AACK;AAEX;AACA;AACA;AACE;AACE;AACE;AAAgiB;AACliB;AAEF;AAAM;AACK;AAEX;AAEE;AACE;AAA2M;AAC7M;AAC8B;AAElC;AACE;AACE;AAAiB;AACnB;AAEF;AACF;;;;","x_google_ignoreList":[0]}

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

@@ -0,0 +1,30 @@
+import * as React from "react";
+function useEnhancedClickHandler(handler) {
+  const lastClickInteractionTypeRef = React.useRef("");
+  const handlePointerDown = React.useCallback((event) => {
+    if (event.defaultPrevented) {
+      return;
+    }
+    lastClickInteractionTypeRef.current = event.pointerType;
+    handler(event, event.pointerType);
+  }, [handler]);
+  const handleClick = React.useCallback((event) => {
+    if (event.detail === 0) {
+      handler(event, "keyboard");
+      return;
+    }
+    if ("pointerType" in event) {
+      handler(event, event.pointerType);
+    }
+    handler(event, lastClickInteractionTypeRef.current);
+    lastClickInteractionTypeRef.current = "";
+  }, [handler]);
+  return {
+    onClick: handleClick,
+    onPointerDown: handlePointerDown
+  };
+}
+export {
+  useEnhancedClickHandler
+};
+//# sourceMappingURL=useEnhancedClickHandler.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useEnhancedClickHandler.js","sources":["../../../../../node_modules/@base-ui/utils/esm/useEnhancedClickHandler.js"],"sourcesContent":["import * 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    }\n    handler(event, lastClickInteractionTypeRef.current);\n    lastClickInteractionTypeRef.current = '';\n  }, [handler]);\n  return {\n    onClick: handleClick,\n    onPointerDown: handlePointerDown\n  };\n}"],"names":[],"mappings":";AAQO,SAAS,wBAAwB,SAAS;AAC/C,QAAM,8BAA8B,MAAM,OAAO,EAAE;AACnD,QAAM,oBAAoB,MAAM,YAAY,WAAS;AACnD,QAAI,MAAM,kBAAkB;AAC1B;AAAA,IACF;AACA,gCAA4B,UAAU,MAAM;AAC5C,YAAQ,OAAO,MAAM,WAAW;AAAA,EAClC,GAAG,CAAC,OAAO,CAAC;AACZ,QAAM,cAAc,MAAM,YAAY,WAAS;AAE7C,QAAI,MAAM,WAAW,GAAG;AACtB,cAAQ,OAAO,UAAU;AACzB;AAAA,IACF;AACA,QAAI,iBAAiB,OAAO;AAE1B,cAAQ,OAAO,MAAM,WAAW;AAAA,IAClC;AACA,YAAQ,OAAO,4BAA4B,OAAO;AAClD,gCAA4B,UAAU;AAAA,EACxC,GAAG,CAAC,OAAO,CAAC;AACZ,SAAO;AAAA,IACL,SAAS;AAAA,IACT,eAAe;AAAA,EACnB;AACA;","x_google_ignoreList":[0]}

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

@@ -0,0 +1,27 @@
+"use client";
+import * as React from "react";
+import { SafeReact } from "./safeReact.js";
+let globalId = 0;
+function useGlobalId(idOverride, prefix = "mui") {
+  const [defaultId, setDefaultId] = React.useState(idOverride);
+  const id = idOverride || defaultId;
+  React.useEffect(() => {
+    if (defaultId == null) {
+      globalId += 1;
+      setDefaultId(`${prefix}-${globalId}`);
+    }
+  }, [defaultId, prefix]);
+  return id;
+}
+const maybeReactUseId = SafeReact.useId;
+function useId(idOverride, prefix) {
+  if (maybeReactUseId !== void 0) {
+    const reactId = maybeReactUseId();
+    return idOverride ?? (prefix ? `${prefix}-${reactId}` : reactId);
+  }
+  return useGlobalId(idOverride, prefix);
+}
+export {
+  useId
+};
+//# sourceMappingURL=useId.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useId.js","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":[],"mappings":";;;AAIA;AAGA;AACE;AACA;AACA;AACE;AAKE;AACA;AAAoC;AACtC;AAEF;AACF;AACA;AAQO;AAEL;AACE;AACA;AAAwD;AAK1D;AACF;;;;","x_google_ignoreList":[0]}

package/dist/node_modules/@base-ui/utils/esm/useIsoLayoutEffect.js

@@ -0,0 +1,9 @@
+"use client";
+import * as React from "react";
+const noop = () => {
+};
+const useIsoLayoutEffect = typeof document !== "undefined" ? React.useLayoutEffect : noop;
+export {
+  useIsoLayoutEffect
+};
+//# sourceMappingURL=useIsoLayoutEffect.js.map

package/dist/node_modules/@base-ui/utils/esm/useIsoLayoutEffect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useIsoLayoutEffect.js","sources":["../../../../../node_modules/@base-ui/utils/esm/useIsoLayoutEffect.js"],"sourcesContent":["'use client';\n\nimport * as React from 'react';\nconst noop = () => {};\nexport const useIsoLayoutEffect = typeof document !== 'undefined' ? React.useLayoutEffect : noop;"],"names":[],"mappings":";;AAGA;AAAoB;AACR;;;;","x_google_ignoreList":[0]}

package/dist/node_modules/@base-ui/utils/esm/useMergedRefs.js

@@ -0,0 +1,91 @@
+import { useRefWithInit } from "./useRefWithInit.js";
+function useMergedRefs(a, b, c, d) {
+  const forkRef = useRefWithInit(createForkRef).current;
+  if (didChange(forkRef, a, b, c, d)) {
+    update(forkRef, [a, b, c, d]);
+  }
+  return forkRef.callback;
+}
+function useMergedRefsN(refs) {
+  const forkRef = useRefWithInit(createForkRef).current;
+  if (didChangeN(forkRef, refs)) {
+    update(forkRef, refs);
+  }
+  return forkRef.callback;
+}
+function createForkRef() {
+  return {
+    callback: null,
+    cleanup: null,
+    refs: []
+  };
+}
+function didChange(forkRef, a, b, c, d) {
+  return forkRef.refs[0] !== a || forkRef.refs[1] !== b || forkRef.refs[2] !== c || forkRef.refs[3] !== d;
+}
+function didChangeN(forkRef, newRefs) {
+  return forkRef.refs.length !== newRefs.length || forkRef.refs.some((ref, index) => ref !== newRefs[index]);
+}
+function update(forkRef, refs) {
+  forkRef.refs = refs;
+  if (refs.every((ref) => ref == null)) {
+    forkRef.callback = null;
+    return;
+  }
+  forkRef.callback = (instance) => {
+    if (forkRef.cleanup) {
+      forkRef.cleanup();
+      forkRef.cleanup = null;
+    }
+    if (instance != null) {
+      const cleanupCallbacks = Array(refs.length).fill(null);
+      for (let i = 0; i < refs.length; i += 1) {
+        const ref = refs[i];
+        if (ref == null) {
+          continue;
+        }
+        switch (typeof ref) {
+          case "function": {
+            const refCleanup = ref(instance);
+            if (typeof refCleanup === "function") {
+              cleanupCallbacks[i] = refCleanup;
+            }
+            break;
+          }
+          case "object": {
+            ref.current = instance;
+            break;
+          }
+        }
+      }
+      forkRef.cleanup = () => {
+        for (let i = 0; i < refs.length; i += 1) {
+          const ref = refs[i];
+          if (ref == null) {
+            continue;
+          }
+          switch (typeof ref) {
+            case "function": {
+              const cleanupCallback = cleanupCallbacks[i];
+              if (typeof cleanupCallback === "function") {
+                cleanupCallback();
+              } else {
+                ref(null);
+              }
+              break;
+            }
+            case "object": {
+              ref.current = null;
+              break;
+            }
+          }
+        }
+      };
+    }
+  };
+}
+export {
+  useMergedRefs,
+  useMergedRefsN
+};
+//# sourceMappingURL=useMergedRefs.js.map

package/dist/node_modules/@base-ui/utils/esm/useMergedRefs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useMergedRefs.js","sources":["../../../../../node_modules/@base-ui/utils/esm/useMergedRefs.js"],"sourcesContent":["import { useRefWithInit } from \"./useRefWithInit.js\";\n\n/**\n * Merges refs into a single memoized callback ref or `null`.\n * This makes sure multiple refs are updated together and have the same value.\n *\n * This function accepts up to four refs. If you need to merge more, or have an unspecified number of refs to merge,\n * use `useMergedRefsN` instead.\n */\n\nexport function useMergedRefs(a, b, c, d) {\n  const forkRef = useRefWithInit(createForkRef).current;\n  if (didChange(forkRef, a, b, c, d)) {\n    update(forkRef, [a, b, c, d]);\n  }\n  return forkRef.callback;\n}\n\n/**\n * Merges an array of refs into a single memoized callback ref or `null`.\n *\n * If you need to merge a fixed number (up to four) of refs, use `useMergedRefs` instead for better performance.\n */\nexport function useMergedRefsN(refs) {\n  const forkRef = useRefWithInit(createForkRef).current;\n  if (didChangeN(forkRef, refs)) {\n    update(forkRef, refs);\n  }\n  return forkRef.callback;\n}\nfunction createForkRef() {\n  return {\n    callback: null,\n    cleanup: null,\n    refs: []\n  };\n}\nfunction didChange(forkRef, a, b, c, d) {\n  // prettier-ignore\n  return forkRef.refs[0] !== a || forkRef.refs[1] !== b || forkRef.refs[2] !== c || forkRef.refs[3] !== d;\n}\nfunction didChangeN(forkRef, newRefs) {\n  return forkRef.refs.length !== newRefs.length || forkRef.refs.some((ref, index) => ref !== newRefs[index]);\n}\nfunction update(forkRef, refs) {\n  forkRef.refs = refs;\n  if (refs.every(ref => ref == null)) {\n    forkRef.callback = null;\n    return;\n  }\n  forkRef.callback = instance => {\n    if (forkRef.cleanup) {\n      forkRef.cleanup();\n      forkRef.cleanup = null;\n    }\n    if (instance != null) {\n      const cleanupCallbacks = Array(refs.length).fill(null);\n      for (let i = 0; i < refs.length; i += 1) {\n        const ref = refs[i];\n        if (ref == null) {\n          continue;\n        }\n        switch (typeof ref) {\n          case 'function':\n            {\n              const refCleanup = ref(instance);\n              if (typeof refCleanup === 'function') {\n                cleanupCallbacks[i] = refCleanup;\n              }\n              break;\n            }\n          case 'object':\n            {\n              ref.current = instance;\n              break;\n            }\n          default:\n        }\n      }\n      forkRef.cleanup = () => {\n        for (let i = 0; i < refs.length; i += 1) {\n          const ref = refs[i];\n          if (ref == null) {\n            continue;\n          }\n          switch (typeof ref) {\n            case 'function':\n              {\n                const cleanupCallback = cleanupCallbacks[i];\n                if (typeof cleanupCallback === 'function') {\n                  cleanupCallback();\n                } else {\n                  ref(null);\n                }\n                break;\n              }\n            case 'object':\n              {\n                ref.current = null;\n                break;\n              }\n            default:\n          }\n        }\n      };\n    }\n  };\n}"],"names":[],"mappings":";AAUO,SAAS,cAAc,GAAG,GAAG,GAAG,GAAG;AACxC,QAAM,UAAU,eAAe,aAAa,EAAE;AAC9C,MAAI,UAAU,SAAS,GAAG,GAAG,GAAG,CAAC,GAAG;AAClC,WAAO,SAAS,CAAC,GAAG,GAAG,GAAG,CAAC,CAAC;AAAA,EAC9B;AACA,SAAO,QAAQ;AACjB;AAOO,SAAS,eAAe,MAAM;AACnC,QAAM,UAAU,eAAe,aAAa,EAAE;AAC9C,MAAI,WAAW,SAAS,IAAI,GAAG;AAC7B,WAAO,SAAS,IAAI;AAAA,EACtB;AACA,SAAO,QAAQ;AACjB;AACA,SAAS,gBAAgB;AACvB,SAAO;AAAA,IACL,UAAU;AAAA,IACV,SAAS;AAAA,IACT,MAAM,CAAA;AAAA,EACV;AACA;AACA,SAAS,UAAU,SAAS,GAAG,GAAG,GAAG,GAAG;AAEtC,SAAO,QAAQ,KAAK,CAAC,MAAM,KAAK,QAAQ,KAAK,CAAC,MAAM,KAAK,QAAQ,KAAK,CAAC,MAAM,KAAK,QAAQ,KAAK,CAAC,MAAM;AACxG;AACA,SAAS,WAAW,SAAS,SAAS;AACpC,SAAO,QAAQ,KAAK,WAAW,QAAQ,UAAU,QAAQ,KAAK,KAAK,CAAC,KAAK,UAAU,QAAQ,QAAQ,KAAK,CAAC;AAC3G;AACA,SAAS,OAAO,SAAS,MAAM;AAC7B,UAAQ,OAAO;AACf,MAAI,KAAK,MAAM,SAAO,OAAO,IAAI,GAAG;AAClC,YAAQ,WAAW;AACnB;AAAA,EACF;AACA,UAAQ,WAAW,cAAY;AAC7B,QAAI,QAAQ,SAAS;AACnB,cAAQ,QAAO;AACf,cAAQ,UAAU;AAAA,IACpB;AACA,QAAI,YAAY,MAAM;AACpB,YAAM,mBAAmB,MAAM,KAAK,MAAM,EAAE,KAAK,IAAI;AACrD,eAAS,IAAI,GAAG,IAAI,KAAK,QAAQ,KAAK,GAAG;AACvC,cAAM,MAAM,KAAK,CAAC;AAClB,YAAI,OAAO,MAAM;AACf;AAAA,QACF;AACA,gBAAQ,OAAO,KAAG;AAAA,UAChB,KAAK,YACH;AACE,kBAAM,aAAa,IAAI,QAAQ;AAC/B,gBAAI,OAAO,eAAe,YAAY;AACpC,+BAAiB,CAAC,IAAI;AAAA,YACxB;AACA;AAAA,UACF;AAAA,UACF,KAAK,UACH;AACE,gBAAI,UAAU;AACd;AAAA,UACF;AAAA,QAEZ;AAAA,MACM;AACA,cAAQ,UAAU,MAAM;AACtB,iBAAS,IAAI,GAAG,IAAI,KAAK,QAAQ,KAAK,GAAG;AACvC,gBAAM,MAAM,KAAK,CAAC;AAClB,cAAI,OAAO,MAAM;AACf;AAAA,UACF;AACA,kBAAQ,OAAO,KAAG;AAAA,YAChB,KAAK,YACH;AACE,oBAAM,kBAAkB,iBAAiB,CAAC;AAC1C,kBAAI,OAAO,oBAAoB,YAAY;AACzC,gCAAe;AAAA,cACjB,OAAO;AACL,oBAAI,IAAI;AAAA,cACV;AACA;AAAA,YACF;AAAA,YACF,KAAK,UACH;AACE,kBAAI,UAAU;AACd;AAAA,YACF;AAAA,UAEd;AAAA,QACQ;AAAA,MACF;AAAA,IACF;AAAA,EACF;AACF;","x_google_ignoreList":[0]}

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

@@ -0,0 +1,12 @@
+import * as React from "react";
+function useOnFirstRender(fn) {
+  const ref = React.useRef(true);
+  if (ref.current) {
+    ref.current = false;
+    fn();
+  }
+}
+export {
+  useOnFirstRender
+};
+//# sourceMappingURL=useOnFirstRender.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useOnFirstRender.js","sources":["../../../../../node_modules/@base-ui/utils/esm/useOnFirstRender.js"],"sourcesContent":["import * 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":[],"mappings":";AACO,SAAS,iBAAiB,IAAI;AACnC,QAAM,MAAM,MAAM,OAAO,IAAI;AAC7B,MAAI,IAAI,SAAS;AACf,QAAI,UAAU;AACd,OAAE;AAAA,EACJ;AACF;","x_google_ignoreList":[0]}

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

@@ -0,0 +1,10 @@
+"use client";
+import * as React from "react";
+const EMPTY = [];
+function useOnMount(fn) {
+  React.useEffect(fn, EMPTY);
+}
+export {
+  useOnMount
+};
+//# sourceMappingURL=useOnMount.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useOnMount.js","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":[],"mappings":";;AAGA;AAKO;AAGL;AAEF;;;;","x_google_ignoreList":[0]}

package/dist/node_modules/@base-ui/utils/esm/useRefWithInit.js

@@ -0,0 +1,14 @@
+"use client";
+import * as React from "react";
+const UNINITIALIZED = {};
+function useRefWithInit(init, initArg) {
+  const ref = React.useRef(UNINITIALIZED);
+  if (ref.current === UNINITIALIZED) {
+    ref.current = init(initArg);
+  }
+  return ref;
+}
+export {
+  useRefWithInit
+};
+//# sourceMappingURL=useRefWithInit.js.map

package/dist/node_modules/@base-ui/utils/esm/useRefWithInit.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useRefWithInit.js","sources":["../../../../../node_modules/@base-ui/utils/esm/useRefWithInit.js"],"sourcesContent":["'use client';\n\nimport * as React from 'react';\nconst UNINITIALIZED = {};\n\n/**\n * A React.useRef() that is initialized with a function. Note that it accepts an optional\n * initialization argument, so the initialization function doesn't need to be an inline closure.\n *\n * @usage\n *   const ref = useRefWithInit(sortColumns, columns)\n */\n\nexport function useRefWithInit(init, initArg) {\n  const ref = React.useRef(UNINITIALIZED);\n  if (ref.current === UNINITIALIZED) {\n    ref.current = init(initArg);\n  }\n  return ref;\n}"],"names":[],"mappings":";;AAGA;AAUO;AACL;AACA;AACE;AAA0B;AAE5B;AACF;;;;","x_google_ignoreList":[0]}

package/dist/node_modules/@base-ui/utils/esm/useScrollLock.js

@@ -0,0 +1,181 @@
+"use client";
+import { getWindow, isOverflowElement } from "../../../@floating-ui/utils/dist/floating-ui.utils.dom.js";
+import { isIOS, isWebKit } from "./detectBrowser.js";
+import { ownerDocument } from "./owner.js";
+import { useIsoLayoutEffect } from "./useIsoLayoutEffect.js";
+import { Timeout } from "./useTimeout.js";
+import { AnimationFrame } from "./useAnimationFrame.js";
+import { NOOP } from "./empty.js";
+let originalHtmlStyles = {};
+let originalBodyStyles = {};
+let originalHtmlScrollBehavior = "";
+function hasInsetScrollbars(referenceElement) {
+  if (typeof document === "undefined") {
+    return false;
+  }
+  const doc = ownerDocument(referenceElement);
+  const win = getWindow(doc);
+  return win.innerWidth - doc.documentElement.clientWidth > 0;
+}
+function preventScrollOverlayScrollbars(referenceElement) {
+  const doc = ownerDocument(referenceElement);
+  const html = doc.documentElement;
+  const body = doc.body;
+  const elementToLock = isOverflowElement(html) ? html : body;
+  const originalOverflow = elementToLock.style.overflow;
+  elementToLock.style.overflow = "hidden";
+  return () => {
+    elementToLock.style.overflow = originalOverflow;
+  };
+}
+function preventScrollInsetScrollbars(referenceElement) {
+  const doc = ownerDocument(referenceElement);
+  const html = doc.documentElement;
+  const body = doc.body;
+  const win = getWindow(html);
+  let scrollTop = 0;
+  let scrollLeft = 0;
+  const resizeFrame = AnimationFrame.create();
+  const supportsStableScrollbarGutter = typeof CSS !== "undefined" && CSS.supports?.("scrollbar-gutter", "stable");
+  if (isWebKit && (win.visualViewport?.scale ?? 1) !== 1) {
+    return () => {
+    };
+  }
+  function lockScroll() {
+    const htmlStyles = win.getComputedStyle(html);
+    const bodyStyles = win.getComputedStyle(body);
+    const htmlScrollbarGutterValue = htmlStyles.scrollbarGutter || "";
+    const hasBothEdges = htmlScrollbarGutterValue.includes("both-edges");
+    const scrollbarGutterValue = hasBothEdges ? "stable both-edges" : "stable";
+    scrollTop = html.scrollTop;
+    scrollLeft = html.scrollLeft;
+    originalHtmlStyles = {
+      scrollbarGutter: html.style.scrollbarGutter,
+      overflowY: html.style.overflowY,
+      overflowX: html.style.overflowX
+    };
+    originalHtmlScrollBehavior = html.style.scrollBehavior;
+    originalBodyStyles = {
+      position: body.style.position,
+      height: body.style.height,
+      width: body.style.width,
+      boxSizing: body.style.boxSizing,
+      overflowY: body.style.overflowY,
+      overflowX: body.style.overflowX,
+      scrollBehavior: body.style.scrollBehavior
+    };
+    const isScrollableY = html.scrollHeight > html.clientHeight;
+    const isScrollableX = html.scrollWidth > html.clientWidth;
+    const hasConstantOverflowY = htmlStyles.overflowY === "scroll" || bodyStyles.overflowY === "scroll";
+    const hasConstantOverflowX = htmlStyles.overflowX === "scroll" || bodyStyles.overflowX === "scroll";
+    const scrollbarWidth = Math.max(0, win.innerWidth - html.clientWidth);
+    const scrollbarHeight = Math.max(0, win.innerHeight - html.clientHeight);
+    const marginY = parseFloat(bodyStyles.marginTop) + parseFloat(bodyStyles.marginBottom);
+    const marginX = parseFloat(bodyStyles.marginLeft) + parseFloat(bodyStyles.marginRight);
+    const elementToLock = isOverflowElement(html) ? html : body;
+    if (supportsStableScrollbarGutter) {
+      html.style.scrollbarGutter = scrollbarGutterValue;
+      elementToLock.style.overflowY = "hidden";
+      elementToLock.style.overflowX = "hidden";
+      return;
+    }
+    Object.assign(html.style, {
+      scrollbarGutter: scrollbarGutterValue,
+      overflowY: "hidden",
+      overflowX: "hidden"
+    });
+    if (isScrollableY || hasConstantOverflowY) {
+      html.style.overflowY = "scroll";
+    }
+    if (isScrollableX || hasConstantOverflowX) {
+      html.style.overflowX = "scroll";
+    }
+    Object.assign(body.style, {
+      position: "relative",
+      height: marginY || scrollbarHeight ? `calc(100dvh - ${marginY + scrollbarHeight}px)` : "100dvh",
+      width: marginX || scrollbarWidth ? `calc(100vw - ${marginX + scrollbarWidth}px)` : "100vw",
+      boxSizing: "border-box",
+      overflow: "hidden",
+      scrollBehavior: "unset"
+    });
+    body.scrollTop = scrollTop;
+    body.scrollLeft = scrollLeft;
+    html.setAttribute("data-base-ui-scroll-locked", "");
+    html.style.scrollBehavior = "unset";
+  }
+  function cleanup() {
+    Object.assign(html.style, originalHtmlStyles);
+    Object.assign(body.style, originalBodyStyles);
+    if (!supportsStableScrollbarGutter) {
+      html.scrollTop = scrollTop;
+      html.scrollLeft = scrollLeft;
+      html.removeAttribute("data-base-ui-scroll-locked");
+      html.style.scrollBehavior = originalHtmlScrollBehavior;
+    }
+  }
+  function handleResize() {
+    cleanup();
+    resizeFrame.request(lockScroll);
+  }
+  lockScroll();
+  win.addEventListener("resize", handleResize);
+  return () => {
+    resizeFrame.cancel();
+    cleanup();
+    if (typeof win.removeEventListener === "function") {
+      win.removeEventListener("resize", handleResize);
+    }
+  };
+}
+class ScrollLocker {
+  lockCount = 0;
+  restore = null;
+  timeoutLock = Timeout.create();
+  timeoutUnlock = Timeout.create();
+  acquire(referenceElement) {
+    this.lockCount += 1;
+    if (this.lockCount === 1 && this.restore === null) {
+      this.timeoutLock.start(0, () => this.lock(referenceElement));
+    }
+    return this.release;
+  }
+  release = () => {
+    this.lockCount -= 1;
+    if (this.lockCount === 0 && this.restore) {
+      this.timeoutUnlock.start(0, this.unlock);
+    }
+  };
+  unlock = () => {
+    if (this.lockCount === 0 && this.restore) {
+      this.restore?.();
+      this.restore = null;
+    }
+  };
+  lock(referenceElement) {
+    if (this.lockCount === 0 || this.restore !== null) {
+      return;
+    }
+    const doc = ownerDocument(referenceElement);
+    const html = doc.documentElement;
+    const htmlOverflowY = getWindow(html).getComputedStyle(html).overflowY;
+    if (htmlOverflowY === "hidden" || htmlOverflowY === "clip") {
+      this.restore = NOOP;
+      return;
+    }
+    const hasOverlayScrollbars = isIOS || !hasInsetScrollbars(referenceElement);
+    this.restore = hasOverlayScrollbars ? preventScrollOverlayScrollbars(referenceElement) : preventScrollInsetScrollbars(referenceElement);
+  }
+}
+const SCROLL_LOCKER = new ScrollLocker();
+function useScrollLock(enabled = true, referenceElement = null) {
+  useIsoLayoutEffect(() => {
+    if (!enabled) {
+      return void 0;
+    }
+    return SCROLL_LOCKER.acquire(referenceElement);
+  }, [enabled, referenceElement]);
+}
+export {
+  useScrollLock
+};
+//# sourceMappingURL=useScrollLock.js.map

package/dist/node_modules/@base-ui/utils/esm/useScrollLock.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useScrollLock.js","sources":["../../../../../node_modules/@base-ui/utils/esm/useScrollLock.js"],"sourcesContent":["'use client';\n\nimport { isOverflowElement } from '@floating-ui/utils/dom';\nimport { isIOS, isWebKit } from \"./detectBrowser.js\";\nimport { ownerDocument, ownerWindow } from \"./owner.js\";\nimport { useIsoLayoutEffect } from \"./useIsoLayoutEffect.js\";\nimport { Timeout } from \"./useTimeout.js\";\nimport { AnimationFrame } from \"./useAnimationFrame.js\";\nimport { NOOP } from \"./empty.js\";\n\n/* eslint-disable lines-between-class-members */\n\nlet originalHtmlStyles = {};\nlet originalBodyStyles = {};\nlet originalHtmlScrollBehavior = '';\nfunction hasInsetScrollbars(referenceElement) {\n  if (typeof document === 'undefined') {\n    return false;\n  }\n  const doc = ownerDocument(referenceElement);\n  const win = ownerWindow(doc);\n  return win.innerWidth - doc.documentElement.clientWidth > 0;\n}\nfunction preventScrollOverlayScrollbars(referenceElement) {\n  const doc = ownerDocument(referenceElement);\n  const html = doc.documentElement;\n  const body = doc.body;\n\n  // If an `overflow` style is present on <html>, we need to lock it, because a lock on <body>\n  // won't have any effect.\n  // But if <body> has an `overflow` style (like `overflow-x: hidden`), we need to lock it\n  // instead, as sticky elements shift otherwise.\n  const elementToLock = isOverflowElement(html) ? html : body;\n  const originalOverflow = elementToLock.style.overflow;\n  elementToLock.style.overflow = 'hidden';\n  return () => {\n    elementToLock.style.overflow = originalOverflow;\n  };\n}\nfunction preventScrollInsetScrollbars(referenceElement) {\n  const doc = ownerDocument(referenceElement);\n  const html = doc.documentElement;\n  const body = doc.body;\n  const win = ownerWindow(html);\n  let scrollTop = 0;\n  let scrollLeft = 0;\n  const resizeFrame = AnimationFrame.create();\n\n  // Handle `scrollbar-gutter` in Chrome when there is no scrollable content.\n  const supportsStableScrollbarGutter = typeof CSS !== 'undefined' && CSS.supports?.('scrollbar-gutter', 'stable');\n\n  // Pinch-zoom in Safari causes a shift. Just don't lock scroll if there's any pinch-zoom.\n  if (isWebKit && (win.visualViewport?.scale ?? 1) !== 1) {\n    return () => {};\n  }\n  function lockScroll() {\n    /* DOM reads: */\n\n    const htmlStyles = win.getComputedStyle(html);\n    const bodyStyles = win.getComputedStyle(body);\n    const htmlScrollbarGutterValue = htmlStyles.scrollbarGutter || '';\n    const hasBothEdges = htmlScrollbarGutterValue.includes('both-edges');\n    const scrollbarGutterValue = hasBothEdges ? 'stable both-edges' : 'stable';\n    scrollTop = html.scrollTop;\n    scrollLeft = html.scrollLeft;\n    originalHtmlStyles = {\n      scrollbarGutter: html.style.scrollbarGutter,\n      overflowY: html.style.overflowY,\n      overflowX: html.style.overflowX\n    };\n    originalHtmlScrollBehavior = html.style.scrollBehavior;\n    originalBodyStyles = {\n      position: body.style.position,\n      height: body.style.height,\n      width: body.style.width,\n      boxSizing: body.style.boxSizing,\n      overflowY: body.style.overflowY,\n      overflowX: body.style.overflowX,\n      scrollBehavior: body.style.scrollBehavior\n    };\n    const isScrollableY = html.scrollHeight > html.clientHeight;\n    const isScrollableX = html.scrollWidth > html.clientWidth;\n    const hasConstantOverflowY = htmlStyles.overflowY === 'scroll' || bodyStyles.overflowY === 'scroll';\n    const hasConstantOverflowX = htmlStyles.overflowX === 'scroll' || bodyStyles.overflowX === 'scroll';\n\n    // Values can be negative in Firefox\n    const scrollbarWidth = Math.max(0, win.innerWidth - html.clientWidth);\n    const scrollbarHeight = Math.max(0, win.innerHeight - html.clientHeight);\n\n    // Avoid shift due to the default <body> margin. This does cause elements to be clipped\n    // with whitespace. Warn if <body> has margins?\n    const marginY = parseFloat(bodyStyles.marginTop) + parseFloat(bodyStyles.marginBottom);\n    const marginX = parseFloat(bodyStyles.marginLeft) + parseFloat(bodyStyles.marginRight);\n    const elementToLock = isOverflowElement(html) ? html : body;\n\n    /*\n     * DOM writes:\n     * Do not read the DOM past this point!\n     */\n\n    if (supportsStableScrollbarGutter) {\n      html.style.scrollbarGutter = scrollbarGutterValue;\n      elementToLock.style.overflowY = 'hidden';\n      elementToLock.style.overflowX = 'hidden';\n      return;\n    }\n    Object.assign(html.style, {\n      scrollbarGutter: scrollbarGutterValue,\n      overflowY: 'hidden',\n      overflowX: 'hidden'\n    });\n    if (isScrollableY || hasConstantOverflowY) {\n      html.style.overflowY = 'scroll';\n    }\n    if (isScrollableX || hasConstantOverflowX) {\n      html.style.overflowX = 'scroll';\n    }\n    Object.assign(body.style, {\n      position: 'relative',\n      height: marginY || scrollbarHeight ? `calc(100dvh - ${marginY + scrollbarHeight}px)` : '100dvh',\n      width: marginX || scrollbarWidth ? `calc(100vw - ${marginX + scrollbarWidth}px)` : '100vw',\n      boxSizing: 'border-box',\n      overflow: 'hidden',\n      scrollBehavior: 'unset'\n    });\n    body.scrollTop = scrollTop;\n    body.scrollLeft = scrollLeft;\n    html.setAttribute('data-base-ui-scroll-locked', '');\n    html.style.scrollBehavior = 'unset';\n  }\n  function cleanup() {\n    Object.assign(html.style, originalHtmlStyles);\n    Object.assign(body.style, originalBodyStyles);\n    if (!supportsStableScrollbarGutter) {\n      html.scrollTop = scrollTop;\n      html.scrollLeft = scrollLeft;\n      html.removeAttribute('data-base-ui-scroll-locked');\n      html.style.scrollBehavior = originalHtmlScrollBehavior;\n    }\n  }\n  function handleResize() {\n    cleanup();\n    resizeFrame.request(lockScroll);\n  }\n  lockScroll();\n  win.addEventListener('resize', handleResize);\n  return () => {\n    resizeFrame.cancel();\n    cleanup();\n    // Sometimes this cleanup can be run after test teardown\n    // because it is called in a `setTimeout(fn, 0)`,\n    // in which case `removeEventListener` wouldn't be available,\n    // so we check for it to avoid test failures.\n    if (typeof win.removeEventListener === 'function') {\n      win.removeEventListener('resize', handleResize);\n    }\n  };\n}\nclass ScrollLocker {\n  lockCount = 0;\n  restore = null;\n  timeoutLock = Timeout.create();\n  timeoutUnlock = Timeout.create();\n  acquire(referenceElement) {\n    this.lockCount += 1;\n    if (this.lockCount === 1 && this.restore === null) {\n      this.timeoutLock.start(0, () => this.lock(referenceElement));\n    }\n    return this.release;\n  }\n  release = () => {\n    this.lockCount -= 1;\n    if (this.lockCount === 0 && this.restore) {\n      this.timeoutUnlock.start(0, this.unlock);\n    }\n  };\n  unlock = () => {\n    if (this.lockCount === 0 && this.restore) {\n      this.restore?.();\n      this.restore = null;\n    }\n  };\n  lock(referenceElement) {\n    if (this.lockCount === 0 || this.restore !== null) {\n      return;\n    }\n    const doc = ownerDocument(referenceElement);\n    const html = doc.documentElement;\n    const htmlOverflowY = ownerWindow(html).getComputedStyle(html).overflowY;\n\n    // If the site author already hid overflow on <html>, respect it and bail out.\n    if (htmlOverflowY === 'hidden' || htmlOverflowY === 'clip') {\n      this.restore = NOOP;\n      return;\n    }\n    const hasOverlayScrollbars = isIOS || !hasInsetScrollbars(referenceElement);\n\n    // On iOS, scroll locking does not work if the navbar is collapsed. Due to numerous\n    // side effects and bugs that arise on iOS, it must be researched extensively before\n    // being enabled to ensure it doesn't cause the following issues:\n    // - Textboxes must scroll into view when focused, nor cause a glitchy scroll animation.\n    // - The navbar must not force itself into view and cause layout shift.\n    // - Scroll containers must not flicker upon closing a popup when it has an exit animation.\n    this.restore = hasOverlayScrollbars ? preventScrollOverlayScrollbars(referenceElement) : preventScrollInsetScrollbars(referenceElement);\n  }\n}\nconst SCROLL_LOCKER = new ScrollLocker();\n\n/**\n * Locks the scroll of the document when enabled.\n *\n * @param enabled - Whether to enable the scroll lock.\n * @param referenceElement - Element to use as a reference for lock calculations.\n */\nexport function useScrollLock(enabled = true, referenceElement = null) {\n  useIsoLayoutEffect(() => {\n    if (!enabled) {\n      return undefined;\n    }\n    return SCROLL_LOCKER.acquire(referenceElement);\n  }, [enabled, referenceElement]);\n}"],"names":[],"mappings":";;;;;;;;AAYA;AACA;AACA;AACA;AACE;AACE;AAAO;AAET;AACA;AACA;AACF;AACA;AACE;AACA;AACA;AAMA;AACA;AACA;AACA;AACE;AAA+B;AAEnC;AACA;AACE;AACA;AACA;AACA;AACA;AACA;AACA;AAGA;AAGA;AACE;AAAa;AAAC;AAEhB;AAGE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AAAqB;AACS;AACN;AACA;AAExB;AACA;AAAqB;AACE;AACF;AACD;AACI;AACA;AACA;AACK;AAE7B;AACA;AACA;AACA;AAGA;AACA;AAIA;AACA;AACA;AAOA;AACE;AACA;AACA;AACA;AAAA;AAEF;AAA0B;AACP;AACN;AACA;AAEb;AACE;AAAuB;AAEzB;AACE;AAAuB;AAEzB;AAA0B;AACd;AAC6E;AACJ;AACxE;AACD;AACM;AAElB;AACA;AACA;AACA;AAA4B;AAE9B;AACE;AACA;AACA;AACE;AACA;AACA;AACA;AAA4B;AAC9B;AAEF;AACE;AACA;AAA8B;AAEhC;AACA;AACA;AACE;AACA;AAKA;AACE;AAA8C;AAChD;AAEJ;AACA;AAAmB;AACL;AACF;AACkB;AACE;AAE5B;AACA;AACE;AAA2D;AAE7D;AAAY;AACd;AAEE;AACA;AACE;AAAuC;AACzC;AACF;AAEE;AACE;AACA;AAAe;AACjB;AACF;AAEE;AACE;AAAA;AAEF;AACA;AACA;AAGA;AACE;AACA;AAAA;AAEF;AAQA;AAAsI;AAE1I;AACA;AAQO;AACL;AACE;AACE;AAAO;AAET;AAA6C;AAEjD;;;;","x_google_ignoreList":[0]}

package/dist/node_modules/@base-ui/utils/esm/useStableCallback.js

@@ -0,0 +1,35 @@
+"use client";
+import * as React from "react";
+import { useRefWithInit } from "./useRefWithInit.js";
+const useInsertionEffect = React[`useInsertionEffect${Math.random().toFixed(1)}`.slice(0, -3)];
+const useSafeInsertionEffect = (
+  // React 17 doesn't have useInsertionEffect.
+  useInsertionEffect && // Preact replaces useInsertionEffect with useLayoutEffect and fires too late.
+  useInsertionEffect !== React.useLayoutEffect ? useInsertionEffect : (fn) => fn()
+);
+function useStableCallback(callback) {
+  const stable = useRefWithInit(createStableCallback).current;
+  stable.next = callback;
+  useSafeInsertionEffect(stable.effect);
+  return stable.trampoline;
+}
+function createStableCallback() {
+  const stable = {
+    next: void 0,
+    callback: assertNotCalled,
+    trampoline: (...args) => stable.callback?.(...args),
+    effect: () => {
+      stable.callback = stable.next;
+    }
+  };
+  return stable;
+}
+function assertNotCalled() {
+  if (process.env.NODE_ENV !== "production") {
+    throw new Error("Base UI: Cannot call an event handler while rendering.");
+  }
+}
+export {
+  useStableCallback
+};
+//# sourceMappingURL=useStableCallback.js.map

package/dist/node_modules/@base-ui/utils/esm/useStableCallback.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useStableCallback.js","sources":["../../../../../node_modules/@base-ui/utils/esm/useStableCallback.js"],"sourcesContent":["'use client';\n\nimport * as React from 'react';\nimport { useRefWithInit } from \"./useRefWithInit.js\";\n\n// https://github.com/mui/material-ui/issues/41190#issuecomment-2040873379\nconst useInsertionEffect = React[`useInsertionEffect${Math.random().toFixed(1)}`.slice(0, -3)];\nconst useSafeInsertionEffect =\n// React 17 doesn't have useInsertionEffect.\nuseInsertionEffect &&\n// Preact replaces useInsertionEffect with useLayoutEffect and fires too late.\nuseInsertionEffect !== React.useLayoutEffect ? useInsertionEffect : fn => fn();\n/**\n * Stabilizes the function passed so it's always the same between renders.\n *\n * The function becomes non-reactive to any values it captures.\n * It can safely be passed as a dependency of `React.useMemo` and `React.useEffect` without re-triggering them if its captured values change.\n *\n * The function must only be called inside effects and event handlers, never during render (which throws an error).\n *\n * This hook is a more permissive version of React 19.2's `React.useEffectEvent` in that it can be passed through contexts and called in event handler props, not just effects.\n */\nexport function useStableCallback(callback) {\n  const stable = useRefWithInit(createStableCallback).current;\n  stable.next = callback;\n  useSafeInsertionEffect(stable.effect);\n  return stable.trampoline;\n}\nfunction createStableCallback() {\n  const stable = {\n    next: undefined,\n    callback: assertNotCalled,\n    trampoline: (...args) => stable.callback?.(...args),\n    effect: () => {\n      stable.callback = stable.next;\n    }\n  };\n  return stable;\n}\nfunction assertNotCalled() {\n  if (process.env.NODE_ENV !== 'production') {\n    throw new Error('Base UI: Cannot call an event handler while rendering.');\n  }\n}"],"names":[],"mappings":";;;AAMA;AACA;AAAM;AAAA;AAEN;AAE4E;AAWrE;AACL;AACA;AACA;AACA;AACF;AACA;AACE;AAAe;AACP;AACI;AACwC;AAEhD;AAAyB;AAC3B;AAEF;AACF;AACA;AACE;AACE;AAAwE;AAE5E;;;;","x_google_ignoreList":[0]}