@dreamcommerce/aurora 3.0.0-64 → 3.0.0-66

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

@@ -0,0 +1,1302 @@
+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 { createPortal } from 'react-dom';
+import { Slot } from '@radix-ui/react-slot';
+import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
+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 { usePrevious } from '../../react-use-previous/dist/index.mjs.js';
+import { useLayoutEffect as useLayoutEffect2 } from '../../react-use-layout-effect/dist/index.mjs.js';
+import { clamp } from '../../number/dist/index.mjs.js';
+import { composeEventHandlers } from '../external/@radix-ui/primitive/dist/index.mjs.js';
+import { useComposedRefs } from '../external/@radix-ui/react-compose-refs/dist/index.mjs.js';
+import { createCollection } from '../external/@radix-ui/react-collection/dist/index.mjs.js';
+import { useDirection } from '../../react-direction/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 '../../react-focus-guards/dist/index.mjs.js';
+import { FocusScope } from '../external/@radix-ui/react-focus-scope/dist/index.mjs.js';
+import { useId } from '../../react-id/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 '../../../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 Value = SelectValue;
+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, Value, Viewport, createSelectScope };
+//# sourceMappingURL=index.mjs.js.map