@qredence/fleet 0.6.0 → 0.6.1

package/dist/web/server/{chunk-C5X6G26O.js → chunk-XIB6XNUX.js}

@@ -1,7 +1,58 @@
-// web/app/dist/server/assets/createBaseUIEventDetails-BA7pBwxQ.js
+// web/app/dist/server/assets/createBaseUIEventDetails-hMAk6i9b.js
 import * as React$1 from "react";
 import { createElement as createElement2 } from "react";
 import * as ReactDOM from "react-dom";
+function NOOP() {
+}
+var EMPTY_ARRAY = Object.freeze([]);
+var EMPTY_OBJECT = Object.freeze({});
+function useOnMount(fn) {
+  React$1.useEffect(fn, EMPTY_ARRAY);
+}
+var UNINITIALIZED = {};
+function useRefWithInit(init, initArg) {
+  const ref = React$1.useRef(UNINITIALIZED);
+  if (ref.current === UNINITIALIZED) ref.current = init(initArg);
+  return ref;
+}
+var noop = () => {
+};
+var useIsoLayoutEffect = typeof document !== "undefined" ? React$1.useLayoutEffect : noop;
+function createFormatErrorMessage(baseUrl, prefix) {
+  return function formatErrorMessage2(code, ...args) {
+    const url = new URL(baseUrl);
+    url.searchParams.set("code", code.toString());
+    args.forEach((arg) => url.searchParams.append("args[]", arg));
+    return `${prefix} error #${code}; visit ${url} for the full message.`;
+  };
+}
+var formatErrorMessage = createFormatErrorMessage("https://base-ui.com/production-error", "Base UI");
+var majorVersion = parseInt(React$1.version, 10);
+function isReactVersionAtLeast(reactVersionToCheck) {
+  return majorVersion >= reactVersionToCheck;
+}
+var SafeReact = { ...React$1 };
+var useInsertionEffect$1 = SafeReact.useInsertionEffect;
+var useSafeInsertionEffect = useInsertionEffect$1 && useInsertionEffect$1 !== SafeReact.useLayoutEffect ? useInsertionEffect$1 : (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() {
+}
 function hasWindow() {
   return typeof window !== "undefined";
 }
@@ -114,37 +165,163 @@ function getOverflowAncestors(node, list, traverseIframes) {
 function getFrameElement(win) {
   return win.parent && Object.getPrototypeOf(win.parent) ? win.frameElement : null;
 }
-var SafeReact = { ...React$1 };
-var UNINITIALIZED = {};
-function useRefWithInit(init, initArg) {
-  const ref = React$1.useRef(UNINITIALIZED);
-  if (ref.current === UNINITIALIZED) ref.current = init(initArg);
-  return ref;
+function addEventListener(target, type, listener, options) {
+  target.addEventListener(type, listener, options);
+  return () => {
+    target.removeEventListener(type, listener, options);
+  };
 }
-var useInsertionEffect$1 = SafeReact.useInsertionEffect;
-var useSafeInsertionEffect = useInsertionEffect$1 && useInsertionEffect$1 !== SafeReact.useLayoutEffect ? useInsertionEffect$1 : (fn) => fn();
-function useStableCallback(callback) {
-  const stable = useRefWithInit(createStableCallback).current;
-  stable.next = callback;
-  useSafeInsertionEffect(stable.effect);
-  return stable.trampoline;
+var EMPTY = null;
+globalThis.requestAnimationFrame;
+var Scheduler = class {
+  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;
+    if (!this.isScheduled || false) {
+      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;
+  }
+};
+var scheduler = new Scheduler();
+var AnimationFrame = class AnimationFrame2 {
+  static create() {
+    return new AnimationFrame2();
+  }
+  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;
 }
-function createStableCallback() {
-  const stable = {
-    next: void 0,
-    callback: assertNotCalled,
-    trampoline: (...args) => stable.callback?.(...args),
-    effect: () => {
-      stable.callback = stable.next;
+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;
+        }
+      }
+      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;
+          }
+        }
+      };
     }
   };
-  return stable;
 }
-function assertNotCalled() {
+function getReactElementRef(element) {
+  if (!/* @__PURE__ */ React$1.isValidElement(element)) return null;
+  const reactElement = element;
+  const propsWithRef = reactElement.props;
+  return (isReactVersionAtLeast(19) ? propsWithRef?.ref : reactElement.ref) ?? null;
 }
-var noop = () => {
-};
-var useIsoLayoutEffect = typeof document !== "undefined" ? React$1.useLayoutEffect : noop;
 function mergeObjects(a, b) {
   if (a && !b) return a;
   if (!a && b) return b;
@@ -153,6 +330,26 @@ function mergeObjects(a, b) {
     ...b
   };
 }
+function getStateAttributesProps(state, customMapping) {
+  const props = {};
+  for (const key in state) {
+    const value = state[key];
+    if (customMapping?.hasOwnProperty(key)) {
+      const customProps = customMapping[key](value);
+      if (customProps != null) Object.assign(props, customProps);
+      continue;
+    }
+    if (value === true) props[`data-${key.toLowerCase()}`] = "";
+    else if (value) props[`data-${key.toLowerCase()}`] = value.toString();
+  }
+  return props;
+}
+function resolveClassName(className, state) {
+  return typeof className === "function" ? className(state) : className;
+}
+function resolveStyle(style, state) {
+  return typeof style === "function" ? style(state) : style;
+}
 var EMPTY_PROPS = {};
 function mergeProps(a, b, c, d, e) {
   if (!c && !d && !e && !a) return createInitialMergedProps(b);
@@ -258,275 +455,6 @@ function mergeClassNames(ourClassName, theirClassName) {
 function isSyntheticEvent(event) {
   return event != null && typeof event === "object" && "nativeEvent" in event;
 }
-function createFormatErrorMessage(baseUrl, prefix) {
-  return function formatErrorMessage2(code, ...args) {
-    const url = new URL(baseUrl);
-    url.searchParams.set("code", code.toString());
-    args.forEach((arg) => url.searchParams.append("args[]", arg));
-    return `${prefix} error #${code}; visit ${url} for the full message.`;
-  };
-}
-var formatErrorMessage = createFormatErrorMessage("https://base-ui.com/production-error", "Base UI");
-var CompositeRootContext = /* @__PURE__ */ React$1.createContext(void 0);
-function useCompositeRootContext(optional = false) {
-  const context = React$1.useContext(CompositeRootContext);
-  if (context === void 0 && !optional) throw new Error(formatErrorMessage(16));
-  return context;
-}
-function useFocusableWhenDisabled(parameters) {
-  const { focusableWhenDisabled, disabled: disabled2, composite = false, tabIndex: tabIndexProp = 0, isNativeButton } = parameters;
-  const isFocusableComposite = composite && focusableWhenDisabled !== false;
-  const isNonFocusableComposite = composite && focusableWhenDisabled === false;
-  return { props: React$1.useMemo(() => {
-    const additionalProps = { onKeyDown(event) {
-      if (disabled2 && focusableWhenDisabled && event.key !== "Tab") event.preventDefault();
-    } };
-    if (!composite) {
-      additionalProps.tabIndex = tabIndexProp;
-      if (!isNativeButton && disabled2) additionalProps.tabIndex = focusableWhenDisabled ? tabIndexProp : -1;
-    }
-    if (isNativeButton && (focusableWhenDisabled || isFocusableComposite) || !isNativeButton && disabled2) additionalProps["aria-disabled"] = disabled2;
-    if (isNativeButton && (!focusableWhenDisabled || isNonFocusableComposite)) additionalProps.disabled = disabled2;
-    return additionalProps;
-  }, [
-    composite,
-    disabled2,
-    focusableWhenDisabled,
-    isFocusableComposite,
-    isNonFocusableComposite,
-    isNativeButton,
-    tabIndexProp
-  ]) };
-}
-function dispatchClickWithModifiers(target, sourceEvent, { detail = 0 } = {}) {
-  target.dispatchEvent(new (getWindow(target)).PointerEvent("click", {
-    bubbles: true,
-    cancelable: true,
-    composed: true,
-    detail,
-    shiftKey: sourceEvent.shiftKey,
-    ctrlKey: sourceEvent.ctrlKey,
-    altKey: sourceEvent.altKey,
-    metaKey: sourceEvent.metaKey
-  }));
-}
-function useButton(parameters = {}) {
-  const { disabled: disabled2 = false, focusableWhenDisabled, tabIndex = 0, native: isNativeButton = true, composite: compositeProp } = parameters;
-  const elementRef = React$1.useRef(null);
-  const compositeRootContext = useCompositeRootContext(true);
-  const isCompositeItem = compositeProp ?? compositeRootContext !== void 0;
-  const { props: focusableWhenDisabledProps } = useFocusableWhenDisabled({
-    focusableWhenDisabled,
-    disabled: disabled2,
-    composite: isCompositeItem,
-    tabIndex,
-    isNativeButton
-  });
-  const updateDisabled = React$1.useCallback(() => {
-    const element = elementRef.current;
-    if (!isButtonElement(element)) return;
-    if (isCompositeItem && disabled2 && focusableWhenDisabledProps.disabled === void 0 && element.disabled) element.disabled = false;
-  }, [
-    disabled2,
-    focusableWhenDisabledProps.disabled,
-    isCompositeItem
-  ]);
-  useIsoLayoutEffect(updateDisabled, [updateDisabled]);
-  return {
-    getButtonProps: React$1.useCallback((externalProps = {}) => {
-      const { onClick: externalOnClick, onMouseDown: externalOnMouseDown, onKeyUp: externalOnKeyUp, onKeyDown: externalOnKeyDown, onPointerDown: externalOnPointerDown, ...otherExternalProps } = externalProps;
-      return mergeProps({
-        onClick(event) {
-          if (disabled2) {
-            event.preventDefault();
-            return;
-          }
-          externalOnClick?.(event);
-        },
-        onMouseDown(event) {
-          if (!disabled2) externalOnMouseDown?.(event);
-        },
-        onKeyDown(event) {
-          if (disabled2) return;
-          makeEventPreventable(event);
-          externalOnKeyDown?.(event);
-          if (event.baseUIHandlerPrevented) return;
-          const isCurrentTarget = event.target === event.currentTarget;
-          const currentTarget = event.currentTarget;
-          const isButton = isButtonElement(currentTarget);
-          const isLink = !isNativeButton && isValidLinkElement(currentTarget);
-          const shouldClick = isCurrentTarget && (isNativeButton ? isButton : !isLink);
-          const isEnterKey = event.key === "Enter";
-          const isSpaceKey = event.key === " ";
-          const role = currentTarget.getAttribute("role");
-          const isTextNavigationRole = role?.startsWith("menuitem") || role === "option" || role === "gridcell";
-          if (isCurrentTarget && isCompositeItem && isSpaceKey) {
-            if (event.defaultPrevented && isTextNavigationRole) return;
-            event.preventDefault();
-            if (!isNativeButton || isButton) {
-              event.preventBaseUIHandler();
-              dispatchClickWithModifiers(currentTarget, event);
-            }
-            return;
-          }
-          if (!shouldClick || isNativeButton || !isSpaceKey && !isEnterKey) {
-            if (isCurrentTarget && isLink && isSpaceKey) event.preventDefault();
-            return;
-          }
-          if (event.defaultPrevented) return;
-          event.preventDefault();
-          if (isEnterKey) {
-            event.preventBaseUIHandler();
-            dispatchClickWithModifiers(currentTarget, event);
-          }
-        },
-        onKeyUp(event) {
-          if (disabled2) return;
-          makeEventPreventable(event);
-          externalOnKeyUp?.(event);
-          if (event.target === event.currentTarget && isNativeButton && isCompositeItem && isButtonElement(event.currentTarget) && event.key === " ") {
-            event.preventDefault();
-            return;
-          }
-          if (event.baseUIHandlerPrevented) return;
-          if (event.target === event.currentTarget && !isNativeButton && !isCompositeItem && !event.defaultPrevented && event.key === " ") {
-            event.preventBaseUIHandler();
-            dispatchClickWithModifiers(event.currentTarget, event);
-          }
-        },
-        onPointerDown(event) {
-          if (disabled2) {
-            event.preventDefault();
-            return;
-          }
-          externalOnPointerDown?.(event);
-        }
-      }, isNativeButton ? { type: "button" } : { role: "button" }, focusableWhenDisabledProps, otherExternalProps);
-    }, [
-      disabled2,
-      focusableWhenDisabledProps,
-      isCompositeItem,
-      isNativeButton
-    ]),
-    buttonRef: useStableCallback((element) => {
-      elementRef.current = element;
-      updateDisabled();
-    })
-  };
-}
-function isButtonElement(elem) {
-  return isHTMLElement(elem) && elem.tagName === "BUTTON";
-}
-function isValidLinkElement(elem) {
-  return isHTMLElement(elem) && elem.tagName === "A" && Boolean(elem.href);
-}
-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;
-        }
-      }
-      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;
-          }
-        }
-      };
-    }
-  };
-}
-var majorVersion = parseInt(React$1.version, 10);
-function isReactVersionAtLeast(reactVersionToCheck) {
-  return majorVersion >= reactVersionToCheck;
-}
-function getReactElementRef(element) {
-  if (!/* @__PURE__ */ React$1.isValidElement(element)) return null;
-  const reactElement = element;
-  const propsWithRef = reactElement.props;
-  return (isReactVersionAtLeast(19) ? propsWithRef?.ref : reactElement.ref) ?? null;
-}
-function NOOP() {
-}
-var EMPTY_ARRAY = Object.freeze([]);
-var EMPTY_OBJECT = Object.freeze({});
-function getStateAttributesProps(state, customMapping) {
-  const props = {};
-  for (const key in state) {
-    const value = state[key];
-    if (customMapping?.hasOwnProperty(key)) {
-      const customProps = customMapping[key](value);
-      if (customProps != null) Object.assign(props, customProps);
-      continue;
-    }
-    if (value === true) props[`data-${key.toLowerCase()}`] = "";
-    else if (value) props[`data-${key.toLowerCase()}`] = value.toString();
-  }
-  return props;
-}
-function resolveClassName(className, state) {
-  return typeof className === "function" ? className(state) : className;
-}
-function resolveStyle(style, state) {
-  return typeof style === "function" ? style(state) : style;
-}
 function useRenderElement(element, componentProps, params = {}) {
   const renderProp = componentProps.render;
   const outProps = useRenderElementProps(componentProps, params);
@@ -540,133 +468,52 @@ function useRenderElementProps(componentProps, params = {}) {
   const style = enabled ? resolveStyle(styleProp, state) : void 0;
   const stateProps = enabled ? getStateAttributesProps(state, stateAttributesMapping) : EMPTY_OBJECT;
   const resolvedProps = enabled && props ? resolveRenderFunctionProps(props) : void 0;
-  const outProps = enabled ? mergeObjects(stateProps, resolvedProps) ?? {} : EMPTY_OBJECT;
-  if (typeof document !== "undefined") {
-    if (!enabled) useMergedRefs(null, null);
-    else if (Array.isArray(ref)) outProps.ref = useMergedRefsN([
-      outProps.ref,
-      getReactElementRef(renderProp),
-      ...ref
-    ]);
-    else outProps.ref = useMergedRefs(outProps.ref, getReactElementRef(renderProp), ref);
-  }
-  if (!enabled) return EMPTY_OBJECT;
-  if (className !== void 0) outProps.className = mergeClassNames(outProps.className, className);
-  if (style !== void 0) outProps.style = mergeObjects(outProps.style, style);
-  return outProps;
-}
-function resolveRenderFunctionProps(props) {
-  if (Array.isArray(props)) return mergePropsN(props);
-  return mergeProps(void 0, props);
-}
-var REACT_LAZY_TYPE = /* @__PURE__ */ Symbol.for("react.lazy");
-function evaluateRenderProp(element, render, props, state) {
-  if (render) {
-    if (typeof render === "function") return render(props, state);
-    const mergedProps = mergeProps(props, render.props);
-    mergedProps.ref = props.ref;
-    let newElement = render;
-    if (newElement?.$$typeof === REACT_LAZY_TYPE) newElement = React$1.Children.toArray(render)[0];
-    return /* @__PURE__ */ React$1.cloneElement(newElement, mergedProps);
-  }
-  if (element) {
-    if (typeof element === "string") return renderTag(element, props);
-  }
-  throw new Error(formatErrorMessage(8));
-}
-function renderTag(Tag, props) {
-  if (Tag === "button") return /* @__PURE__ */ createElement2("button", {
-    type: "button",
-    ...props,
-    key: props.key
-  });
-  if (Tag === "img") return /* @__PURE__ */ createElement2("img", {
-    alt: "",
-    ...props,
-    key: props.key
-  });
-  return /* @__PURE__ */ React$1.createElement(Tag, props);
-}
-function useOnMount(fn) {
-  React$1.useEffect(fn, EMPTY_ARRAY);
-}
-function addEventListener(target, type, listener, options) {
-  target.addEventListener(type, listener, options);
-  return () => {
-    target.removeEventListener(type, listener, options);
-  };
-}
-var EMPTY = null;
-globalThis.requestAnimationFrame;
-var Scheduler = class {
-  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;
-    if (!this.isScheduled || false) {
-      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;
-  }
-};
-var scheduler = new Scheduler();
-var AnimationFrame = class AnimationFrame2 {
-  static create() {
-    return new AnimationFrame2();
-  }
-  static request(fn) {
-    return scheduler.request(fn);
+  const outProps = enabled ? mergeObjects(stateProps, resolvedProps) ?? {} : EMPTY_OBJECT;
+  if (typeof document !== "undefined") {
+    if (!enabled) useMergedRefs(null, null);
+    else if (Array.isArray(ref)) outProps.ref = useMergedRefsN([
+      outProps.ref,
+      getReactElementRef(renderProp),
+      ...ref
+    ]);
+    else outProps.ref = useMergedRefs(outProps.ref, getReactElementRef(renderProp), ref);
   }
-  static cancel(id) {
-    return scheduler.cancel(id);
+  if (!enabled) return EMPTY_OBJECT;
+  if (className !== void 0) outProps.className = mergeClassNames(outProps.className, className);
+  if (style !== void 0) outProps.style = mergeObjects(outProps.style, style);
+  return outProps;
+}
+function resolveRenderFunctionProps(props) {
+  if (Array.isArray(props)) return mergePropsN(props);
+  return mergeProps(void 0, props);
+}
+var REACT_LAZY_TYPE = /* @__PURE__ */ Symbol.for("react.lazy");
+function evaluateRenderProp(element, render, props, state) {
+  if (render) {
+    if (typeof render === "function") return render(props, state);
+    const mergedProps = mergeProps(props, render.props);
+    mergedProps.ref = props.ref;
+    let newElement = render;
+    if (newElement?.$$typeof === REACT_LAZY_TYPE) newElement = React$1.Children.toArray(render)[0];
+    return /* @__PURE__ */ React$1.cloneElement(newElement, mergedProps);
   }
-  currentId = EMPTY;
-  /**
-  * Executes `fn` after `delay`, clearing any previously scheduled call.
-  */
-  request(fn) {
-    this.cancel();
-    this.currentId = scheduler.request(() => {
-      this.currentId = EMPTY;
-      fn();
-    });
+  if (element) {
+    if (typeof element === "string") return renderTag(element, props);
   }
-  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;
+  throw new Error(formatErrorMessage(8));
+}
+function renderTag(Tag, props) {
+  if (Tag === "button") return /* @__PURE__ */ createElement2("button", {
+    type: "button",
+    ...props,
+    key: props.key
+  });
+  if (Tag === "img") return /* @__PURE__ */ createElement2("img", {
+    alt: "",
+    ...props,
+    key: props.key
+  });
+  return /* @__PURE__ */ React$1.createElement(Tag, props);
 }
 var TransitionStatusDataAttributes = /* @__PURE__ */ (function(TransitionStatusDataAttributes2) {
   TransitionStatusDataAttributes2["startingStyle"] = "data-starting-style";
@@ -770,6 +617,159 @@ function useId$1(idOverride, prefix) {
   }
   return useGlobalId(idOverride, prefix);
 }
+var CompositeRootContext = /* @__PURE__ */ React$1.createContext(void 0);
+function useCompositeRootContext(optional = false) {
+  const context = React$1.useContext(CompositeRootContext);
+  if (context === void 0 && !optional) throw new Error(formatErrorMessage(16));
+  return context;
+}
+function useFocusableWhenDisabled(parameters) {
+  const { focusableWhenDisabled, disabled: disabled2, composite = false, tabIndex: tabIndexProp = 0, isNativeButton } = parameters;
+  const isFocusableComposite = composite && focusableWhenDisabled !== false;
+  const isNonFocusableComposite = composite && focusableWhenDisabled === false;
+  return { props: React$1.useMemo(() => {
+    const additionalProps = { onKeyDown(event) {
+      if (disabled2 && focusableWhenDisabled && event.key !== "Tab") event.preventDefault();
+    } };
+    if (!composite) {
+      additionalProps.tabIndex = tabIndexProp;
+      if (!isNativeButton && disabled2) additionalProps.tabIndex = focusableWhenDisabled ? tabIndexProp : -1;
+    }
+    if (isNativeButton && (focusableWhenDisabled || isFocusableComposite) || !isNativeButton && disabled2) additionalProps["aria-disabled"] = disabled2;
+    if (isNativeButton && (!focusableWhenDisabled || isNonFocusableComposite)) additionalProps.disabled = disabled2;
+    return additionalProps;
+  }, [
+    composite,
+    disabled2,
+    focusableWhenDisabled,
+    isFocusableComposite,
+    isNonFocusableComposite,
+    isNativeButton,
+    tabIndexProp
+  ]) };
+}
+function dispatchClickWithModifiers(target, sourceEvent, { detail = 0 } = {}) {
+  target.dispatchEvent(new (getWindow(target)).PointerEvent("click", {
+    bubbles: true,
+    cancelable: true,
+    composed: true,
+    detail,
+    shiftKey: sourceEvent.shiftKey,
+    ctrlKey: sourceEvent.ctrlKey,
+    altKey: sourceEvent.altKey,
+    metaKey: sourceEvent.metaKey
+  }));
+}
+function useButton(parameters = {}) {
+  const { disabled: disabled2 = false, focusableWhenDisabled, tabIndex = 0, native: isNativeButton = true, composite: compositeProp } = parameters;
+  const elementRef = React$1.useRef(null);
+  const compositeRootContext = useCompositeRootContext(true);
+  const isCompositeItem = compositeProp ?? compositeRootContext !== void 0;
+  const { props: focusableWhenDisabledProps } = useFocusableWhenDisabled({
+    focusableWhenDisabled,
+    disabled: disabled2,
+    composite: isCompositeItem,
+    tabIndex,
+    isNativeButton
+  });
+  const updateDisabled = React$1.useCallback(() => {
+    const element = elementRef.current;
+    if (!isButtonElement(element)) return;
+    if (isCompositeItem && disabled2 && focusableWhenDisabledProps.disabled === void 0 && element.disabled) element.disabled = false;
+  }, [
+    disabled2,
+    focusableWhenDisabledProps.disabled,
+    isCompositeItem
+  ]);
+  useIsoLayoutEffect(updateDisabled, [updateDisabled]);
+  return {
+    getButtonProps: React$1.useCallback((externalProps = {}) => {
+      const { onClick: externalOnClick, onMouseDown: externalOnMouseDown, onKeyUp: externalOnKeyUp, onKeyDown: externalOnKeyDown, onPointerDown: externalOnPointerDown, ...otherExternalProps } = externalProps;
+      return mergeProps({
+        onClick(event) {
+          if (disabled2) {
+            event.preventDefault();
+            return;
+          }
+          externalOnClick?.(event);
+        },
+        onMouseDown(event) {
+          if (!disabled2) externalOnMouseDown?.(event);
+        },
+        onKeyDown(event) {
+          if (disabled2) return;
+          makeEventPreventable(event);
+          externalOnKeyDown?.(event);
+          if (event.baseUIHandlerPrevented) return;
+          const isCurrentTarget = event.target === event.currentTarget;
+          const currentTarget = event.currentTarget;
+          const isButton = isButtonElement(currentTarget);
+          const isLink = !isNativeButton && isValidLinkElement(currentTarget);
+          const shouldClick = isCurrentTarget && (isNativeButton ? isButton : !isLink);
+          const isEnterKey = event.key === "Enter";
+          const isSpaceKey = event.key === " ";
+          const role = currentTarget.getAttribute("role");
+          const isTextNavigationRole = role?.startsWith("menuitem") || role === "option" || role === "gridcell";
+          if (isCurrentTarget && isCompositeItem && isSpaceKey) {
+            if (event.defaultPrevented && isTextNavigationRole) return;
+            event.preventDefault();
+            if (!isNativeButton || isButton) {
+              event.preventBaseUIHandler();
+              dispatchClickWithModifiers(currentTarget, event);
+            }
+            return;
+          }
+          if (!shouldClick || isNativeButton || !isSpaceKey && !isEnterKey) {
+            if (isCurrentTarget && isLink && isSpaceKey) event.preventDefault();
+            return;
+          }
+          if (event.defaultPrevented) return;
+          event.preventDefault();
+          if (isEnterKey) {
+            event.preventBaseUIHandler();
+            dispatchClickWithModifiers(currentTarget, event);
+          }
+        },
+        onKeyUp(event) {
+          if (disabled2) return;
+          makeEventPreventable(event);
+          externalOnKeyUp?.(event);
+          if (event.target === event.currentTarget && isNativeButton && isCompositeItem && isButtonElement(event.currentTarget) && event.key === " ") {
+            event.preventDefault();
+            return;
+          }
+          if (event.baseUIHandlerPrevented) return;
+          if (event.target === event.currentTarget && !isNativeButton && !isCompositeItem && !event.defaultPrevented && event.key === " ") {
+            event.preventBaseUIHandler();
+            dispatchClickWithModifiers(event.currentTarget, event);
+          }
+        },
+        onPointerDown(event) {
+          if (disabled2) {
+            event.preventDefault();
+            return;
+          }
+          externalOnPointerDown?.(event);
+        }
+      }, isNativeButton ? { type: "button" } : { role: "button" }, focusableWhenDisabledProps, otherExternalProps);
+    }, [
+      disabled2,
+      focusableWhenDisabledProps,
+      isCompositeItem,
+      isNativeButton
+    ]),
+    buttonRef: useStableCallback((element) => {
+      elementRef.current = element;
+      updateDisabled();
+    })
+  };
+}
+function isButtonElement(elem) {
+  return isHTMLElement(elem) && elem.tagName === "BUTTON";
+}
+function isValidLinkElement(elem) {
+  return isHTMLElement(elem) && elem.tagName === "A" && Boolean(elem.href);
+}
 var none = "none";
 var triggerPress = "trigger-press";
 var triggerHover = "trigger-hover";
@@ -811,6 +811,15 @@ function createChangeEventDetails(reason, event, trigger, customProperties) {
 }
 
 export {
+  NOOP,
+  EMPTY_ARRAY,
+  EMPTY_OBJECT,
+  useOnMount,
+  useRefWithInit,
+  useIsoLayoutEffect,
+  formatErrorMessage,
+  isReactVersionAtLeast,
+  useStableCallback,
   getNodeName,
   getWindow,
   getDocumentElement,
@@ -830,32 +839,23 @@ export {
   getParentNode,
   getOverflowAncestors,
   getFrameElement,
-  useRefWithInit,
-  useStableCallback,
-  useIsoLayoutEffect,
-  mergeProps,
-  formatErrorMessage,
-  CompositeRootContext,
-  useCompositeRootContext,
-  dispatchClickWithModifiers,
-  useButton,
-  useMergedRefs,
-  isReactVersionAtLeast,
-  NOOP,
-  EMPTY_ARRAY,
-  EMPTY_OBJECT,
-  resolveStyle,
-  useRenderElement,
-  useOnMount,
   addEventListener,
   AnimationFrame,
   useAnimationFrame,
+  useMergedRefs,
+  resolveStyle,
+  mergeProps,
+  useRenderElement,
   TransitionStatusDataAttributes,
   transitionStatusMapping,
   resolveRef,
   useAnimationsFinished,
   useOpenChangeComplete,
   useId$1,
+  CompositeRootContext,
+  useCompositeRootContext,
+  dispatchClickWithModifiers,
+  useButton,
   none,
   triggerPress,
   triggerHover,