@qredence/fleet 0.6.1 → 0.6.3

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

@@ -1,58 +1,7 @@
-// web/app/dist/server/assets/createBaseUIEventDetails-hMAk6i9b.js
+// web/app/dist/server/assets/createBaseUIEventDetails-DCJ8SSHG.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";
 }
@@ -165,163 +114,37 @@ function getOverflowAncestors(node, list, traverseIframes) {
 function getFrameElement(win) {
   return win.parent && Object.getPrototypeOf(win.parent) ? win.frameElement : null;
 }
-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);
-  }
-  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 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;
+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 didChangeN(forkRef, newRefs) {
-  return forkRef.refs.length !== newRefs.length || forkRef.refs.some((ref, index) => ref !== newRefs[index]);
+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 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;
-          }
-        }
-      };
+function createStableCallback() {
+  const stable = {
+    next: void 0,
+    callback: assertNotCalled,
+    trampoline: (...args) => stable.callback?.(...args),
+    effect: () => {
+      stable.callback = stable.next;
     }
   };
+  return stable;
 }
-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 assertNotCalled() {
 }
+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;
@@ -330,26 +153,6 @@ 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);
@@ -455,168 +258,15 @@ function mergeClassNames(ourClassName, theirClassName) {
 function isSyntheticEvent(event) {
   return event != null && typeof event === "object" && "nativeEvent" in event;
 }
-function useRenderElement(element, componentProps, params = {}) {
-  const renderProp = componentProps.render;
-  const outProps = useRenderElementProps(componentProps, params);
-  if (params.enabled === false) return null;
-  return evaluateRenderProp(element, renderProp, outProps, params.state ?? EMPTY_OBJECT);
-}
-function useRenderElementProps(componentProps, params = {}) {
-  const { className: classNameProp, style: styleProp, render: renderProp } = componentProps;
-  const { state = EMPTY_OBJECT, ref, props, stateAttributesMapping, enabled = true } = params;
-  const className = enabled ? resolveClassName(classNameProp, state) : void 0;
-  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);
-}
-var TransitionStatusDataAttributes = /* @__PURE__ */ (function(TransitionStatusDataAttributes2) {
-  TransitionStatusDataAttributes2["startingStyle"] = "data-starting-style";
-  TransitionStatusDataAttributes2["endingStyle"] = "data-ending-style";
-  return TransitionStatusDataAttributes2;
-})({});
-var STARTING_HOOK = { "data-starting-style": "" };
-var ENDING_HOOK = { "data-ending-style": "" };
-var transitionStatusMapping = { transitionStatus(value) {
-  if (value === "starting") return STARTING_HOOK;
-  if (value === "ending") return ENDING_HOOK;
-  return null;
-} };
-function resolveRef(maybeRef) {
-  if (maybeRef == null) return maybeRef;
-  return "current" in maybeRef ? maybeRef.current : maybeRef;
-}
-function useAnimationsFinished(elementOrRef, waitForStartingStyleRemoved = false) {
-  const frame = useAnimationFrame();
-  return useStableCallback((fnToExecute, signal = null) => {
-    frame.cancel();
-    const element = resolveRef(elementOrRef);
-    if (element == null) return;
-    const resolvedElement = element;
-    const done = () => {
-      ReactDOM.flushSync(fnToExecute);
-    };
-    if (typeof resolvedElement.getAnimations !== "function" || globalThis.BASE_UI_ANIMATIONS_DISABLED) {
-      fnToExecute();
-      return;
-    }
-    function exec() {
-      Promise.all(resolvedElement.getAnimations().map((animation) => animation.finished)).then(() => {
-        if (!signal?.aborted) done();
-      }, () => {
-        if (signal?.aborted) return;
-        if (resolvedElement.getAnimations().some((animation) => animation.pending || animation.playState !== "finished")) {
-          exec();
-          return;
-        }
-        done();
-      });
-    }
-    if (waitForStartingStyleRemoved) {
-      const startingStyleAttribute = "data-starting-style";
-      if (!resolvedElement.hasAttribute(startingStyleAttribute)) {
-        frame.request(exec);
-        return;
-      }
-      const attributeObserver = new MutationObserver(() => {
-        if (!resolvedElement.hasAttribute(startingStyleAttribute)) {
-          attributeObserver.disconnect();
-          exec();
-        }
-      });
-      attributeObserver.observe(resolvedElement, {
-        attributes: true,
-        attributeFilter: [startingStyleAttribute]
-      });
-      signal?.addEventListener("abort", () => attributeObserver.disconnect(), { once: true });
-      return;
-    }
-    frame.request(exec);
-  });
-}
-function useOpenChangeComplete(parameters) {
-  const { enabled = true, open, ref, onComplete: onCompleteParam } = parameters;
-  const onComplete = useStableCallback(onCompleteParam);
-  const runOnceAnimationsFinish = useAnimationsFinished(ref, open);
-  React$1.useEffect(() => {
-    if (!enabled) return;
-    const abortController = new AbortController();
-    runOnceAnimationsFinish(onComplete, abortController.signal);
-    return () => {
-      abortController.abort();
-    };
-  }, [
-    enabled,
-    open,
-    onComplete,
-    runOnceAnimationsFinish
-  ]);
-}
-var globalId = 0;
-function useGlobalId(idOverride, prefix = "mui") {
-  const [defaultId, setDefaultId] = React$1.useState(idOverride);
-  const id = idOverride || defaultId;
-  React$1.useEffect(() => {
-    if (defaultId == null) {
-      globalId += 1;
-      setDefaultId(`${prefix}-${globalId}`);
-    }
-  }, [defaultId, prefix]);
-  return id;
-}
-var maybeReactUseId = SafeReact.useId;
-function useId$1(idOverride, prefix) {
-  if (maybeReactUseId !== void 0) {
-    const reactId = maybeReactUseId();
-    return idOverride ?? (prefix ? `${prefix}-${reactId}` : reactId);
-  }
-  return useGlobalId(idOverride, prefix);
+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);
@@ -770,10 +420,382 @@ function isButtonElement(elem) {
 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 = {}) {
+  let renderProp = componentProps.render;
+  if (params.enabled !== false) renderProp = unwrapLazyRenderProp(renderProp);
+  const outProps = useRenderElementProps(componentProps, params, renderProp);
+  if (params.enabled === false) return null;
+  const state = params.state ?? EMPTY_OBJECT;
+  return evaluateRenderProp(element, renderProp, outProps, state);
+}
+function useRenderElementProps(componentProps, params, renderProp) {
+  const { className: classNameProp, style: styleProp } = componentProps;
+  const { state = EMPTY_OBJECT, ref, props, stateAttributesMapping, enabled = true } = params;
+  const className = enabled ? resolveClassName(classNameProp, state) : void 0;
+  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 unwrapLazyRenderProp(render) {
+  if (render?.$$typeof !== REACT_LAZY_TYPE) return render;
+  const unwrapped = React$1.Children.toArray(render)[0];
+  return /* @__PURE__ */ React$1.isValidElement(unwrapped) ? unwrapped : render;
+}
+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;
+    return /* @__PURE__ */ React$1.cloneElement(render, 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;
+    if (this.callbacks[index] === null) 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;
+}
+var startingStyle = "data-starting-style";
+var endingStyle = "data-ending-style";
+var STARTING_HOOK = { [startingStyle]: "" };
+var ENDING_HOOK = { [endingStyle]: "" };
+var transitionStatusMapping = { transitionStatus(value) {
+  if (value === "starting") return STARTING_HOOK;
+  if (value === "ending") return ENDING_HOOK;
+  return null;
+} };
+function resolveRef(maybeRef) {
+  if (maybeRef == null) return maybeRef;
+  return "current" in maybeRef ? maybeRef.current : maybeRef;
+}
+var pendingCallbacks = null;
+function flushBeforePaint(fn) {
+  if (!pendingCallbacks) {
+    const callbacks = [];
+    pendingCallbacks = callbacks;
+    queueMicrotask(() => {
+      pendingCallbacks = null;
+      ReactDOM.flushSync(() => {
+        for (const callback of callbacks) callback();
+      });
+    });
+  }
+  pendingCallbacks.push(fn);
+}
+function useAnimationsFinished(elementOrRef, waitForStartingStyleRemoved = false, batch = false) {
+  const frame = useAnimationFrame();
+  return useStableCallback((fnToExecute, signal = null) => {
+    frame.cancel();
+    const element = resolveRef(elementOrRef);
+    if (element == null) return;
+    const resolvedElement = element;
+    const done = () => {
+      if (!batch) {
+        ReactDOM.flushSync(fnToExecute);
+        return;
+      }
+      flushBeforePaint(() => {
+        if (!signal?.aborted) fnToExecute();
+      });
+    };
+    if (typeof resolvedElement.getAnimations !== "function" || globalThis.BASE_UI_ANIMATIONS_DISABLED) {
+      fnToExecute();
+      return;
+    }
+    function exec() {
+      Promise.all(resolvedElement.getAnimations().map((animation) => animation.finished)).then(() => {
+        if (!signal?.aborted) done();
+      }, () => {
+        if (signal?.aborted) return;
+        if (resolvedElement.getAnimations().some((animation) => animation.pending || animation.playState !== "finished")) {
+          exec();
+          return;
+        }
+        done();
+      });
+    }
+    if (waitForStartingStyleRemoved) {
+      const startingStyleAttribute = startingStyle;
+      if (!resolvedElement.hasAttribute(startingStyleAttribute)) {
+        frame.request(exec);
+        return;
+      }
+      const attributeObserver = new MutationObserver(() => {
+        if (!resolvedElement.hasAttribute(startingStyleAttribute)) {
+          attributeObserver.disconnect();
+          exec();
+        }
+      });
+      attributeObserver.observe(resolvedElement, {
+        attributes: true,
+        attributeFilter: [startingStyleAttribute]
+      });
+      signal?.addEventListener("abort", () => attributeObserver.disconnect(), { once: true });
+      return;
+    }
+    frame.request(exec);
+  });
+}
+function useOpenChangeComplete(parameters) {
+  const { enabled = true, open, ref, batch = false, onComplete: onCompleteParam } = parameters;
+  const onComplete = useStableCallback(onCompleteParam);
+  const runOnceAnimationsFinish = useAnimationsFinished(ref, open, batch);
+  React$1.useEffect(() => {
+    if (!enabled) return;
+    const abortController = new AbortController();
+    runOnceAnimationsFinish(onComplete, abortController.signal);
+    return () => {
+      abortController.abort();
+    };
+  }, [
+    enabled,
+    open,
+    onComplete,
+    runOnceAnimationsFinish
+  ]);
+}
+var globalId = 0;
+function useGlobalId(idOverride, prefix = "mui") {
+  const [defaultId, setDefaultId] = React$1.useState(idOverride);
+  const id = idOverride || defaultId;
+  React$1.useEffect(() => {
+    if (defaultId == null) {
+      globalId += 1;
+      setDefaultId(`${prefix}-${globalId}`);
+    }
+  }, [defaultId, prefix]);
+  return id;
+}
+var maybeReactUseId = SafeReact.useId;
+function useId$1(idOverride, prefix) {
+  if (maybeReactUseId !== void 0) {
+    const reactId = maybeReactUseId();
+    return idOverride ?? (prefix ? `${prefix}-${reactId}` : reactId);
+  }
+  return useGlobalId(idOverride, prefix);
+}
 var none = "none";
 var triggerPress = "trigger-press";
 var triggerHover = "trigger-hover";
-var triggerFocus = "trigger-focus";
 var outsidePress = "outside-press";
 var itemPress = "item-press";
 var closePress = "close-press";
@@ -811,15 +833,6 @@ function createChangeEventDetails(reason, event, trigger, customProperties) {
 }
 
 export {
-  NOOP,
-  EMPTY_ARRAY,
-  EMPTY_OBJECT,
-  useOnMount,
-  useRefWithInit,
-  useIsoLayoutEffect,
-  formatErrorMessage,
-  isReactVersionAtLeast,
-  useStableCallback,
   getNodeName,
   getWindow,
   getDocumentElement,
@@ -839,27 +852,35 @@ export {
   getParentNode,
   getOverflowAncestors,
   getFrameElement,
-  addEventListener,
-  AnimationFrame,
-  useAnimationFrame,
+  useRefWithInit,
+  useStableCallback,
+  useIsoLayoutEffect,
+  mergeProps,
+  formatErrorMessage,
+  CompositeRootContext,
+  useCompositeRootContext,
+  dispatchClickWithModifiers,
+  useButton,
   useMergedRefs,
+  isReactVersionAtLeast,
+  NOOP,
+  EMPTY_ARRAY,
+  EMPTY_OBJECT,
   resolveStyle,
-  mergeProps,
   useRenderElement,
-  TransitionStatusDataAttributes,
+  useOnMount,
+  addEventListener,
+  AnimationFrame,
+  useAnimationFrame,
+  startingStyle,
   transitionStatusMapping,
   resolveRef,
   useAnimationsFinished,
   useOpenChangeComplete,
   useId$1,
-  CompositeRootContext,
-  useCompositeRootContext,
-  dispatchClickWithModifiers,
-  useButton,
   none,
   triggerPress,
   triggerHover,
-  triggerFocus,
   outsidePress,
   itemPress,
   closePress,