dune-react 0.0.1 → 0.0.2

package/dist/node_modules/.pnpm/@base-ui_react@1.3.0_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/react/esm/tooltip/store/TooltipStore.js

@@ -0,0 +1,105 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+import * as React from "react";
+import * as ReactDOM from "react-dom";
+import { useRefWithInit } from "../../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/useRefWithInit.js";
+import { useSyncedFloatingRootContext } from "../../floating-ui-react/hooks/useSyncedFloatingRootContext.js";
+import { ReactStore } from "../../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/store/ReactStore.js";
+import { PopupTriggerMap } from "../../utils/popups/popupTriggerMap.js";
+import { popupStoreSelectors, createInitialPopupStoreState } from "../../utils/popups/store.js";
+import { triggerHover, triggerFocus, triggerPress, escapeKey } from "../../utils/reason-parts.js";
+import { createSelector } from "../../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/store/createSelector.js";
+const selectors = {
+  ...popupStoreSelectors,
+  disabled: createSelector((state) => state.disabled),
+  instantType: createSelector((state) => state.instantType),
+  isInstantPhase: createSelector((state) => state.isInstantPhase),
+  trackCursorAxis: createSelector((state) => state.trackCursorAxis),
+  disableHoverablePopup: createSelector((state) => state.disableHoverablePopup),
+  lastOpenChangeReason: createSelector((state) => state.openChangeReason),
+  closeOnClick: createSelector((state) => state.closeOnClick),
+  closeDelay: createSelector((state) => state.closeDelay),
+  hasViewport: createSelector((state) => state.hasViewport)
+};
+class TooltipStore extends ReactStore {
+  constructor(initialState) {
+    super({
+      ...createInitialState(),
+      ...initialState
+    }, {
+      popupRef: /* @__PURE__ */ React.createRef(),
+      onOpenChange: void 0,
+      onOpenChangeComplete: void 0,
+      triggerElements: new PopupTriggerMap()
+    }, selectors);
+    __publicField(this, "setOpen", (nextOpen, eventDetails) => {
+      var _a, _b;
+      const reason = eventDetails.reason;
+      const isHover = reason === triggerHover;
+      const isFocusOpen = nextOpen && reason === triggerFocus;
+      const isDismissClose = !nextOpen && (reason === triggerPress || reason === escapeKey);
+      eventDetails.preventUnmountOnClose = () => {
+        this.set("preventUnmountingOnClose", true);
+      };
+      (_b = (_a = this.context).onOpenChange) == null ? void 0 : _b.call(_a, nextOpen, eventDetails);
+      if (eventDetails.isCanceled) {
+        return;
+      }
+      const changeState = () => {
+        var _a2;
+        const updatedState = {
+          open: nextOpen,
+          openChangeReason: reason
+        };
+        if (isFocusOpen) {
+          updatedState.instantType = "focus";
+        } else if (isDismissClose) {
+          updatedState.instantType = "dismiss";
+        } else if (reason === triggerHover) {
+          updatedState.instantType = void 0;
+        }
+        const newTriggerId = ((_a2 = eventDetails.trigger) == null ? void 0 : _a2.id) ?? null;
+        if (newTriggerId || nextOpen) {
+          updatedState.activeTriggerId = newTriggerId;
+          updatedState.activeTriggerElement = eventDetails.trigger ?? null;
+        }
+        this.update(updatedState);
+      };
+      if (isHover) {
+        ReactDOM.flushSync(changeState);
+      } else {
+        changeState();
+      }
+    });
+  }
+  static useStore(externalStore, initialState) {
+    const internalStore = useRefWithInit(() => {
+      return new TooltipStore(initialState);
+    }).current;
+    const store = externalStore ?? internalStore;
+    const floatingRootContext = useSyncedFloatingRootContext({
+      popupStore: store,
+      onOpenChange: store.setOpen
+    });
+    store.state.floatingRootContext = floatingRootContext;
+    return store;
+  }
+}
+function createInitialState() {
+  return {
+    ...createInitialPopupStoreState(),
+    disabled: false,
+    instantType: void 0,
+    isInstantPhase: false,
+    trackCursorAxis: "none",
+    disableHoverablePopup: false,
+    openChangeReason: null,
+    closeOnClick: true,
+    closeDelay: 0,
+    hasViewport: false
+  };
+}
+export {
+  TooltipStore
+};

package/dist/node_modules/.pnpm/@base-ui_react@1.3.0_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/react/esm/tooltip/trigger/TooltipTrigger.js

@@ -0,0 +1,117 @@
+import formatErrorMessage from "../../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/formatErrorMessage.js";
+import * as React from "react";
+import { fastComponentRef } from "../../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/fastHooks.js";
+import { useTooltipRootContext } from "../root/TooltipRootContext.js";
+import { triggerOpenStateMapping } from "../../utils/popupStateMapping.js";
+import { useRenderElement } from "../../utils/useRenderElement.js";
+import { useBaseUiId } from "../../utils/useBaseUiId.js";
+import { useTooltipProviderContext } from "../provider/TooltipProviderContext.js";
+import { TooltipTriggerDataAttributes } from "./TooltipTriggerDataAttributes.js";
+import { OPEN_DELAY } from "../utils/constants.js";
+import { useDelayGroup } from "../../floating-ui-react/components/FloatingDelayGroup.js";
+import { useHoverReferenceInteraction } from "../../floating-ui-react/hooks/useHoverReferenceInteraction.js";
+import { safePolygon } from "../../floating-ui-react/safePolygon.js";
+import { useFocus } from "../../floating-ui-react/hooks/useFocus.js";
+import { useTriggerDataForwarding } from "../../utils/popups/popupStoreUtils.js";
+const TooltipTrigger = fastComponentRef(function TooltipTrigger2(componentProps, forwardedRef) {
+  const {
+    className,
+    render,
+    handle,
+    payload,
+    disabled: disabledProp,
+    delay,
+    closeOnClick = true,
+    closeDelay,
+    id: idProp,
+    ...elementProps
+  } = componentProps;
+  const rootContext = useTooltipRootContext(true);
+  const store = (handle == null ? void 0 : handle.store) ?? rootContext;
+  if (!store) {
+    throw new Error(process.env.NODE_ENV !== "production" ? "Base UI: <Tooltip.Trigger> must be either used within a <Tooltip.Root> component or provided with a handle." : formatErrorMessage(82));
+  }
+  const thisTriggerId = useBaseUiId(idProp);
+  const isTriggerActive = store.useState("isTriggerActive", thisTriggerId);
+  const isOpenedByThisTrigger = store.useState("isOpenedByTrigger", thisTriggerId);
+  const floatingRootContext = store.useState("floatingRootContext");
+  const triggerElementRef = React.useRef(null);
+  const delayWithDefault = delay ?? OPEN_DELAY;
+  const closeDelayWithDefault = closeDelay ?? 0;
+  const {
+    registerTrigger,
+    isMountedByThisTrigger
+  } = useTriggerDataForwarding(thisTriggerId, triggerElementRef, store, {
+    payload,
+    closeOnClick,
+    closeDelay: closeDelayWithDefault
+  });
+  const providerContext = useTooltipProviderContext();
+  const {
+    delayRef,
+    isInstantPhase,
+    hasProvider
+  } = useDelayGroup(floatingRootContext, {
+    open: isOpenedByThisTrigger
+  });
+  store.useSyncedValue("isInstantPhase", isInstantPhase);
+  const rootDisabled = store.useState("disabled");
+  const disabled = disabledProp ?? rootDisabled;
+  const trackCursorAxis = store.useState("trackCursorAxis");
+  const disableHoverablePopup = store.useState("disableHoverablePopup");
+  const hoverProps = useHoverReferenceInteraction(floatingRootContext, {
+    enabled: !disabled,
+    mouseOnly: true,
+    move: false,
+    handleClose: !disableHoverablePopup && trackCursorAxis !== "both" ? safePolygon() : null,
+    restMs() {
+      const providerDelay = providerContext == null ? void 0 : providerContext.delay;
+      const groupOpenValue = typeof delayRef.current === "object" ? delayRef.current.open : void 0;
+      let computedRestMs = delayWithDefault;
+      if (hasProvider) {
+        if (groupOpenValue !== 0) {
+          computedRestMs = delay ?? providerDelay ?? delayWithDefault;
+        } else {
+          computedRestMs = 0;
+        }
+      }
+      return computedRestMs;
+    },
+    delay() {
+      const closeValue = typeof delayRef.current === "object" ? delayRef.current.close : void 0;
+      let computedCloseDelay = closeDelayWithDefault;
+      if (closeDelay == null && hasProvider) {
+        computedCloseDelay = closeValue;
+      }
+      return {
+        close: computedCloseDelay
+      };
+    },
+    triggerElementRef,
+    isActiveTrigger: isTriggerActive
+  });
+  const focusProps = useFocus(floatingRootContext, {
+    enabled: !disabled
+  }).reference;
+  const state = {
+    open: isOpenedByThisTrigger
+  };
+  const rootTriggerProps = store.useState("triggerProps", isMountedByThisTrigger);
+  const element = useRenderElement("button", componentProps, {
+    state,
+    ref: [forwardedRef, registerTrigger, triggerElementRef],
+    props: [hoverProps, focusProps, rootTriggerProps, {
+      onPointerDown() {
+        store.set("closeOnClick", closeOnClick);
+      },
+      id: thisTriggerId,
+      [TooltipTriggerDataAttributes.triggerDisabled]: disabled ? "" : void 0
+    }, elementProps],
+    stateAttributesMapping: triggerOpenStateMapping
+  });
+  return element;
+});
+if (process.env.NODE_ENV !== "production") TooltipTrigger.displayName = "TooltipTrigger";
+export {
+  TooltipTrigger
+};

package/dist/node_modules/.pnpm/@base-ui_react@1.3.0_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/react/esm/tooltip/trigger/TooltipTriggerDataAttributes.js

@@ -0,0 +1,9 @@
+import { CommonTriggerDataAttributes } from "../../utils/popupStateMapping.js";
+let TooltipTriggerDataAttributes = function(TooltipTriggerDataAttributes2) {
+  TooltipTriggerDataAttributes2[TooltipTriggerDataAttributes2["popupOpen"] = CommonTriggerDataAttributes.popupOpen] = "popupOpen";
+  TooltipTriggerDataAttributes2["triggerDisabled"] = "data-trigger-disabled";
+  return TooltipTriggerDataAttributes2;
+}({});
+export {
+  TooltipTriggerDataAttributes
+};

package/dist/node_modules/.pnpm/@base-ui_react@1.3.0_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/react/esm/tooltip/utils/constants.js

@@ -0,0 +1,4 @@
+const OPEN_DELAY = 600;
+export {
+  OPEN_DELAY
+};

package/dist/node_modules/.pnpm/@base-ui_react@1.3.0_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/react/esm/use-button/useButton.js

@@ -0,0 +1,170 @@
+import * as React from "react";
+import { isHTMLElement } from "../../../../../../@floating-ui_utils@0.2.11/node_modules/@floating-ui/utils/dist/floating-ui.utils.dom.js";
+import { useStableCallback } from "../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/useStableCallback.js";
+import { error } from "../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/error.js";
+import { SafeReact } from "../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/safeReact.js";
+import { useIsoLayoutEffect } from "../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/useIsoLayoutEffect.js";
+import { useCompositeRootContext } from "../composite/root/CompositeRootContext.js";
+import { useFocusableWhenDisabled } from "../utils/useFocusableWhenDisabled.js";
+import { mergeProps, makeEventPreventable } from "../merge-props/mergeProps.js";
+function useButton(parameters = {}) {
+  const {
+    disabled = false,
+    focusableWhenDisabled,
+    tabIndex = 0,
+    native: isNativeButton = true,
+    composite: compositeProp
+  } = parameters;
+  const elementRef = React.useRef(null);
+  const compositeRootContext = useCompositeRootContext(true);
+  const isCompositeItem = compositeProp ?? compositeRootContext !== void 0;
+  const {
+    props: focusableWhenDisabledProps
+  } = useFocusableWhenDisabled({
+    focusableWhenDisabled,
+    disabled,
+    composite: isCompositeItem,
+    tabIndex,
+    isNativeButton
+  });
+  if (process.env.NODE_ENV !== "production") {
+    React.useEffect(() => {
+      var _a, _b, _c, _d;
+      if (!elementRef.current) {
+        return;
+      }
+      const isButtonTag = isButtonElement(elementRef.current);
+      if (isNativeButton) {
+        if (!isButtonTag) {
+          const ownerStackMessage = ((_b = (_a = SafeReact).captureOwnerStack) == null ? void 0 : _b.call(_a)) || "";
+          const message = "A component that acts as a button expected a native <button> because the `nativeButton` prop is true. Rendering a non-<button> removes native button semantics, which can impact forms and accessibility. Use a real <button> in the `render` prop, or set `nativeButton` to `false`.";
+          error(`${message}${ownerStackMessage}`);
+        }
+      } else if (isButtonTag) {
+        const ownerStackMessage = ((_d = (_c = SafeReact).captureOwnerStack) == null ? void 0 : _d.call(_c)) || "";
+        const message = "A component that acts as a button expected a non-<button> because the `nativeButton` prop is false. Rendering a <button> keeps native behavior while Base UI applies non-native attributes and handlers, which can add unintended extra attributes (such as `role` or `aria-disabled`). Use a non-<button> in the `render` prop, or set `nativeButton` to `true`.";
+        error(`${message}${ownerStackMessage}`);
+      }
+    }, [isNativeButton]);
+  }
+  const updateDisabled = React.useCallback(() => {
+    const element = elementRef.current;
+    if (!isButtonElement(element)) {
+      return;
+    }
+    if (isCompositeItem && disabled && focusableWhenDisabledProps.disabled === void 0 && element.disabled) {
+      element.disabled = false;
+    }
+  }, [disabled, focusableWhenDisabledProps.disabled, isCompositeItem]);
+  useIsoLayoutEffect(updateDisabled, [updateDisabled]);
+  const getButtonProps = React.useCallback((externalProps = {}) => {
+    const {
+      onClick: externalOnClick,
+      onMouseDown: externalOnMouseDown,
+      onKeyUp: externalOnKeyUp,
+      onKeyDown: externalOnKeyDown,
+      onPointerDown: externalOnPointerDown,
+      ...otherExternalProps
+    } = externalProps;
+    const type = isNativeButton ? "button" : void 0;
+    return mergeProps({
+      type,
+      onClick(event) {
+        if (disabled) {
+          event.preventDefault();
+          return;
+        }
+        externalOnClick == null ? void 0 : externalOnClick(event);
+      },
+      onMouseDown(event) {
+        if (!disabled) {
+          externalOnMouseDown == null ? void 0 : externalOnMouseDown(event);
+        }
+      },
+      onKeyDown(event) {
+        if (disabled) {
+          return;
+        }
+        makeEventPreventable(event);
+        externalOnKeyDown == null ? void 0 : 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 == null ? void 0 : role.startsWith("menuitem")) || role === "option" || role === "gridcell";
+        if (isCurrentTarget && isCompositeItem && isSpaceKey) {
+          if (event.defaultPrevented && isTextNavigationRole) {
+            return;
+          }
+          event.preventDefault();
+          if (isLink || isNativeButton && isButton) {
+            currentTarget.click();
+            event.preventBaseUIHandler();
+          } else if (shouldClick) {
+            externalOnClick == null ? void 0 : externalOnClick(event);
+            event.preventBaseUIHandler();
+          }
+          return;
+        }
+        if (shouldClick) {
+          if (!isNativeButton && (isSpaceKey || isEnterKey)) {
+            event.preventDefault();
+          }
+          if (!isNativeButton && isEnterKey) {
+            externalOnClick == null ? void 0 : externalOnClick(event);
+          }
+        }
+      },
+      onKeyUp(event) {
+        if (disabled) {
+          return;
+        }
+        makeEventPreventable(event);
+        externalOnKeyUp == null ? void 0 : 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.key === " ") {
+          externalOnClick == null ? void 0 : externalOnClick(event);
+        }
+      },
+      onPointerDown(event) {
+        if (disabled) {
+          event.preventDefault();
+          return;
+        }
+        externalOnPointerDown == null ? void 0 : externalOnPointerDown(event);
+      }
+    }, !isNativeButton ? {
+      role: "button"
+    } : void 0, focusableWhenDisabledProps, otherExternalProps);
+  }, [disabled, focusableWhenDisabledProps, isCompositeItem, isNativeButton]);
+  const buttonRef = useStableCallback((element) => {
+    elementRef.current = element;
+    updateDisabled();
+  });
+  return {
+    getButtonProps,
+    buttonRef
+  };
+}
+function isButtonElement(elem) {
+  return isHTMLElement(elem) && elem.tagName === "BUTTON";
+}
+function isValidLinkElement(elem) {
+  return Boolean((elem == null ? void 0 : elem.tagName) === "A" && (elem == null ? void 0 : elem.href));
+}
+export {
+  useButton
+};

package/dist/node_modules/.pnpm/@base-ui_react@1.3.0_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/react/esm/use-render/useRender.js

@@ -0,0 +1,7 @@
+import { useRenderElement } from "../utils/useRenderElement.js";
+function useRender(params) {
+  return useRenderElement(params.defaultTagName ?? "div", params, params);
+}
+export {
+  useRender
+};

package/dist/node_modules/.pnpm/@base-ui_react@1.3.0_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/react/esm/utils/FloatingPortalLite.js

@@ -0,0 +1,32 @@
+import * as React from "react";
+import * as ReactDOM from "react-dom";
+import { jsxs } from "react/jsx-runtime";
+import { useFloatingPortalNode } from "../floating-ui-react/components/FloatingPortal.js";
+const FloatingPortalLite = /* @__PURE__ */ React.forwardRef(function FloatingPortalLite2(componentProps, forwardedRef) {
+  const {
+    children,
+    container,
+    className,
+    render,
+    ...elementProps
+  } = componentProps;
+  const {
+    portalNode,
+    portalSubtree
+  } = useFloatingPortalNode({
+    container,
+    ref: forwardedRef,
+    componentProps,
+    elementProps
+  });
+  if (!portalSubtree && !portalNode) {
+    return null;
+  }
+  return /* @__PURE__ */ jsxs(React.Fragment, {
+    children: [portalSubtree, portalNode && /* @__PURE__ */ ReactDOM.createPortal(children, portalNode)]
+  });
+});
+if (process.env.NODE_ENV !== "production") FloatingPortalLite.displayName = "FloatingPortalLite";
+export {
+  FloatingPortalLite
+};

package/dist/node_modules/.pnpm/@base-ui_react@1.3.0_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/react/esm/utils/FocusGuard.js

@@ -0,0 +1,30 @@
+import * as React from "react";
+import { useIsoLayoutEffect } from "../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/useIsoLayoutEffect.js";
+import { isSafari } from "../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/detectBrowser.js";
+import { visuallyHidden } from "../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/visuallyHidden.js";
+import { jsx } from "react/jsx-runtime";
+const FocusGuard = /* @__PURE__ */ React.forwardRef(function FocusGuard2(props, ref) {
+  const [role, setRole] = React.useState();
+  useIsoLayoutEffect(() => {
+    if (isSafari) {
+      setRole("button");
+    }
+  }, []);
+  const restProps = {
+    tabIndex: 0,
+    // Role is only for VoiceOver
+    role
+  };
+  return /* @__PURE__ */ jsx("span", {
+    ...props,
+    ref,
+    style: visuallyHidden,
+    "aria-hidden": role ? void 0 : true,
+    ...restProps,
+    "data-base-ui-focus-guard": ""
+  });
+});
+if (process.env.NODE_ENV !== "production") FocusGuard.displayName = "FocusGuard";
+export {
+  FocusGuard
+};

package/dist/node_modules/.pnpm/@base-ui_react@1.3.0_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/react/esm/utils/InternalBackdrop.js

@@ -0,0 +1,41 @@
+import * as React from "react";
+import { jsx } from "react/jsx-runtime";
+const InternalBackdrop = /* @__PURE__ */ React.forwardRef(function InternalBackdrop2(props, ref) {
+  const {
+    cutout,
+    ...otherProps
+  } = props;
+  let clipPath;
+  if (cutout) {
+    const rect = cutout == null ? void 0 : cutout.getBoundingClientRect();
+    clipPath = `polygon(
+      0% 0%,
+      100% 0%,
+      100% 100%,
+      0% 100%,
+      0% 0%,
+      ${rect.left}px ${rect.top}px,
+      ${rect.left}px ${rect.bottom}px,
+      ${rect.right}px ${rect.bottom}px,
+      ${rect.right}px ${rect.top}px,
+      ${rect.left}px ${rect.top}px
+    )`;
+  }
+  return /* @__PURE__ */ jsx("div", {
+    ref,
+    role: "presentation",
+    "data-base-ui-inert": "",
+    ...otherProps,
+    style: {
+      position: "fixed",
+      inset: 0,
+      userSelect: "none",
+      WebkitUserSelect: "none",
+      clipPath
+    }
+  });
+});
+if (process.env.NODE_ENV !== "production") InternalBackdrop.displayName = "InternalBackdrop";
+export {
+  InternalBackdrop
+};

package/dist/node_modules/.pnpm/@base-ui_react@1.3.0_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/react/esm/utils/adaptiveOriginMiddleware.js

@@ -0,0 +1,78 @@
+import { ownerDocument } from "../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/owner.js";
+import { getSide } from "../../../../../../@floating-ui_utils@0.2.11/node_modules/@floating-ui/utils/dist/floating-ui.utils.js";
+import { getWindow } from "../../../../../../@floating-ui_utils@0.2.11/node_modules/@floating-ui/utils/dist/floating-ui.utils.dom.js";
+const DEFAULT_SIDES = {
+  sideX: "left",
+  sideY: "top"
+};
+const adaptiveOrigin = {
+  name: "adaptiveOrigin",
+  async fn(state) {
+    var _a, _b;
+    const {
+      x: rawX,
+      y: rawY,
+      rects: {
+        floating: floatRect
+      },
+      elements: {
+        floating
+      },
+      platform,
+      strategy,
+      placement
+    } = state;
+    const win = getWindow(floating);
+    const styles = win.getComputedStyle(floating);
+    const hasTransition = styles.transitionDuration !== "0s" && styles.transitionDuration !== "";
+    if (!hasTransition) {
+      return {
+        x: rawX,
+        y: rawY,
+        data: DEFAULT_SIDES
+      };
+    }
+    const offsetParent = await ((_a = platform.getOffsetParent) == null ? void 0 : _a.call(platform, floating));
+    let offsetDimensions = {
+      width: 0,
+      height: 0
+    };
+    if (strategy === "fixed" && (win == null ? void 0 : win.visualViewport)) {
+      offsetDimensions = {
+        width: win.visualViewport.width,
+        height: win.visualViewport.height
+      };
+    } else if (offsetParent === win) {
+      const doc = ownerDocument(floating);
+      offsetDimensions = {
+        width: doc.documentElement.clientWidth,
+        height: doc.documentElement.clientHeight
+      };
+    } else if (await ((_b = platform.isElement) == null ? void 0 : _b.call(platform, offsetParent))) {
+      offsetDimensions = await platform.getDimensions(offsetParent);
+    }
+    const currentSide = getSide(placement);
+    let x = rawX;
+    let y = rawY;
+    if (currentSide === "left") {
+      x = offsetDimensions.width - (rawX + floatRect.width);
+    }
+    if (currentSide === "top") {
+      y = offsetDimensions.height - (rawY + floatRect.height);
+    }
+    const sideX = currentSide === "left" ? "right" : DEFAULT_SIDES.sideX;
+    const sideY = currentSide === "top" ? "bottom" : DEFAULT_SIDES.sideY;
+    return {
+      x,
+      y,
+      data: {
+        sideX,
+        sideY
+      }
+    };
+  }
+};
+export {
+  DEFAULT_SIDES,
+  adaptiveOrigin
+};

package/dist/node_modules/.pnpm/@base-ui_react@1.3.0_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/react/esm/utils/areArraysEqual.js

@@ -0,0 +1,6 @@
+function areArraysEqual(array1, array2, itemComparer = (a, b) => a === b) {
+  return array1.length === array2.length && array1.every((value, index) => itemComparer(value, array2[index]));
+}
+export {
+  areArraysEqual
+};

package/dist/node_modules/.pnpm/@base-ui_react@1.3.0_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/react/esm/utils/clamp.js

@@ -0,0 +1,6 @@
+function clamp(val, min = Number.MIN_SAFE_INTEGER, max = Number.MAX_SAFE_INTEGER) {
+  return Math.max(min, Math.min(val, max));
+}
+export {
+  clamp
+};

package/dist/node_modules/.pnpm/@base-ui_react@1.3.0_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/react/esm/utils/closePart.js

@@ -0,0 +1,35 @@
+import * as React from "react";
+import { useStableCallback } from "../../../../../../@base-ui_utils@0.2.6_@types_react@18.3.28_react-dom@18.3.1_react@18.3.1__react@18.3.1/node_modules/@base-ui/utils/esm/useStableCallback.js";
+import { jsx } from "react/jsx-runtime";
+const ClosePartContext = /* @__PURE__ */ React.createContext(void 0);
+if (process.env.NODE_ENV !== "production") ClosePartContext.displayName = "ClosePartContext";
+function useClosePartCount() {
+  const [closePartCount, setClosePartCount] = React.useState(0);
+  const register = useStableCallback(() => {
+    setClosePartCount((count) => count + 1);
+    return () => {
+      setClosePartCount((count) => Math.max(0, count - 1));
+    };
+  });
+  const context = React.useMemo(() => ({
+    register
+  }), [register]);
+  return {
+    context,
+    hasClosePart: closePartCount > 0
+  };
+}
+function ClosePartProvider(props) {
+  const {
+    value,
+    children
+  } = props;
+  return /* @__PURE__ */ jsx(ClosePartContext.Provider, {
+    value,
+    children
+  });
+}
+export {
+  ClosePartProvider,
+  useClosePartCount
+};