@dreamcommerce/aurora 3.1.45 → 3.1.46-2

package/build/esm/external/@radix-ui/react-select/dist/index.mjs.js

@@ -0,0 +1,1301 @@
+import { useState, useRef, useCallback, forwardRef, useEffect, useMemo } from 'react';
+import { slicedToArray as _slicedToArray, objectSpread2 as _objectSpread2, objectWithoutProperties as _objectWithoutProperties, toArray as _toArray, createForOfIteratorHelper as _createForOfIteratorHelper } from '../../../../_virtual/_rollupPluginBabelHelpers.js';
+import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
+import { createPortal } from 'react-dom';
+import { createContextScope } from '../../react-context/dist/index.mjs.js';
+import { useCallbackRef } from '../../react-use-callback-ref/dist/index.mjs.js';
+import { useControllableState } from '../../react-use-controllable-state/dist/index.mjs.js';
+import { useDirection } from '../../react-direction/dist/index.mjs.js';
+import { useLayoutEffect as useLayoutEffect2 } from '../../react-use-layout-effect/dist/index.mjs.js';
+import { useId } from '../../react-id/dist/index.mjs.js';
+import { usePrevious } from '../../react-use-previous/dist/index.mjs.js';
+import { useComposedRefs } from '../../react-compose-refs/dist/index.mjs.js';
+import { clamp } from '../../number/dist/index.mjs.js';
+import { composeEventHandlers } from '../external/@radix-ui/primitive/dist/index.mjs.js';
+import { Slot } from '../external/@radix-ui/react-slot/dist/index.mjs.js';
+import { createCollection } from '../external/@radix-ui/react-collection/dist/index.mjs.js';
+import { Primitive } from '../external/@radix-ui/react-primitive/dist/index.mjs.js';
+import { DismissableLayer } from '../external/@radix-ui/react-dismissable-layer/dist/index.mjs.js';
+import { useFocusGuards } from '../external/@radix-ui/react-focus-guards/dist/index.mjs.js';
+import { FocusScope } from '../external/@radix-ui/react-focus-scope/dist/index.mjs.js';
+import { createPopperScope, Root as Root2$1, Anchor, Content, Arrow } from '../external/@radix-ui/react-popper/dist/index.mjs.js';
+import { Portal as Portal$1 } from '../external/@radix-ui/react-portal/dist/index.mjs.js';
+import { VisuallyHidden } from '../../react-visually-hidden/dist/index.mjs.js';
+import { hideOthers } from '../external/aria-hidden/dist/es2015/index.js';
+import ReactRemoveScroll from '../external/react-remove-scroll/dist/es2015/Combination.js';
+
+var _excluded = ["__scopeSelect", "disabled"],
+  _excluded2 = ["__scopeSelect", "className", "style", "children", "placeholder"],
+  _excluded3 = ["__scopeSelect", "children"],
+  _excluded4 = ["__scopeSelect", "position", "onCloseAutoFocus", "onEscapeKeyDown", "onPointerDownOutside", "side", "sideOffset", "align", "alignOffset", "arrowPadding", "collisionBoundary", "collisionPadding", "sticky", "hideWhenDetached", "avoidCollisions"],
+  _excluded5 = ["__scopeSelect", "onPlaced"],
+  _excluded6 = ["__scopeSelect", "align", "collisionPadding"],
+  _excluded7 = ["__scopeSelect", "nonce"],
+  _excluded8 = ["__scopeSelect"],
+  _excluded9 = ["__scopeSelect"],
+  _excluded10 = ["__scopeSelect", "value", "disabled", "textValue"],
+  _excluded11 = ["__scopeSelect", "className", "style"],
+  _excluded12 = ["__scopeSelect"],
+  _excluded13 = ["__scopeSelect", "onAutoScroll"],
+  _excluded14 = ["__scopeSelect"],
+  _excluded15 = ["__scopeSelect"],
+  _excluded16 = ["value"];
+var OPEN_KEYS = [" ", "Enter", "ArrowUp", "ArrowDown"];
+var SELECTION_KEYS = [" ", "Enter"];
+var SELECT_NAME = "Select";
+var _createCollection = createCollection(SELECT_NAME),
+  _createCollection2 = _slicedToArray(_createCollection, 3),
+  Collection = _createCollection2[0],
+  useCollection = _createCollection2[1],
+  createCollectionScope = _createCollection2[2];
+var _createContextScope = createContextScope(SELECT_NAME, [createCollectionScope, createPopperScope]),
+  _createContextScope2 = _slicedToArray(_createContextScope, 2),
+  createSelectContext = _createContextScope2[0],
+  createSelectScope = _createContextScope2[1];
+var usePopperScope = createPopperScope();
+var _createSelectContext = createSelectContext(SELECT_NAME),
+  _createSelectContext2 = _slicedToArray(_createSelectContext, 2),
+  SelectProvider = _createSelectContext2[0],
+  useSelectContext = _createSelectContext2[1];
+var _createSelectContext3 = createSelectContext(SELECT_NAME),
+  _createSelectContext4 = _slicedToArray(_createSelectContext3, 2),
+  SelectNativeOptionsProvider = _createSelectContext4[0],
+  useSelectNativeOptionsContext = _createSelectContext4[1];
+var Select = function Select(props) {
+  var __scopeSelect = props.__scopeSelect,
+    children = props.children,
+    openProp = props.open,
+    defaultOpen = props.defaultOpen,
+    onOpenChange = props.onOpenChange,
+    valueProp = props.value,
+    defaultValue = props.defaultValue,
+    onValueChange = props.onValueChange,
+    dir = props.dir,
+    name = props.name,
+    autoComplete = props.autoComplete,
+    disabled = props.disabled,
+    required = props.required,
+    form = props.form;
+  var popperScope = usePopperScope(__scopeSelect);
+  var _React$useState = useState(null),
+    _React$useState2 = _slicedToArray(_React$useState, 2),
+    trigger = _React$useState2[0],
+    setTrigger = _React$useState2[1];
+  var _React$useState3 = useState(null),
+    _React$useState4 = _slicedToArray(_React$useState3, 2),
+    valueNode = _React$useState4[0],
+    setValueNode = _React$useState4[1];
+  var _React$useState5 = useState(false),
+    _React$useState6 = _slicedToArray(_React$useState5, 2),
+    valueNodeHasChildren = _React$useState6[0],
+    setValueNodeHasChildren = _React$useState6[1];
+  var direction = useDirection(dir);
+  var _useControllableState = useControllableState({
+      prop: openProp,
+      defaultProp: defaultOpen,
+      onChange: onOpenChange
+    }),
+    _useControllableState2 = _slicedToArray(_useControllableState, 2),
+    _useControllableState3 = _useControllableState2[0],
+    open = _useControllableState3 === void 0 ? false : _useControllableState3,
+    setOpen = _useControllableState2[1];
+  var _useControllableState4 = useControllableState({
+      prop: valueProp,
+      defaultProp: defaultValue,
+      onChange: onValueChange
+    }),
+    _useControllableState5 = _slicedToArray(_useControllableState4, 2),
+    value = _useControllableState5[0],
+    setValue = _useControllableState5[1];
+  var triggerPointerDownPosRef = useRef(null);
+  var isFormControl = trigger ? form || !!trigger.closest("form") : true;
+  var _React$useState7 = useState(/* @__PURE__ */new Set()),
+    _React$useState8 = _slicedToArray(_React$useState7, 2),
+    nativeOptionsSet = _React$useState8[0],
+    setNativeOptionsSet = _React$useState8[1];
+  var nativeSelectKey = Array.from(nativeOptionsSet).map(function (option) {
+    return option.props.value;
+  }).join(";");
+  return /* @__PURE__ */jsx(Root2$1, _objectSpread2(_objectSpread2({}, popperScope), {}, {
+    children: /* @__PURE__ */jsxs(SelectProvider, {
+      required: required,
+      scope: __scopeSelect,
+      trigger: trigger,
+      onTriggerChange: setTrigger,
+      valueNode: valueNode,
+      onValueNodeChange: setValueNode,
+      valueNodeHasChildren: valueNodeHasChildren,
+      onValueNodeHasChildrenChange: setValueNodeHasChildren,
+      contentId: useId(),
+      value: value,
+      onValueChange: setValue,
+      open: open,
+      onOpenChange: setOpen,
+      dir: direction,
+      triggerPointerDownPosRef: triggerPointerDownPosRef,
+      disabled: disabled,
+      children: [/* @__PURE__ */jsx(Collection.Provider, {
+        scope: __scopeSelect,
+        children: /* @__PURE__ */jsx(SelectNativeOptionsProvider, {
+          scope: props.__scopeSelect,
+          onNativeOptionAdd: useCallback(function (option) {
+            setNativeOptionsSet(function (prev) {
+              return new Set(prev).add(option);
+            });
+          }, []),
+          onNativeOptionRemove: useCallback(function (option) {
+            setNativeOptionsSet(function (prev) {
+              var optionsSet = new Set(prev);
+              optionsSet.delete(option);
+              return optionsSet;
+            });
+          }, []),
+          children: children
+        })
+      }), isFormControl ? /* @__PURE__ */jsxs(BubbleSelect, {
+        "aria-hidden": true,
+        required: required,
+        tabIndex: -1,
+        name: name,
+        autoComplete: autoComplete,
+        value: value,
+        onChange: function onChange(event) {
+          return setValue(event.target.value);
+        },
+        disabled: disabled,
+        form: form,
+        children: [value === void 0 ? /* @__PURE__ */jsx("option", {
+          value: ""
+        }) : null, Array.from(nativeOptionsSet)]
+      }, nativeSelectKey) : null]
+    })
+  }));
+};
+Select.displayName = SELECT_NAME;
+var TRIGGER_NAME = "SelectTrigger";
+var SelectTrigger = /*#__PURE__*/forwardRef(function (props, forwardedRef) {
+  var __scopeSelect = props.__scopeSelect,
+    _props$disabled = props.disabled,
+    disabled = _props$disabled === void 0 ? false : _props$disabled,
+    triggerProps = _objectWithoutProperties(props, _excluded);
+  var popperScope = usePopperScope(__scopeSelect);
+  var context = useSelectContext(TRIGGER_NAME, __scopeSelect);
+  var isDisabled = context.disabled || disabled;
+  var composedRefs = useComposedRefs(forwardedRef, context.onTriggerChange);
+  var getItems = useCollection(__scopeSelect);
+  var pointerTypeRef = useRef("touch");
+  var _useTypeaheadSearch = useTypeaheadSearch(function (search) {
+      var enabledItems = getItems().filter(function (item) {
+        return !item.disabled;
+      });
+      var currentItem = enabledItems.find(function (item) {
+        return item.value === context.value;
+      });
+      var nextItem = findNextItem(enabledItems, search, currentItem);
+      if (nextItem !== void 0) {
+        context.onValueChange(nextItem.value);
+      }
+    }),
+    _useTypeaheadSearch2 = _slicedToArray(_useTypeaheadSearch, 3),
+    searchRef = _useTypeaheadSearch2[0],
+    handleTypeaheadSearch = _useTypeaheadSearch2[1],
+    resetTypeahead = _useTypeaheadSearch2[2];
+  var handleOpen = function handleOpen(pointerEvent) {
+    if (!isDisabled) {
+      context.onOpenChange(true);
+      resetTypeahead();
+    }
+    if (pointerEvent) {
+      context.triggerPointerDownPosRef.current = {
+        x: Math.round(pointerEvent.pageX),
+        y: Math.round(pointerEvent.pageY)
+      };
+    }
+  };
+  return /* @__PURE__ */jsx(Anchor, _objectSpread2(_objectSpread2({
+    asChild: true
+  }, popperScope), {}, {
+    children: /* @__PURE__ */jsx(Primitive.button, _objectSpread2(_objectSpread2({
+      type: "button",
+      role: "combobox",
+      "aria-controls": context.contentId,
+      "aria-expanded": context.open,
+      "aria-required": context.required,
+      "aria-autocomplete": "none",
+      dir: context.dir,
+      "data-state": context.open ? "open" : "closed",
+      disabled: isDisabled,
+      "data-disabled": isDisabled ? "" : void 0,
+      "data-placeholder": shouldShowPlaceholder(context.value) ? "" : void 0
+    }, triggerProps), {}, {
+      ref: composedRefs,
+      onClick: composeEventHandlers(triggerProps.onClick, function (event) {
+        event.currentTarget.focus();
+        if (pointerTypeRef.current !== "mouse") {
+          handleOpen(event);
+        }
+      }),
+      onPointerDown: composeEventHandlers(triggerProps.onPointerDown, function (event) {
+        pointerTypeRef.current = event.pointerType;
+        var target = event.target;
+        if (target.hasPointerCapture(event.pointerId)) {
+          target.releasePointerCapture(event.pointerId);
+        }
+        if (event.button === 0 && event.ctrlKey === false && event.pointerType === "mouse") {
+          handleOpen(event);
+          event.preventDefault();
+        }
+      }),
+      onKeyDown: composeEventHandlers(triggerProps.onKeyDown, function (event) {
+        var isTypingAhead = searchRef.current !== "";
+        var isModifierKey = event.ctrlKey || event.altKey || event.metaKey;
+        if (!isModifierKey && event.key.length === 1) handleTypeaheadSearch(event.key);
+        if (isTypingAhead && event.key === " ") return;
+        if (OPEN_KEYS.includes(event.key)) {
+          handleOpen();
+          event.preventDefault();
+        }
+      })
+    }))
+  }));
+});
+SelectTrigger.displayName = TRIGGER_NAME;
+var VALUE_NAME = "SelectValue";
+var SelectValue = /*#__PURE__*/forwardRef(function (props, forwardedRef) {
+  var __scopeSelect = props.__scopeSelect,
+    className = props.className,
+    style = props.style,
+    children = props.children,
+    _props$placeholder = props.placeholder,
+    placeholder = _props$placeholder === void 0 ? "" : _props$placeholder,
+    valueProps = _objectWithoutProperties(props, _excluded2);
+  var context = useSelectContext(VALUE_NAME, __scopeSelect);
+  var onValueNodeHasChildrenChange = context.onValueNodeHasChildrenChange;
+  var hasChildren = children !== void 0;
+  var composedRefs = useComposedRefs(forwardedRef, context.onValueNodeChange);
+  useLayoutEffect2(function () {
+    onValueNodeHasChildrenChange(hasChildren);
+  }, [onValueNodeHasChildrenChange, hasChildren]);
+  return /* @__PURE__ */jsx(Primitive.span, _objectSpread2(_objectSpread2({}, valueProps), {}, {
+    ref: composedRefs,
+    style: {
+      pointerEvents: "none"
+    },
+    children: shouldShowPlaceholder(context.value) ? /* @__PURE__ */jsx(Fragment, {
+      children: placeholder
+    }) : children
+  }));
+});
+SelectValue.displayName = VALUE_NAME;
+var ICON_NAME = "SelectIcon";
+var SelectIcon = /*#__PURE__*/forwardRef(function (props, forwardedRef) {
+  var __scopeSelect = props.__scopeSelect,
+    children = props.children,
+    iconProps = _objectWithoutProperties(props, _excluded3);
+  return /* @__PURE__ */jsx(Primitive.span, _objectSpread2(_objectSpread2({
+    "aria-hidden": true
+  }, iconProps), {}, {
+    ref: forwardedRef,
+    children: children || "\u25BC"
+  }));
+});
+SelectIcon.displayName = ICON_NAME;
+var PORTAL_NAME = "SelectPortal";
+var SelectPortal = function SelectPortal(props) {
+  return /* @__PURE__ */jsx(Portal$1, _objectSpread2({
+    asChild: true
+  }, props));
+};
+SelectPortal.displayName = PORTAL_NAME;
+var CONTENT_NAME = "SelectContent";
+var SelectContent = /*#__PURE__*/forwardRef(function (props, forwardedRef) {
+  var context = useSelectContext(CONTENT_NAME, props.__scopeSelect);
+  var _React$useState9 = useState(),
+    _React$useState10 = _slicedToArray(_React$useState9, 2),
+    fragment = _React$useState10[0],
+    setFragment = _React$useState10[1];
+  useLayoutEffect2(function () {
+    setFragment(new DocumentFragment());
+  }, []);
+  if (!context.open) {
+    var frag = fragment;
+    return frag ? /*#__PURE__*/createPortal(/* @__PURE__ */jsx(SelectContentProvider, {
+      scope: props.__scopeSelect,
+      children: /* @__PURE__ */jsx(Collection.Slot, {
+        scope: props.__scopeSelect,
+        children: /* @__PURE__ */jsx("div", {
+          children: props.children
+        })
+      })
+    }), frag) : null;
+  }
+  return /* @__PURE__ */jsx(SelectContentImpl, _objectSpread2(_objectSpread2({}, props), {}, {
+    ref: forwardedRef
+  }));
+});
+SelectContent.displayName = CONTENT_NAME;
+var CONTENT_MARGIN = 10;
+var _createSelectContext5 = createSelectContext(CONTENT_NAME),
+  _createSelectContext6 = _slicedToArray(_createSelectContext5, 2),
+  SelectContentProvider = _createSelectContext6[0],
+  useSelectContentContext = _createSelectContext6[1];
+var CONTENT_IMPL_NAME = "SelectContentImpl";
+var SelectContentImpl = /*#__PURE__*/forwardRef(function (props, forwardedRef) {
+  var __scopeSelect = props.__scopeSelect,
+    _props$position = props.position,
+    position = _props$position === void 0 ? "item-aligned" : _props$position,
+    onCloseAutoFocus = props.onCloseAutoFocus,
+    onEscapeKeyDown = props.onEscapeKeyDown,
+    onPointerDownOutside = props.onPointerDownOutside,
+    side = props.side,
+    sideOffset = props.sideOffset,
+    align = props.align,
+    alignOffset = props.alignOffset,
+    arrowPadding = props.arrowPadding,
+    collisionBoundary = props.collisionBoundary,
+    collisionPadding = props.collisionPadding,
+    sticky = props.sticky,
+    hideWhenDetached = props.hideWhenDetached,
+    avoidCollisions = props.avoidCollisions,
+    contentProps = _objectWithoutProperties(props, _excluded4);
+  var context = useSelectContext(CONTENT_NAME, __scopeSelect);
+  var _React$useState11 = useState(null),
+    _React$useState12 = _slicedToArray(_React$useState11, 2),
+    content = _React$useState12[0],
+    setContent = _React$useState12[1];
+  var _React$useState13 = useState(null),
+    _React$useState14 = _slicedToArray(_React$useState13, 2),
+    viewport = _React$useState14[0],
+    setViewport = _React$useState14[1];
+  var composedRefs = useComposedRefs(forwardedRef, function (node) {
+    return setContent(node);
+  });
+  var _React$useState15 = useState(null),
+    _React$useState16 = _slicedToArray(_React$useState15, 2),
+    selectedItem = _React$useState16[0],
+    setSelectedItem = _React$useState16[1];
+  var _React$useState17 = useState(null),
+    _React$useState18 = _slicedToArray(_React$useState17, 2),
+    selectedItemText = _React$useState18[0],
+    setSelectedItemText = _React$useState18[1];
+  var getItems = useCollection(__scopeSelect);
+  var _React$useState19 = useState(false),
+    _React$useState20 = _slicedToArray(_React$useState19, 2),
+    isPositioned = _React$useState20[0],
+    setIsPositioned = _React$useState20[1];
+  var firstValidItemFoundRef = useRef(false);
+  useEffect(function () {
+    if (content) return hideOthers(content);
+  }, [content]);
+  useFocusGuards();
+  var focusFirst = useCallback(function (candidates) {
+    var _getItems$map = getItems().map(function (item) {
+        return item.ref.current;
+      }),
+      _getItems$map2 = _toArray(_getItems$map),
+      firstItem = _getItems$map2[0],
+      restItems = _getItems$map2.slice(1);
+    var _restItems$slice = restItems.slice(-1),
+      _restItems$slice2 = _slicedToArray(_restItems$slice, 1),
+      lastItem = _restItems$slice2[0];
+    var PREVIOUSLY_FOCUSED_ELEMENT = document.activeElement;
+    var _iterator = _createForOfIteratorHelper(candidates),
+      _step;
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var candidate = _step.value;
+        if (candidate === PREVIOUSLY_FOCUSED_ELEMENT) return;
+        candidate === null || candidate === void 0 ? void 0 : candidate.scrollIntoView({
+          block: "nearest"
+        });
+        if (candidate === firstItem && viewport) viewport.scrollTop = 0;
+        if (candidate === lastItem && viewport) viewport.scrollTop = viewport.scrollHeight;
+        candidate === null || candidate === void 0 ? void 0 : candidate.focus();
+        if (document.activeElement !== PREVIOUSLY_FOCUSED_ELEMENT) return;
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+  }, [getItems, viewport]);
+  var focusSelectedItem = useCallback(function () {
+    return focusFirst([selectedItem, content]);
+  }, [focusFirst, selectedItem, content]);
+  useEffect(function () {
+    if (isPositioned) {
+      focusSelectedItem();
+    }
+  }, [isPositioned, focusSelectedItem]);
+  var onOpenChange = context.onOpenChange,
+    triggerPointerDownPosRef = context.triggerPointerDownPosRef;
+  useEffect(function () {
+    if (content) {
+      var pointerMoveDelta = {
+        x: 0,
+        y: 0
+      };
+      var handlePointerMove = function handlePointerMove(event) {
+        var _triggerPointerDownPo, _triggerPointerDownPo2, _triggerPointerDownPo3, _triggerPointerDownPo4;
+        pointerMoveDelta = {
+          x: Math.abs(Math.round(event.pageX) - ((_triggerPointerDownPo = (_triggerPointerDownPo2 = triggerPointerDownPosRef.current) === null || _triggerPointerDownPo2 === void 0 ? void 0 : _triggerPointerDownPo2.x) !== null && _triggerPointerDownPo !== void 0 ? _triggerPointerDownPo : 0)),
+          y: Math.abs(Math.round(event.pageY) - ((_triggerPointerDownPo3 = (_triggerPointerDownPo4 = triggerPointerDownPosRef.current) === null || _triggerPointerDownPo4 === void 0 ? void 0 : _triggerPointerDownPo4.y) !== null && _triggerPointerDownPo3 !== void 0 ? _triggerPointerDownPo3 : 0))
+        };
+      };
+      var handlePointerUp = function handlePointerUp(event) {
+        if (pointerMoveDelta.x <= 10 && pointerMoveDelta.y <= 10) {
+          event.preventDefault();
+        } else {
+          if (!content.contains(event.target)) {
+            onOpenChange(false);
+          }
+        }
+        document.removeEventListener("pointermove", handlePointerMove);
+        triggerPointerDownPosRef.current = null;
+      };
+      if (triggerPointerDownPosRef.current !== null) {
+        document.addEventListener("pointermove", handlePointerMove);
+        document.addEventListener("pointerup", handlePointerUp, {
+          capture: true,
+          once: true
+        });
+      }
+      return function () {
+        document.removeEventListener("pointermove", handlePointerMove);
+        document.removeEventListener("pointerup", handlePointerUp, {
+          capture: true
+        });
+      };
+    }
+  }, [content, onOpenChange, triggerPointerDownPosRef]);
+  useEffect(function () {
+    var close = function close() {
+      return onOpenChange(false);
+    };
+    window.addEventListener("blur", close);
+    window.addEventListener("resize", close);
+    return function () {
+      window.removeEventListener("blur", close);
+      window.removeEventListener("resize", close);
+    };
+  }, [onOpenChange]);
+  var _useTypeaheadSearch3 = useTypeaheadSearch(function (search) {
+      var enabledItems = getItems().filter(function (item) {
+        return !item.disabled;
+      });
+      var currentItem = enabledItems.find(function (item) {
+        return item.ref.current === document.activeElement;
+      });
+      var nextItem = findNextItem(enabledItems, search, currentItem);
+      if (nextItem) {
+        setTimeout(function () {
+          return nextItem.ref.current.focus();
+        });
+      }
+    }),
+    _useTypeaheadSearch4 = _slicedToArray(_useTypeaheadSearch3, 2),
+    searchRef = _useTypeaheadSearch4[0],
+    handleTypeaheadSearch = _useTypeaheadSearch4[1];
+  var itemRefCallback = useCallback(function (node, value, disabled) {
+    var isFirstValidItem = !firstValidItemFoundRef.current && !disabled;
+    var isSelectedItem = context.value !== void 0 && context.value === value;
+    if (isSelectedItem || isFirstValidItem) {
+      setSelectedItem(node);
+      if (isFirstValidItem) firstValidItemFoundRef.current = true;
+    }
+  }, [context.value]);
+  var handleItemLeave = useCallback(function () {
+    return content === null || content === void 0 ? void 0 : content.focus();
+  }, [content]);
+  var itemTextRefCallback = useCallback(function (node, value, disabled) {
+    var isFirstValidItem = !firstValidItemFoundRef.current && !disabled;
+    var isSelectedItem = context.value !== void 0 && context.value === value;
+    if (isSelectedItem || isFirstValidItem) {
+      setSelectedItemText(node);
+    }
+  }, [context.value]);
+  var SelectPosition = position === "popper" ? SelectPopperPosition : SelectItemAlignedPosition;
+  var popperContentProps = SelectPosition === SelectPopperPosition ? {
+    side: side,
+    sideOffset: sideOffset,
+    align: align,
+    alignOffset: alignOffset,
+    arrowPadding: arrowPadding,
+    collisionBoundary: collisionBoundary,
+    collisionPadding: collisionPadding,
+    sticky: sticky,
+    hideWhenDetached: hideWhenDetached,
+    avoidCollisions: avoidCollisions
+  } : {};
+  return /* @__PURE__ */jsx(SelectContentProvider, {
+    scope: __scopeSelect,
+    content: content,
+    viewport: viewport,
+    onViewportChange: setViewport,
+    itemRefCallback: itemRefCallback,
+    selectedItem: selectedItem,
+    onItemLeave: handleItemLeave,
+    itemTextRefCallback: itemTextRefCallback,
+    focusSelectedItem: focusSelectedItem,
+    selectedItemText: selectedItemText,
+    position: position,
+    isPositioned: isPositioned,
+    searchRef: searchRef,
+    children: /* @__PURE__ */jsx(ReactRemoveScroll, {
+      as: Slot,
+      allowPinchZoom: true,
+      children: /* @__PURE__ */jsx(FocusScope, {
+        asChild: true,
+        trapped: context.open,
+        onMountAutoFocus: function onMountAutoFocus(event) {
+          event.preventDefault();
+        },
+        onUnmountAutoFocus: composeEventHandlers(onCloseAutoFocus, function (event) {
+          var _context$trigger;
+          (_context$trigger = context.trigger) === null || _context$trigger === void 0 ? void 0 : _context$trigger.focus({
+            preventScroll: true
+          });
+          event.preventDefault();
+        }),
+        children: /* @__PURE__ */jsx(DismissableLayer, {
+          asChild: true,
+          disableOutsidePointerEvents: true,
+          onEscapeKeyDown: onEscapeKeyDown,
+          onPointerDownOutside: onPointerDownOutside,
+          onFocusOutside: function onFocusOutside(event) {
+            return event.preventDefault();
+          },
+          onDismiss: function onDismiss() {
+            return context.onOpenChange(false);
+          },
+          children: /* @__PURE__ */jsx(SelectPosition, _objectSpread2(_objectSpread2(_objectSpread2({
+            role: "listbox",
+            id: context.contentId,
+            "data-state": context.open ? "open" : "closed",
+            dir: context.dir,
+            onContextMenu: function onContextMenu(event) {
+              return event.preventDefault();
+            }
+          }, contentProps), popperContentProps), {}, {
+            onPlaced: function onPlaced() {
+              return setIsPositioned(true);
+            },
+            ref: composedRefs,
+            style: _objectSpread2({
+              // flex layout so we can place the scroll buttons properly
+              display: "flex",
+              flexDirection: "column",
+              // reset the outline by default as the content MAY get focused
+              outline: "none"
+            }, contentProps.style),
+            onKeyDown: composeEventHandlers(contentProps.onKeyDown, function (event) {
+              var isModifierKey = event.ctrlKey || event.altKey || event.metaKey;
+              if (event.key === "Tab") event.preventDefault();
+              if (!isModifierKey && event.key.length === 1) handleTypeaheadSearch(event.key);
+              if (["ArrowUp", "ArrowDown", "Home", "End"].includes(event.key)) {
+                var items = getItems().filter(function (item) {
+                  return !item.disabled;
+                });
+                var candidateNodes = items.map(function (item) {
+                  return item.ref.current;
+                });
+                if (["ArrowUp", "End"].includes(event.key)) {
+                  candidateNodes = candidateNodes.slice().reverse();
+                }
+                if (["ArrowUp", "ArrowDown"].includes(event.key)) {
+                  var currentElement = event.target;
+                  var currentIndex = candidateNodes.indexOf(currentElement);
+                  candidateNodes = candidateNodes.slice(currentIndex + 1);
+                }
+                setTimeout(function () {
+                  return focusFirst(candidateNodes);
+                });
+                event.preventDefault();
+              }
+            })
+          }))
+        })
+      })
+    })
+  });
+});
+SelectContentImpl.displayName = CONTENT_IMPL_NAME;
+var ITEM_ALIGNED_POSITION_NAME = "SelectItemAlignedPosition";
+var SelectItemAlignedPosition = /*#__PURE__*/forwardRef(function (props, forwardedRef) {
+  var __scopeSelect = props.__scopeSelect,
+    onPlaced = props.onPlaced,
+    popperProps = _objectWithoutProperties(props, _excluded5);
+  var context = useSelectContext(CONTENT_NAME, __scopeSelect);
+  var contentContext = useSelectContentContext(CONTENT_NAME, __scopeSelect);
+  var _React$useState21 = useState(null),
+    _React$useState22 = _slicedToArray(_React$useState21, 2),
+    contentWrapper = _React$useState22[0],
+    setContentWrapper = _React$useState22[1];
+  var _React$useState23 = useState(null),
+    _React$useState24 = _slicedToArray(_React$useState23, 2),
+    content = _React$useState24[0],
+    setContent = _React$useState24[1];
+  var composedRefs = useComposedRefs(forwardedRef, function (node) {
+    return setContent(node);
+  });
+  var getItems = useCollection(__scopeSelect);
+  var shouldExpandOnScrollRef = useRef(false);
+  var shouldRepositionRef = useRef(true);
+  var viewport = contentContext.viewport,
+    selectedItem = contentContext.selectedItem,
+    selectedItemText = contentContext.selectedItemText,
+    focusSelectedItem = contentContext.focusSelectedItem;
+  var position = useCallback(function () {
+    if (context.trigger && context.valueNode && contentWrapper && content && viewport && selectedItem && selectedItemText) {
+      var triggerRect = context.trigger.getBoundingClientRect();
+      var contentRect = content.getBoundingClientRect();
+      var valueNodeRect = context.valueNode.getBoundingClientRect();
+      var itemTextRect = selectedItemText.getBoundingClientRect();
+      if (context.dir !== "rtl") {
+        var itemTextOffset = itemTextRect.left - contentRect.left;
+        var left = valueNodeRect.left - itemTextOffset;
+        var leftDelta = triggerRect.left - left;
+        var minContentWidth = triggerRect.width + leftDelta;
+        var contentWidth = Math.max(minContentWidth, contentRect.width);
+        var rightEdge = window.innerWidth - CONTENT_MARGIN;
+        var clampedLeft = clamp(left, [CONTENT_MARGIN,
+        // Prevents the content from going off the starting edge of the
+        // viewport. It may still go off the ending edge, but this can be
+        // controlled by the user since they may want to manage overflow in a
+        // specific way.
+        // https://github.com/radix-ui/primitives/issues/2049
+        Math.max(CONTENT_MARGIN, rightEdge - contentWidth)]);
+        contentWrapper.style.minWidth = minContentWidth + "px";
+        contentWrapper.style.left = clampedLeft + "px";
+      } else {
+        var _itemTextOffset = contentRect.right - itemTextRect.right;
+        var right = window.innerWidth - valueNodeRect.right - _itemTextOffset;
+        var rightDelta = window.innerWidth - triggerRect.right - right;
+        var _minContentWidth = triggerRect.width + rightDelta;
+        var _contentWidth = Math.max(_minContentWidth, contentRect.width);
+        var leftEdge = window.innerWidth - CONTENT_MARGIN;
+        var clampedRight = clamp(right, [CONTENT_MARGIN, Math.max(CONTENT_MARGIN, leftEdge - _contentWidth)]);
+        contentWrapper.style.minWidth = _minContentWidth + "px";
+        contentWrapper.style.right = clampedRight + "px";
+      }
+      var items = getItems();
+      var availableHeight = window.innerHeight - CONTENT_MARGIN * 2;
+      var itemsHeight = viewport.scrollHeight;
+      var contentStyles = window.getComputedStyle(content);
+      var contentBorderTopWidth = parseInt(contentStyles.borderTopWidth, 10);
+      var contentPaddingTop = parseInt(contentStyles.paddingTop, 10);
+      var contentBorderBottomWidth = parseInt(contentStyles.borderBottomWidth, 10);
+      var contentPaddingBottom = parseInt(contentStyles.paddingBottom, 10);
+      var fullContentHeight = contentBorderTopWidth + contentPaddingTop + itemsHeight + contentPaddingBottom + contentBorderBottomWidth;
+      var minContentHeight = Math.min(selectedItem.offsetHeight * 5, fullContentHeight);
+      var viewportStyles = window.getComputedStyle(viewport);
+      var viewportPaddingTop = parseInt(viewportStyles.paddingTop, 10);
+      var viewportPaddingBottom = parseInt(viewportStyles.paddingBottom, 10);
+      var topEdgeToTriggerMiddle = triggerRect.top + triggerRect.height / 2 - CONTENT_MARGIN;
+      var triggerMiddleToBottomEdge = availableHeight - topEdgeToTriggerMiddle;
+      var selectedItemHalfHeight = selectedItem.offsetHeight / 2;
+      var itemOffsetMiddle = selectedItem.offsetTop + selectedItemHalfHeight;
+      var contentTopToItemMiddle = contentBorderTopWidth + contentPaddingTop + itemOffsetMiddle;
+      var itemMiddleToContentBottom = fullContentHeight - contentTopToItemMiddle;
+      var willAlignWithoutTopOverflow = contentTopToItemMiddle <= topEdgeToTriggerMiddle;
+      if (willAlignWithoutTopOverflow) {
+        var isLastItem = items.length > 0 && selectedItem === items[items.length - 1].ref.current;
+        contentWrapper.style.bottom = "0px";
+        var viewportOffsetBottom = content.clientHeight - viewport.offsetTop - viewport.offsetHeight;
+        var clampedTriggerMiddleToBottomEdge = Math.max(triggerMiddleToBottomEdge, selectedItemHalfHeight + (
+        // viewport might have padding bottom, include it to avoid a scrollable viewport
+        isLastItem ? viewportPaddingBottom : 0) + viewportOffsetBottom + contentBorderBottomWidth);
+        var height = contentTopToItemMiddle + clampedTriggerMiddleToBottomEdge;
+        contentWrapper.style.height = height + "px";
+      } else {
+        var isFirstItem = items.length > 0 && selectedItem === items[0].ref.current;
+        contentWrapper.style.top = "0px";
+        var clampedTopEdgeToTriggerMiddle = Math.max(topEdgeToTriggerMiddle, contentBorderTopWidth + viewport.offsetTop + (
+        // viewport might have padding top, include it to avoid a scrollable viewport
+        isFirstItem ? viewportPaddingTop : 0) + selectedItemHalfHeight);
+        var _height = clampedTopEdgeToTriggerMiddle + itemMiddleToContentBottom;
+        contentWrapper.style.height = _height + "px";
+        viewport.scrollTop = contentTopToItemMiddle - topEdgeToTriggerMiddle + viewport.offsetTop;
+      }
+      contentWrapper.style.margin = "".concat(CONTENT_MARGIN, "px 0");
+      contentWrapper.style.minHeight = minContentHeight + "px";
+      contentWrapper.style.maxHeight = availableHeight + "px";
+      onPlaced === null || onPlaced === void 0 ? void 0 : onPlaced();
+      requestAnimationFrame(function () {
+        return shouldExpandOnScrollRef.current = true;
+      });
+    }
+  }, [getItems, context.trigger, context.valueNode, contentWrapper, content, viewport, selectedItem, selectedItemText, context.dir, onPlaced]);
+  useLayoutEffect2(function () {
+    return position();
+  }, [position]);
+  var _React$useState25 = useState(),
+    _React$useState26 = _slicedToArray(_React$useState25, 2),
+    contentZIndex = _React$useState26[0],
+    setContentZIndex = _React$useState26[1];
+  useLayoutEffect2(function () {
+    if (content) setContentZIndex(window.getComputedStyle(content).zIndex);
+  }, [content]);
+  var handleScrollButtonChange = useCallback(function (node) {
+    if (node && shouldRepositionRef.current === true) {
+      position();
+      focusSelectedItem === null || focusSelectedItem === void 0 ? void 0 : focusSelectedItem();
+      shouldRepositionRef.current = false;
+    }
+  }, [position, focusSelectedItem]);
+  return /* @__PURE__ */jsx(SelectViewportProvider, {
+    scope: __scopeSelect,
+    contentWrapper: contentWrapper,
+    shouldExpandOnScrollRef: shouldExpandOnScrollRef,
+    onScrollButtonChange: handleScrollButtonChange,
+    children: /* @__PURE__ */jsx("div", {
+      ref: setContentWrapper,
+      style: {
+        display: "flex",
+        flexDirection: "column",
+        position: "fixed",
+        zIndex: contentZIndex
+      },
+      children: /* @__PURE__ */jsx(Primitive.div, _objectSpread2(_objectSpread2({}, popperProps), {}, {
+        ref: composedRefs,
+        style: _objectSpread2({
+          // When we get the height of the content, it includes borders. If we were to set
+          // the height without having `boxSizing: 'border-box'` it would be too big.
+          boxSizing: "border-box",
+          // We need to ensure the content doesn't get taller than the wrapper
+          maxHeight: "100%"
+        }, popperProps.style)
+      }))
+    })
+  });
+});
+SelectItemAlignedPosition.displayName = ITEM_ALIGNED_POSITION_NAME;
+var POPPER_POSITION_NAME = "SelectPopperPosition";
+var SelectPopperPosition = /*#__PURE__*/forwardRef(function (props, forwardedRef) {
+  var __scopeSelect = props.__scopeSelect,
+    _props$align = props.align,
+    align = _props$align === void 0 ? "start" : _props$align,
+    _props$collisionPaddi = props.collisionPadding,
+    collisionPadding = _props$collisionPaddi === void 0 ? CONTENT_MARGIN : _props$collisionPaddi,
+    popperProps = _objectWithoutProperties(props, _excluded6);
+  var popperScope = usePopperScope(__scopeSelect);
+  return /* @__PURE__ */jsx(Content, _objectSpread2(_objectSpread2(_objectSpread2({}, popperScope), popperProps), {}, {
+    ref: forwardedRef,
+    align: align,
+    collisionPadding: collisionPadding,
+    style: _objectSpread2(_objectSpread2({
+      // Ensure border-box for floating-ui calculations
+      boxSizing: "border-box"
+    }, popperProps.style), {
+      "--radix-select-content-transform-origin": "var(--radix-popper-transform-origin)",
+      "--radix-select-content-available-width": "var(--radix-popper-available-width)",
+      "--radix-select-content-available-height": "var(--radix-popper-available-height)",
+      "--radix-select-trigger-width": "var(--radix-popper-anchor-width)",
+      "--radix-select-trigger-height": "var(--radix-popper-anchor-height)"
+    })
+  }));
+});
+SelectPopperPosition.displayName = POPPER_POSITION_NAME;
+var _createSelectContext7 = createSelectContext(CONTENT_NAME, {}),
+  _createSelectContext8 = _slicedToArray(_createSelectContext7, 2),
+  SelectViewportProvider = _createSelectContext8[0],
+  useSelectViewportContext = _createSelectContext8[1];
+var VIEWPORT_NAME = "SelectViewport";
+var SelectViewport = /*#__PURE__*/forwardRef(function (props, forwardedRef) {
+  var __scopeSelect = props.__scopeSelect,
+    nonce = props.nonce,
+    viewportProps = _objectWithoutProperties(props, _excluded7);
+  var contentContext = useSelectContentContext(VIEWPORT_NAME, __scopeSelect);
+  var viewportContext = useSelectViewportContext(VIEWPORT_NAME, __scopeSelect);
+  var composedRefs = useComposedRefs(forwardedRef, contentContext.onViewportChange);
+  var prevScrollTopRef = useRef(0);
+  return /* @__PURE__ */jsxs(Fragment, {
+    children: [/* @__PURE__ */jsx("style", {
+      dangerouslySetInnerHTML: {
+        __html: "[data-radix-select-viewport]{scrollbar-width:none;-ms-overflow-style:none;-webkit-overflow-scrolling:touch;}[data-radix-select-viewport]::-webkit-scrollbar{display:none}"
+      },
+      nonce: nonce
+    }), /* @__PURE__ */jsx(Collection.Slot, {
+      scope: __scopeSelect,
+      children: /* @__PURE__ */jsx(Primitive.div, _objectSpread2(_objectSpread2({
+        "data-radix-select-viewport": "",
+        role: "presentation"
+      }, viewportProps), {}, {
+        ref: composedRefs,
+        style: _objectSpread2({
+          // we use position: 'relative' here on the `viewport` so that when we call
+          // `selectedItem.offsetTop` in calculations, the offset is relative to the viewport
+          // (independent of the scrollUpButton).
+          position: "relative",
+          flex: 1,
+          // Viewport should only be scrollable in the vertical direction.
+          // This won't work in vertical writing modes, so we'll need to
+          // revisit this if/when that is supported
+          // https://developer.chrome.com/blog/vertical-form-controls
+          overflow: "hidden auto"
+        }, viewportProps.style),
+        onScroll: composeEventHandlers(viewportProps.onScroll, function (event) {
+          var viewport = event.currentTarget;
+          var contentWrapper = viewportContext.contentWrapper,
+            shouldExpandOnScrollRef = viewportContext.shouldExpandOnScrollRef;
+          if (shouldExpandOnScrollRef !== null && shouldExpandOnScrollRef !== void 0 && shouldExpandOnScrollRef.current && contentWrapper) {
+            var scrolledBy = Math.abs(prevScrollTopRef.current - viewport.scrollTop);
+            if (scrolledBy > 0) {
+              var availableHeight = window.innerHeight - CONTENT_MARGIN * 2;
+              var cssMinHeight = parseFloat(contentWrapper.style.minHeight);
+              var cssHeight = parseFloat(contentWrapper.style.height);
+              var prevHeight = Math.max(cssMinHeight, cssHeight);
+              if (prevHeight < availableHeight) {
+                var nextHeight = prevHeight + scrolledBy;
+                var clampedNextHeight = Math.min(availableHeight, nextHeight);
+                var heightDiff = nextHeight - clampedNextHeight;
+                contentWrapper.style.height = clampedNextHeight + "px";
+                if (contentWrapper.style.bottom === "0px") {
+                  viewport.scrollTop = heightDiff > 0 ? heightDiff : 0;
+                  contentWrapper.style.justifyContent = "flex-end";
+                }
+              }
+            }
+          }
+          prevScrollTopRef.current = viewport.scrollTop;
+        })
+      }))
+    })]
+  });
+});
+SelectViewport.displayName = VIEWPORT_NAME;
+var GROUP_NAME = "SelectGroup";
+var _createSelectContext9 = createSelectContext(GROUP_NAME),
+  _createSelectContext10 = _slicedToArray(_createSelectContext9, 2),
+  SelectGroupContextProvider = _createSelectContext10[0],
+  useSelectGroupContext = _createSelectContext10[1];
+var SelectGroup = /*#__PURE__*/forwardRef(function (props, forwardedRef) {
+  var __scopeSelect = props.__scopeSelect,
+    groupProps = _objectWithoutProperties(props, _excluded8);
+  var groupId = useId();
+  return /* @__PURE__ */jsx(SelectGroupContextProvider, {
+    scope: __scopeSelect,
+    id: groupId,
+    children: /* @__PURE__ */jsx(Primitive.div, _objectSpread2(_objectSpread2({
+      role: "group",
+      "aria-labelledby": groupId
+    }, groupProps), {}, {
+      ref: forwardedRef
+    }))
+  });
+});
+SelectGroup.displayName = GROUP_NAME;
+var LABEL_NAME = "SelectLabel";
+var SelectLabel = /*#__PURE__*/forwardRef(function (props, forwardedRef) {
+  var __scopeSelect = props.__scopeSelect,
+    labelProps = _objectWithoutProperties(props, _excluded9);
+  var groupContext = useSelectGroupContext(LABEL_NAME, __scopeSelect);
+  return /* @__PURE__ */jsx(Primitive.div, _objectSpread2(_objectSpread2({
+    id: groupContext.id
+  }, labelProps), {}, {
+    ref: forwardedRef
+  }));
+});
+SelectLabel.displayName = LABEL_NAME;
+var ITEM_NAME = "SelectItem";
+var _createSelectContext11 = createSelectContext(ITEM_NAME),
+  _createSelectContext12 = _slicedToArray(_createSelectContext11, 2),
+  SelectItemContextProvider = _createSelectContext12[0],
+  useSelectItemContext = _createSelectContext12[1];
+var SelectItem = /*#__PURE__*/forwardRef(function (props, forwardedRef) {
+  var __scopeSelect = props.__scopeSelect,
+    value = props.value,
+    _props$disabled2 = props.disabled,
+    disabled = _props$disabled2 === void 0 ? false : _props$disabled2,
+    textValueProp = props.textValue,
+    itemProps = _objectWithoutProperties(props, _excluded10);
+  var context = useSelectContext(ITEM_NAME, __scopeSelect);
+  var contentContext = useSelectContentContext(ITEM_NAME, __scopeSelect);
+  var isSelected = context.value === value;
+  var _React$useState27 = useState(textValueProp !== null && textValueProp !== void 0 ? textValueProp : ""),
+    _React$useState28 = _slicedToArray(_React$useState27, 2),
+    textValue = _React$useState28[0],
+    setTextValue = _React$useState28[1];
+  var _React$useState29 = useState(false),
+    _React$useState30 = _slicedToArray(_React$useState29, 2),
+    isFocused = _React$useState30[0],
+    setIsFocused = _React$useState30[1];
+  var composedRefs = useComposedRefs(forwardedRef, function (node) {
+    var _contentContext$itemR;
+    return (_contentContext$itemR = contentContext.itemRefCallback) === null || _contentContext$itemR === void 0 ? void 0 : _contentContext$itemR.call(contentContext, node, value, disabled);
+  });
+  var textId = useId();
+  var pointerTypeRef = useRef("touch");
+  var handleSelect = function handleSelect() {
+    if (!disabled) {
+      context.onValueChange(value);
+      context.onOpenChange(false);
+    }
+  };
+  if (value === "") {
+    throw new Error("A <Select.Item /> must have a value prop that is not an empty string. This is because the Select value can be set to an empty string to clear the selection and show the placeholder.");
+  }
+  return /* @__PURE__ */jsx(SelectItemContextProvider, {
+    scope: __scopeSelect,
+    value: value,
+    disabled: disabled,
+    textId: textId,
+    isSelected: isSelected,
+    onItemTextChange: useCallback(function (node) {
+      setTextValue(function (prevTextValue) {
+        var _node$textContent;
+        return prevTextValue || ((_node$textContent = node === null || node === void 0 ? void 0 : node.textContent) !== null && _node$textContent !== void 0 ? _node$textContent : "").trim();
+      });
+    }, []),
+    children: /* @__PURE__ */jsx(Collection.ItemSlot, {
+      scope: __scopeSelect,
+      value: value,
+      disabled: disabled,
+      textValue: textValue,
+      children: /* @__PURE__ */jsx(Primitive.div, _objectSpread2(_objectSpread2({
+        role: "option",
+        "aria-labelledby": textId,
+        "data-highlighted": isFocused ? "" : void 0,
+        "aria-selected": isSelected && isFocused,
+        "data-state": isSelected ? "checked" : "unchecked",
+        "aria-disabled": disabled || void 0,
+        "data-disabled": disabled ? "" : void 0,
+        tabIndex: disabled ? void 0 : -1
+      }, itemProps), {}, {
+        ref: composedRefs,
+        onFocus: composeEventHandlers(itemProps.onFocus, function () {
+          return setIsFocused(true);
+        }),
+        onBlur: composeEventHandlers(itemProps.onBlur, function () {
+          return setIsFocused(false);
+        }),
+        onClick: composeEventHandlers(itemProps.onClick, function () {
+          if (pointerTypeRef.current !== "mouse") handleSelect();
+        }),
+        onPointerUp: composeEventHandlers(itemProps.onPointerUp, function () {
+          if (pointerTypeRef.current === "mouse") handleSelect();
+        }),
+        onPointerDown: composeEventHandlers(itemProps.onPointerDown, function (event) {
+          pointerTypeRef.current = event.pointerType;
+        }),
+        onPointerMove: composeEventHandlers(itemProps.onPointerMove, function (event) {
+          pointerTypeRef.current = event.pointerType;
+          if (disabled) {
+            var _contentContext$onIte;
+            (_contentContext$onIte = contentContext.onItemLeave) === null || _contentContext$onIte === void 0 ? void 0 : _contentContext$onIte.call(contentContext);
+          } else if (pointerTypeRef.current === "mouse") {
+            event.currentTarget.focus({
+              preventScroll: true
+            });
+          }
+        }),
+        onPointerLeave: composeEventHandlers(itemProps.onPointerLeave, function (event) {
+          if (event.currentTarget === document.activeElement) {
+            var _contentContext$onIte2;
+            (_contentContext$onIte2 = contentContext.onItemLeave) === null || _contentContext$onIte2 === void 0 ? void 0 : _contentContext$onIte2.call(contentContext);
+          }
+        }),
+        onKeyDown: composeEventHandlers(itemProps.onKeyDown, function (event) {
+          var _contentContext$searc;
+          var isTypingAhead = ((_contentContext$searc = contentContext.searchRef) === null || _contentContext$searc === void 0 ? void 0 : _contentContext$searc.current) !== "";
+          if (isTypingAhead && event.key === " ") return;
+          if (SELECTION_KEYS.includes(event.key)) handleSelect();
+          if (event.key === " ") event.preventDefault();
+        })
+      }))
+    })
+  });
+});
+SelectItem.displayName = ITEM_NAME;
+var ITEM_TEXT_NAME = "SelectItemText";
+var SelectItemText = /*#__PURE__*/forwardRef(function (props, forwardedRef) {
+  var __scopeSelect = props.__scopeSelect,
+    className = props.className,
+    style = props.style,
+    itemTextProps = _objectWithoutProperties(props, _excluded11);
+  var context = useSelectContext(ITEM_TEXT_NAME, __scopeSelect);
+  var contentContext = useSelectContentContext(ITEM_TEXT_NAME, __scopeSelect);
+  var itemContext = useSelectItemContext(ITEM_TEXT_NAME, __scopeSelect);
+  var nativeOptionsContext = useSelectNativeOptionsContext(ITEM_TEXT_NAME, __scopeSelect);
+  var _React$useState31 = useState(null),
+    _React$useState32 = _slicedToArray(_React$useState31, 2),
+    itemTextNode = _React$useState32[0],
+    setItemTextNode = _React$useState32[1];
+  var composedRefs = useComposedRefs(forwardedRef, function (node) {
+    return setItemTextNode(node);
+  }, itemContext.onItemTextChange, function (node) {
+    var _contentContext$itemT;
+    return (_contentContext$itemT = contentContext.itemTextRefCallback) === null || _contentContext$itemT === void 0 ? void 0 : _contentContext$itemT.call(contentContext, node, itemContext.value, itemContext.disabled);
+  });
+  var textContent = itemTextNode === null || itemTextNode === void 0 ? void 0 : itemTextNode.textContent;
+  var nativeOption = useMemo(function () {
+    return /* @__PURE__ */jsx("option", {
+      value: itemContext.value,
+      disabled: itemContext.disabled,
+      children: textContent
+    }, itemContext.value);
+  }, [itemContext.disabled, itemContext.value, textContent]);
+  var onNativeOptionAdd = nativeOptionsContext.onNativeOptionAdd,
+    onNativeOptionRemove = nativeOptionsContext.onNativeOptionRemove;
+  useLayoutEffect2(function () {
+    onNativeOptionAdd(nativeOption);
+    return function () {
+      return onNativeOptionRemove(nativeOption);
+    };
+  }, [onNativeOptionAdd, onNativeOptionRemove, nativeOption]);
+  return /* @__PURE__ */jsxs(Fragment, {
+    children: [/* @__PURE__ */jsx(Primitive.span, _objectSpread2(_objectSpread2({
+      id: itemContext.textId
+    }, itemTextProps), {}, {
+      ref: composedRefs
+    })), itemContext.isSelected && context.valueNode && !context.valueNodeHasChildren ? /*#__PURE__*/createPortal(itemTextProps.children, context.valueNode) : null]
+  });
+});
+SelectItemText.displayName = ITEM_TEXT_NAME;
+var ITEM_INDICATOR_NAME = "SelectItemIndicator";
+var SelectItemIndicator = /*#__PURE__*/forwardRef(function (props, forwardedRef) {
+  var __scopeSelect = props.__scopeSelect,
+    itemIndicatorProps = _objectWithoutProperties(props, _excluded12);
+  var itemContext = useSelectItemContext(ITEM_INDICATOR_NAME, __scopeSelect);
+  return itemContext.isSelected ? /* @__PURE__ */jsx(Primitive.span, _objectSpread2(_objectSpread2({
+    "aria-hidden": true
+  }, itemIndicatorProps), {}, {
+    ref: forwardedRef
+  })) : null;
+});
+SelectItemIndicator.displayName = ITEM_INDICATOR_NAME;
+var SCROLL_UP_BUTTON_NAME = "SelectScrollUpButton";
+var SelectScrollUpButton = /*#__PURE__*/forwardRef(function (props, forwardedRef) {
+  var contentContext = useSelectContentContext(SCROLL_UP_BUTTON_NAME, props.__scopeSelect);
+  var viewportContext = useSelectViewportContext(SCROLL_UP_BUTTON_NAME, props.__scopeSelect);
+  var _React$useState33 = useState(false),
+    _React$useState34 = _slicedToArray(_React$useState33, 2),
+    canScrollUp = _React$useState34[0],
+    setCanScrollUp = _React$useState34[1];
+  var composedRefs = useComposedRefs(forwardedRef, viewportContext.onScrollButtonChange);
+  useLayoutEffect2(function () {
+    if (contentContext.viewport && contentContext.isPositioned) {
+      var handleScroll2 = function handleScroll2() {
+        var canScrollUp2 = viewport.scrollTop > 0;
+        setCanScrollUp(canScrollUp2);
+      };
+      var viewport = contentContext.viewport;
+      handleScroll2();
+      viewport.addEventListener("scroll", handleScroll2);
+      return function () {
+        return viewport.removeEventListener("scroll", handleScroll2);
+      };
+    }
+  }, [contentContext.viewport, contentContext.isPositioned]);
+  return canScrollUp ? /* @__PURE__ */jsx(SelectScrollButtonImpl, _objectSpread2(_objectSpread2({}, props), {}, {
+    ref: composedRefs,
+    onAutoScroll: function onAutoScroll() {
+      var viewport = contentContext.viewport,
+        selectedItem = contentContext.selectedItem;
+      if (viewport && selectedItem) {
+        viewport.scrollTop = viewport.scrollTop - selectedItem.offsetHeight;
+      }
+    }
+  })) : null;
+});
+SelectScrollUpButton.displayName = SCROLL_UP_BUTTON_NAME;
+var SCROLL_DOWN_BUTTON_NAME = "SelectScrollDownButton";
+var SelectScrollDownButton = /*#__PURE__*/forwardRef(function (props, forwardedRef) {
+  var contentContext = useSelectContentContext(SCROLL_DOWN_BUTTON_NAME, props.__scopeSelect);
+  var viewportContext = useSelectViewportContext(SCROLL_DOWN_BUTTON_NAME, props.__scopeSelect);
+  var _React$useState35 = useState(false),
+    _React$useState36 = _slicedToArray(_React$useState35, 2),
+    canScrollDown = _React$useState36[0],
+    setCanScrollDown = _React$useState36[1];
+  var composedRefs = useComposedRefs(forwardedRef, viewportContext.onScrollButtonChange);
+  useLayoutEffect2(function () {
+    if (contentContext.viewport && contentContext.isPositioned) {
+      var handleScroll2 = function handleScroll2() {
+        var maxScroll = viewport.scrollHeight - viewport.clientHeight;
+        var canScrollDown2 = Math.ceil(viewport.scrollTop) < maxScroll;
+        setCanScrollDown(canScrollDown2);
+      };
+      var viewport = contentContext.viewport;
+      handleScroll2();
+      viewport.addEventListener("scroll", handleScroll2);
+      return function () {
+        return viewport.removeEventListener("scroll", handleScroll2);
+      };
+    }
+  }, [contentContext.viewport, contentContext.isPositioned]);
+  return canScrollDown ? /* @__PURE__ */jsx(SelectScrollButtonImpl, _objectSpread2(_objectSpread2({}, props), {}, {
+    ref: composedRefs,
+    onAutoScroll: function onAutoScroll() {
+      var viewport = contentContext.viewport,
+        selectedItem = contentContext.selectedItem;
+      if (viewport && selectedItem) {
+        viewport.scrollTop = viewport.scrollTop + selectedItem.offsetHeight;
+      }
+    }
+  })) : null;
+});
+SelectScrollDownButton.displayName = SCROLL_DOWN_BUTTON_NAME;
+var SelectScrollButtonImpl = /*#__PURE__*/forwardRef(function (props, forwardedRef) {
+  var __scopeSelect = props.__scopeSelect,
+    onAutoScroll = props.onAutoScroll,
+    scrollIndicatorProps = _objectWithoutProperties(props, _excluded13);
+  var contentContext = useSelectContentContext("SelectScrollButton", __scopeSelect);
+  var autoScrollTimerRef = useRef(null);
+  var getItems = useCollection(__scopeSelect);
+  var clearAutoScrollTimer = useCallback(function () {
+    if (autoScrollTimerRef.current !== null) {
+      window.clearInterval(autoScrollTimerRef.current);
+      autoScrollTimerRef.current = null;
+    }
+  }, []);
+  useEffect(function () {
+    return function () {
+      return clearAutoScrollTimer();
+    };
+  }, [clearAutoScrollTimer]);
+  useLayoutEffect2(function () {
+    var _activeItem$ref$curre;
+    var activeItem = getItems().find(function (item) {
+      return item.ref.current === document.activeElement;
+    });
+    activeItem === null || activeItem === void 0 ? void 0 : (_activeItem$ref$curre = activeItem.ref.current) === null || _activeItem$ref$curre === void 0 ? void 0 : _activeItem$ref$curre.scrollIntoView({
+      block: "nearest"
+    });
+  }, [getItems]);
+  return /* @__PURE__ */jsx(Primitive.div, _objectSpread2(_objectSpread2({
+    "aria-hidden": true
+  }, scrollIndicatorProps), {}, {
+    ref: forwardedRef,
+    style: _objectSpread2({
+      flexShrink: 0
+    }, scrollIndicatorProps.style),
+    onPointerDown: composeEventHandlers(scrollIndicatorProps.onPointerDown, function () {
+      if (autoScrollTimerRef.current === null) {
+        autoScrollTimerRef.current = window.setInterval(onAutoScroll, 50);
+      }
+    }),
+    onPointerMove: composeEventHandlers(scrollIndicatorProps.onPointerMove, function () {
+      var _contentContext$onIte3;
+      (_contentContext$onIte3 = contentContext.onItemLeave) === null || _contentContext$onIte3 === void 0 ? void 0 : _contentContext$onIte3.call(contentContext);
+      if (autoScrollTimerRef.current === null) {
+        autoScrollTimerRef.current = window.setInterval(onAutoScroll, 50);
+      }
+    }),
+    onPointerLeave: composeEventHandlers(scrollIndicatorProps.onPointerLeave, function () {
+      clearAutoScrollTimer();
+    })
+  }));
+});
+var SEPARATOR_NAME = "SelectSeparator";
+var SelectSeparator = /*#__PURE__*/forwardRef(function (props, forwardedRef) {
+  var __scopeSelect = props.__scopeSelect,
+    separatorProps = _objectWithoutProperties(props, _excluded14);
+  return /* @__PURE__ */jsx(Primitive.div, _objectSpread2(_objectSpread2({
+    "aria-hidden": true
+  }, separatorProps), {}, {
+    ref: forwardedRef
+  }));
+});
+SelectSeparator.displayName = SEPARATOR_NAME;
+var ARROW_NAME = "SelectArrow";
+var SelectArrow = /*#__PURE__*/forwardRef(function (props, forwardedRef) {
+  var __scopeSelect = props.__scopeSelect,
+    arrowProps = _objectWithoutProperties(props, _excluded15);
+  var popperScope = usePopperScope(__scopeSelect);
+  var context = useSelectContext(ARROW_NAME, __scopeSelect);
+  var contentContext = useSelectContentContext(ARROW_NAME, __scopeSelect);
+  return context.open && contentContext.position === "popper" ? /* @__PURE__ */jsx(Arrow, _objectSpread2(_objectSpread2(_objectSpread2({}, popperScope), arrowProps), {}, {
+    ref: forwardedRef
+  })) : null;
+});
+SelectArrow.displayName = ARROW_NAME;
+function shouldShowPlaceholder(value) {
+  return value === "" || value === void 0;
+}
+var BubbleSelect = /*#__PURE__*/forwardRef(function (props, forwardedRef) {
+  var value = props.value,
+    selectProps = _objectWithoutProperties(props, _excluded16);
+  var ref = useRef(null);
+  var composedRefs = useComposedRefs(forwardedRef, ref);
+  var prevValue = usePrevious(value);
+  useEffect(function () {
+    var select = ref.current;
+    var selectProto = window.HTMLSelectElement.prototype;
+    var descriptor = Object.getOwnPropertyDescriptor(selectProto, "value");
+    var setValue = descriptor.set;
+    if (prevValue !== value && setValue) {
+      var event = new Event("change", {
+        bubbles: true
+      });
+      setValue.call(select, value);
+      select.dispatchEvent(event);
+    }
+  }, [prevValue, value]);
+  return /* @__PURE__ */jsx(VisuallyHidden, {
+    asChild: true,
+    children: /* @__PURE__ */jsx("select", _objectSpread2(_objectSpread2({}, selectProps), {}, {
+      ref: composedRefs,
+      defaultValue: value
+    }))
+  });
+});
+BubbleSelect.displayName = "BubbleSelect";
+function useTypeaheadSearch(onSearchChange) {
+  var handleSearchChange = useCallbackRef(onSearchChange);
+  var searchRef = useRef("");
+  var timerRef = useRef(0);
+  var handleTypeaheadSearch = useCallback(function (key) {
+    var search = searchRef.current + key;
+    handleSearchChange(search);
+    (function updateSearch(value) {
+      searchRef.current = value;
+      window.clearTimeout(timerRef.current);
+      if (value !== "") timerRef.current = window.setTimeout(function () {
+        return updateSearch("");
+      }, 1e3);
+    })(search);
+  }, [handleSearchChange]);
+  var resetTypeahead = useCallback(function () {
+    searchRef.current = "";
+    window.clearTimeout(timerRef.current);
+  }, []);
+  useEffect(function () {
+    return function () {
+      return window.clearTimeout(timerRef.current);
+    };
+  }, []);
+  return [searchRef, handleTypeaheadSearch, resetTypeahead];
+}
+function findNextItem(items, search, currentItem) {
+  var isRepeated = search.length > 1 && Array.from(search).every(function (char) {
+    return char === search[0];
+  });
+  var normalizedSearch = isRepeated ? search[0] : search;
+  var currentItemIndex = currentItem ? items.indexOf(currentItem) : -1;
+  var wrappedItems = wrapArray(items, Math.max(currentItemIndex, 0));
+  var excludeCurrentItem = normalizedSearch.length === 1;
+  if (excludeCurrentItem) wrappedItems = wrappedItems.filter(function (v) {
+    return v !== currentItem;
+  });
+  var nextItem = wrappedItems.find(function (item) {
+    return item.textValue.toLowerCase().startsWith(normalizedSearch.toLowerCase());
+  });
+  return nextItem !== currentItem ? nextItem : void 0;
+}
+function wrapArray(array, startIndex) {
+  return array.map(function (_, index) {
+    return array[(startIndex + index) % array.length];
+  });
+}
+var Root2 = Select;
+var Trigger = SelectTrigger;
+var Icon = SelectIcon;
+var Portal = SelectPortal;
+var Content2 = SelectContent;
+var Viewport = SelectViewport;
+var Item = SelectItem;
+var ItemText = SelectItemText;
+var ItemIndicator = SelectItemIndicator;
+
+export { Content2 as Content, Icon, Item, ItemIndicator, ItemText, Portal, Root2 as Root, Select, SelectArrow, SelectContent, SelectGroup, SelectIcon, SelectItem, SelectItemIndicator, SelectItemText, SelectLabel, SelectPortal, SelectScrollDownButton, SelectScrollUpButton, SelectSeparator, SelectTrigger, SelectValue, SelectViewport, Trigger, Viewport, createSelectScope };
+//# sourceMappingURL=index.mjs.js.map