@zendeskgarden/react-dropdowns 9.0.0-next.1 → 9.0.0-next.11

package/dist/index.cjs.js

@@ -1,24 +1,26 @@
 /**
- * Copyright Zendesk, Inc.
- *
- * Use of this source code is governed under the Apache License, Version 2.0
- * found at http://www.apache.org/licenses/LICENSE-2.0.
- */
-
+* Copyright Zendesk, Inc.
+*
+* Use of this source code is governed under the Apache License, Version 2.0
+* found at http://www.apache.org/licenses/LICENSE-2.0.
+*/
 'use strict';
 
 var React = require('react');
 var PropTypes = require('prop-types');
 var styled = require('styled-components');
-var Downshift = require('downshift');
-var reactPopper = require('react-popper');
-var containerUtilities = require('@zendeskgarden/container-utilities');
+var containerCombobox = require('@zendeskgarden/container-combobox');
 var reactTheming = require('@zendeskgarden/react-theming');
-var polished = require('polished');
 var reactForms = require('@zendeskgarden/react-forms');
+var polished = require('polished');
+var reactTags = require('@zendeskgarden/react-tags');
+var reactButtons = require('@zendeskgarden/react-buttons');
+var reactDom$1 = require('react-dom');
+var reactDom = require('@floating-ui/react-dom');
+var containerUtilities = require('@zendeskgarden/container-utilities');
+var reactTooltips = require('@zendeskgarden/react-tooltips');
 var reactMergeRefs = require('react-merge-refs');
-var containerSelection = require('@zendeskgarden/container-selection');
-var reactDom = require('react-dom');
+var containerMenu = require('@zendeskgarden/container-menu');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
@@ -43,1671 +45,1258 @@ function _interopNamespace(e) {
 var React__namespace = /*#__PURE__*/_interopNamespace(React);
 var PropTypes__default = /*#__PURE__*/_interopDefault(PropTypes);
 var styled__default = /*#__PURE__*/_interopDefault(styled);
-var Downshift__default = /*#__PURE__*/_interopDefault(Downshift);
-
-function _extends$5() {
-  _extends$5 = Object.assign ? Object.assign.bind() : function (target) {
-    for (var i = 1; i < arguments.length; i++) {
-      var source = arguments[i];
-      for (var key in source) {
-        if (Object.prototype.hasOwnProperty.call(source, key)) {
-          target[key] = source[key];
-        }
-      }
-    }
-    return target;
-  };
-  return _extends$5.apply(this, arguments);
-}
 
-const DropdownContext = React__namespace.default.createContext(undefined);
-const useDropdownContext = () => {
-  const dropdownContext = React.useContext(DropdownContext);
-  if (!dropdownContext) {
-    throw new Error('This component must be rendered within a `Dropdown` component.');
-  }
-  return dropdownContext;
+var _path$4;
+function _extends$4() { _extends$4 = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends$4.apply(this, arguments); }
+var SvgChevronDownStroke = function SvgChevronDownStroke(props) {
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$4({
+    xmlns: "http://www.w3.org/2000/svg",
+    width: 16,
+    height: 16,
+    focusable: "false",
+    viewBox: "0 0 16 16",
+    "aria-hidden": "true"
+  }, props), _path$4 || (_path$4 = /*#__PURE__*/React__namespace.createElement("path", {
+    fill: "currentColor",
+    d: "M12.688 5.61a.5.5 0 01.69.718l-.066.062-5 4a.5.5 0 01-.542.054l-.082-.054-5-4a.5.5 0 01.55-.83l.074.05L8 9.359l4.688-3.75z"
+  })));
 };
 
-const REMOVE_ITEM_STATE_TYPE = 'REMOVE_ITEM';
-const Dropdown = props => {
-  const {
-    children,
-    isOpen,
-    selectedItem,
-    selectedItems,
-    highlightedIndex,
-    inputValue,
-    onSelect,
-    onStateChange,
-    onInputValueChange,
-    downshiftProps
-  } = props;
-  const itemIndexRef = React.useRef(0);
-  const previousItemRef = React.useRef(undefined);
-  const previousIndexRef = React.useRef(undefined);
-  const nextItemsHashRef = React.useRef({});
-  const containsMultiselectRef = React.useRef(false);
-  const itemSearchRegistry = React.useRef([]);
-  const [dropdownType, setDropdownType] = React.useState('');
-  const {
-    rtl
-  } = React.useContext(styled.ThemeContext);
-  const hasMenuRef = React.useRef(false);
-  const popperReferenceElementRef = React.useRef(null);
-  const customGetInputProps = (_ref, downshift) => {
-    let {
-      onKeyDown,
-      ...other
-    } = _ref;
-    return {
-      onKeyDown: containerUtilities.composeEventHandlers(onKeyDown, e => {
-        const PREVIOUS_KEY = rtl ? containerUtilities.KEY_CODES.RIGHT : containerUtilities.KEY_CODES.LEFT;
-        const NEXT_KEY = rtl ? containerUtilities.KEY_CODES.LEFT : containerUtilities.KEY_CODES.RIGHT;
-        if (downshift.isOpen) {
-          if (e.keyCode === PREVIOUS_KEY && previousIndexRef.current !== null && previousIndexRef.current !== undefined && !downshift.inputValue) {
-            e.preventDefault();
-            e.stopPropagation();
-            downshift.selectItemAtIndex(previousIndexRef.current);
-          }
-          if (e.keyCode === NEXT_KEY) {
-            const nextItemIndexes = Object.values(nextItemsHashRef.current);
-            if (nextItemIndexes.includes(downshift.highlightedIndex)) {
-              e.preventDefault();
-              e.stopPropagation();
-              downshift.selectItemAtIndex(downshift.highlightedIndex);
-            }
-          }
-        } else if ((e.keyCode === containerUtilities.KEY_CODES.ENTER || e.keyCode === containerUtilities.KEY_CODES.SPACE) && !downshift.isOpen && dropdownType !== 'combobox') {
-          e.preventDefault();
-          e.stopPropagation();
-          downshift.openMenu();
-        }
-      }),
-      ...other
-    };
-  };
-  const transformDownshift = _ref2 => {
-    let {
-      getInputProps,
-      getToggleButtonProps,
-      ...downshift
-    } = _ref2;
-    return {
-      getInputProps: p => getInputProps(customGetInputProps(p, downshift)),
-      getToggleButtonProps: p => getToggleButtonProps({
-        'aria-label': undefined,
-        ...p
-      }),
-      ...downshift
-    };
-  };
-  return React__namespace.default.createElement(reactPopper.Manager, null, React__namespace.default.createElement(Downshift__default.default, _extends$5({
-    suppressRefError: true
-    ,
-    isOpen: isOpen,
-    highlightedIndex: highlightedIndex,
-    selectedItem: selectedItem || null
-    ,
-    inputValue: inputValue,
-    onInputValueChange: (inputVal, stateAndHelpers) => {
-      if (onInputValueChange) {
-        if (stateAndHelpers.isOpen) {
-          onInputValueChange(inputVal, stateAndHelpers);
-        } else if (dropdownType === 'multiselect') {
-          onInputValueChange('', stateAndHelpers);
-        }
-      }
-    },
-    onStateChange: (changes, stateAndHelpers) => {
-      if (dropdownType === 'autocomplete' && changes.isOpen === false && !changes.selectedItem) {
-        onSelect && onSelect(selectedItem, stateAndHelpers);
-      }
-      if (Object.prototype.hasOwnProperty.call(changes, 'selectedItem') && changes.selectedItem !== null) {
-        if (selectedItems) {
-          const {
-            itemToString
-          } = stateAndHelpers;
-          const existingItemIndex = selectedItems.findIndex(item => {
-            return itemToString(item) === itemToString(changes.selectedItem);
-          });
-          const updatedSelectedItems = Array.from(selectedItems);
-          if (existingItemIndex === -1) {
-            updatedSelectedItems.splice(updatedSelectedItems.length, 0, changes.selectedItem);
-          } else {
-            updatedSelectedItems.splice(existingItemIndex, 1);
-          }
-          changes.selectedItems = updatedSelectedItems;
-          delete changes.selectedItem;
-          onSelect && onSelect(updatedSelectedItems, stateAndHelpers);
-        } else {
-          onSelect && onSelect(changes.selectedItem, stateAndHelpers);
-        }
-        if (dropdownType === 'multiselect') {
-          stateAndHelpers.setState({
-            inputValue: ''
-          });
-        }
-      }
-      onStateChange && onStateChange(changes, stateAndHelpers);
-    },
-    stateReducer: (_state, changes) => {
-      switch (changes.type) {
-        case Downshift__default.default.stateChangeTypes.changeInput:
-          if (changes.inputValue === '' && dropdownType === 'combobox') {
-            return {
-              ...changes,
-              isOpen: false
-            };
-          }
-          return changes;
-        default:
-          return changes;
-      }
-    }
-  }, downshiftProps), downshift => React__namespace.default.createElement(DropdownContext.Provider, {
-    value: {
-      hasMenuRef,
-      itemIndexRef,
-      previousItemRef,
-      previousIndexRef,
-      nextItemsHashRef,
-      popperReferenceElementRef,
-      selectedItems,
-      downshift: transformDownshift(downshift),
-      containsMultiselectRef,
-      itemSearchRegistry,
-      setDropdownType
-    }
-  }, children)));
-};
-Dropdown.propTypes = {
-  isOpen: PropTypes__default.default.bool,
-  selectedItem: PropTypes__default.default.any,
-  selectedItems: PropTypes__default.default.arrayOf(PropTypes__default.default.any),
-  highlightedIndex: PropTypes__default.default.number,
-  inputValue: PropTypes__default.default.string,
-  onSelect: PropTypes__default.default.func,
-  onStateChange: PropTypes__default.default.func,
-  downshiftProps: PropTypes__default.default.object
-};
-
-function getPopperPlacement(gardenPlacement) {
-  switch (gardenPlacement) {
-    case 'end':
-      return 'right';
-    case 'end-top':
-      return 'right-start';
-    case 'end-bottom':
-      return 'right-end';
-    case 'start':
-      return 'left';
-    case 'start-top':
-      return 'left-start';
-    case 'start-bottom':
-      return 'left-end';
-    default:
-      return gardenPlacement;
-  }
-}
-function getRtlPopperPlacement(gardenPlacement) {
-  const popperPlacement = getPopperPlacement(gardenPlacement);
-  switch (popperPlacement) {
-    case 'left':
-      return 'right';
-    case 'left-start':
-      return 'right-start';
-    case 'left-end':
-      return 'right-end';
-    case 'top-start':
-      return 'top-end';
-    case 'top-end':
-      return 'top-start';
-    case 'right':
-      return 'left';
-    case 'right-start':
-      return 'left-start';
-    case 'right-end':
-      return 'left-end';
-    case 'bottom-start':
-      return 'bottom-end';
-    case 'bottom-end':
-      return 'bottom-start';
-    default:
-      return popperPlacement;
+const ComboboxContext = React.createContext(undefined);
+const useComboboxContext = () => {
+  const context = React.useContext(ComboboxContext);
+  if (!context) {
+    throw new Error('Error: this component must be rendered within a <Combobox>.');
   }
-}
-function getArrowPosition(popperPlacement) {
-  const arrowPositionMappings = {
-    auto: 'top',
-    top: 'bottom',
-    'top-start': 'bottom-left',
-    'top-end': 'bottom-right',
-    right: 'left',
-    'right-start': 'left-top',
-    'right-end': 'left-bottom',
-    bottom: 'top',
-    'bottom-start': 'top-left',
-    'bottom-end': 'top-right',
-    left: 'right',
-    'left-start': 'right-top',
-    'left-end': 'right-bottom'
-  };
-  return popperPlacement ? arrowPositionMappings[popperPlacement] : 'top';
-}
-function getMenuPosition(popperPlacement) {
-  if (popperPlacement === 'auto') {
-    return 'bottom';
+  return context;
+};
+
+const FieldContext = React.createContext(undefined);
+const useFieldContext = () => {
+  const context = React.useContext(FieldContext);
+  if (!context) {
+    throw new Error('Error: this component must be rendered within a <Field>.');
   }
-  return popperPlacement ? popperPlacement.split('-')[0] : 'bottom';
-}
+  return context;
+};
 
-const COMPONENT_ID$m = 'dropdowns.menu';
-const StyledMenu = styled__default.default.ul.attrs(props => ({
-  'data-garden-id': COMPONENT_ID$m,
-  'data-garden-version': '9.0.0-next.1',
-  className: props.isAnimated && 'is-animated'
-})).withConfig({
-  displayName: "StyledMenu",
-  componentId: "sc-1vpttfd-0"
-})(["position:static !important;max-height:", ";overflow-y:auto;", ";", ";"], props => props.maxHeight, props => props.hasArrow && reactTheming.arrowStyles(getArrowPosition(props.placement), {
-  size: `${props.theme.space.base * 2}px`,
-  inset: '2px',
-  animationModifier: props.isAnimated ? '.is-animated' : undefined
-}), props => reactTheming.retrieveComponentStyles(COMPONENT_ID$m, props));
-StyledMenu.defaultProps = {
+const COMPONENT_ID$v = 'dropdowns.combobox.label';
+const StyledLabel = styled__default.default(reactForms.Field.Label).attrs({
+  'data-garden-id': COMPONENT_ID$v,
+  'data-garden-version': '9.0.0-next.11'
+}).withConfig({
+  displayName: "StyledLabel",
+  componentId: "sc-az6now-0"
+})(["vertical-align:revert;", ";"], props => reactTheming.retrieveComponentStyles(COMPONENT_ID$v, props));
+StyledLabel.defaultProps = {
   theme: reactTheming.DEFAULT_THEME
 };
 
-const COMPONENT_ID$l = 'dropdowns.menu_wrapper';
-const StyledMenuWrapper = styled__default.default.div.attrs(props => ({
-  'data-garden-id': COMPONENT_ID$l,
-  'data-garden-version': '9.0.0-next.1',
-  className: props.isAnimated && 'is-animated'
-})).withConfig({
-  displayName: "StyledMenuWrapper",
-  componentId: "sc-tiwdxz-0"
-})(["", ";", ";"], props => reactTheming.menuStyles(getMenuPosition(props.placement), {
+const COMPONENT_ID$u = 'dropdowns.combobox.hint';
+const StyledHint = styled__default.default(reactForms.Field.Hint).attrs({
+  'data-garden-id': COMPONENT_ID$u,
+  'data-garden-version': '9.0.0-next.11'
+}).withConfig({
+  displayName: "StyledHint",
+  componentId: "sc-106qvqx-0"
+})(["", ";"], props => reactTheming.retrieveComponentStyles(COMPONENT_ID$u, props));
+StyledHint.defaultProps = {
+  theme: reactTheming.DEFAULT_THEME
+};
+
+const COMPONENT_ID$t = 'dropdowns.combobox.message';
+const StyledMessage = styled__default.default(reactForms.Field.Message).attrs({
+  'data-garden-id': COMPONENT_ID$t,
+  'data-garden-version': '9.0.0-next.11'
+}).withConfig({
+  displayName: "StyledMessage",
+  componentId: "sc-jux8m5-0"
+})(["", ";"], props => reactTheming.retrieveComponentStyles(COMPONENT_ID$t, props));
+StyledMessage.defaultProps = {
+  theme: reactTheming.DEFAULT_THEME
+};
+
+const COMPONENT_ID$s = 'dropdowns.combobox';
+const sizeStyles$a = props => {
+  const minWidth = `${props.isCompact ? 100 : 144}px`;
+  const marginTop = `${props.theme.space.base * (props.isCompact ? 1 : 2)}px`;
+  return styled.css(["min-width:", ";", ":not([hidden]) + &&,", " + &&,", " + &&,&& + ", ",&& + ", "{margin-top:", ";}"], minWidth, StyledLabel, StyledHint, StyledMessage, StyledHint, StyledMessage, marginTop);
+};
+const StyledCombobox = styled__default.default.div.attrs({
+  'data-garden-id': COMPONENT_ID$s,
+  'data-garden-version': '9.0.0-next.11'
+}).withConfig({
+  displayName: "StyledCombobox",
+  componentId: "sc-13eybg8-0"
+})(["", ";", ";"], sizeStyles$a, props => reactTheming.retrieveComponentStyles(COMPONENT_ID$s, props));
+StyledCombobox.defaultProps = {
+  theme: reactTheming.DEFAULT_THEME
+};
+
+const COMPONENT_ID$r = 'dropdowns.combobox.container';
+const StyledContainer = styled__default.default.div.attrs({
+  'data-garden-id': COMPONENT_ID$r,
+  'data-garden-version': '9.0.0-next.11'
+}).withConfig({
+  displayName: "StyledContainer",
+  componentId: "sc-14i9jid-0"
+})(["display:flex;", ";"], props => reactTheming.retrieveComponentStyles(COMPONENT_ID$r, props));
+StyledContainer.defaultProps = {
+  theme: reactTheming.DEFAULT_THEME
+};
+
+const COMPONENT_ID$q = 'dropdowns.combobox.field';
+const StyledField = styled__default.default.div.attrs({
+  'data-garden-id': COMPONENT_ID$q,
+  'data-garden-version': '9.0.0-next.11'
+}).withConfig({
+  displayName: "StyledField",
+  componentId: "sc-zc57xl-0"
+})(["direction:", ";", ";"], props => props.theme.rtl ? 'rtl' : 'ltr', props => reactTheming.retrieveComponentStyles(COMPONENT_ID$q, props));
+StyledField.defaultProps = {
+  theme: reactTheming.DEFAULT_THEME
+};
+
+const COMPONENT_ID$p = 'dropdowns.combobox.floating';
+const StyledFloatingListbox = styled__default.default.div.attrs({
+  'data-garden-id': COMPONENT_ID$p,
+  'data-garden-version': '9.0.0-next.11'
+}).withConfig({
+  displayName: "StyledFloatingListbox",
+  componentId: "sc-1cp6spf-0"
+})(["top:0;left:0;", ";", ";"], props => reactTheming.menuStyles(props.position, {
   theme: props.theme,
   hidden: props.isHidden,
-  margin: `${props.theme.space.base * (props.hasArrow ? 2 : 1)}px`,
-  zIndex: props.zIndex,
-  animationModifier: props.isAnimated ? '.is-animated' : undefined
-}), props => reactTheming.retrieveComponentStyles(COMPONENT_ID$l, props));
-StyledMenuWrapper.defaultProps = {
+  animationModifier: '[data-garden-animate="true"]',
+  zIndex: props.zIndex
+}), props => reactTheming.retrieveComponentStyles(COMPONENT_ID$p, props));
+StyledFloatingListbox.defaultProps = {
   theme: reactTheming.DEFAULT_THEME
 };
 
-const COMPONENT_ID$k = 'dropdowns.separator';
-const StyledSeparator = styled__default.default.li.attrs({
-  'data-garden-id': COMPONENT_ID$k,
-  'data-garden-version': '9.0.0-next.1',
-  role: 'separator'
+const COMPONENT_ID$o = 'dropdowns.combobox.input';
+const colorStyles$8 = props => {
+  const placeholderColor = reactTheming.getColorV8('neutralHue', 400, props.theme);
+  return styled.css(["background-color:inherit;color:inherit;&::placeholder{opacity:1;color:", ";}"], placeholderColor);
+};
+const getHeight = props => {
+  if (props.isBare && !props.isMultiselectable) {
+    return props.theme.space.base * 5;
+  }
+  return props.theme.space.base * (props.isCompact ? 5 : 8);
+};
+const sizeStyles$9 = props => {
+  const height = props.theme.space.base * 5;
+  const fontSize = props.theme.fontSizes.md;
+  const lineHeight = reactTheming.getLineHeight(height, fontSize);
+  const margin = polished.math(`${props.theme.shadowWidths.sm} + ${(getHeight(props) - height) / 2}`);
+  const minWidth = `${props.theme.space.base * 8}px`;
+  return styled.css(["min-width:", ";height:", "px;line-height:", ";font-size:", ";&&{margin-top:", ";margin-bottom:", ";}"], minWidth, height, lineHeight, fontSize, margin, margin);
+};
+const StyledInput = styled__default.default.input.attrs({
+  'data-garden-id': COMPONENT_ID$o,
+  'data-garden-version': '9.0.0-next.11'
 }).withConfig({
-  displayName: "StyledSeparator",
-  componentId: "sc-1mrnp18-0"
-})(["display:block;margin:", "px 0;border-bottom:", ";", ";"], props => props.theme.space.base, props => `${props.theme.borders.sm} ${reactTheming.getColor('neutralHue', 200, props.theme)}`, props => reactTheming.retrieveComponentStyles(COMPONENT_ID$k, props));
-StyledSeparator.defaultProps = {
+  displayName: "StyledInput",
+  componentId: "sc-1lkqdg-0"
+})(["flex-basis:0;flex-grow:1;border:none;padding:0;font-family:inherit;&:focus{outline:none;}", ";", ";&[hidden]{display:revert;", "}&[aria-hidden='true']{display:none;}", ";"], sizeStyles$9, colorStyles$8, props => props.isEditable && polished.hideVisually(), props => reactTheming.retrieveComponentStyles(COMPONENT_ID$o, props));
+StyledInput.defaultProps = {
+  theme: reactTheming.DEFAULT_THEME
+};
+
+const COMPONENT_ID$n = 'dropdowns.combobox.input_group';
+const sizeStyles$8 = props => {
+  const margin = props.theme.shadowWidths.sm;
+  return styled.css(["margin:-", ";min-width:0;& > *{margin:", ";}"], margin, margin);
+};
+const StyledInputGroup = styled__default.default.div.attrs({
+  'data-garden-id': COMPONENT_ID$n,
+  'data-garden-version': '9.0.0-next.11'
+}).withConfig({
+  displayName: "StyledInputGroup",
+  componentId: "sc-yx3q7u-0"
+})(["display:flex;flex-grow:1;flex-wrap:wrap;", ";", ";"], sizeStyles$8, props => reactTheming.retrieveComponentStyles(COMPONENT_ID$n, props));
+StyledInputGroup.defaultProps = {
   theme: reactTheming.DEFAULT_THEME
 };
 
-const COMPONENT_ID$j = 'dropdowns.item';
-const getItemPaddingVertical = props => {
-  if (props.isCompact) {
-    return `${props.theme.space.base}px`;
+const COMPONENT_ID$m = 'dropdowns.combobox.trigger';
+const colorStyles$7 = props => {
+  const SHADE = 600;
+  let hue = 'neutralHue';
+  if (props.validation === 'success') {
+    hue = 'successHue';
+  } else if (props.validation === 'warning') {
+    hue = 'warningHue';
+  } else if (props.validation === 'error') {
+    hue = 'dangerHue';
+  }
+  const backgroundColor = props.isBare ? 'transparent' : reactTheming.getColorV8('background', 600 , props.theme);
+  let borderColor;
+  let hoverBorderColor;
+  let focusBorderColor;
+  let focusShade;
+  if (props.validation) {
+    borderColor = reactTheming.getColorV8(hue, SHADE, props.theme);
+    hoverBorderColor = borderColor;
+    if (props.validation === 'warning') {
+      focusBorderColor = reactTheming.getColorV8(hue, SHADE + 100, props.theme);
+      focusShade = SHADE + 100;
+    } else {
+      focusBorderColor = borderColor;
+    }
+  } else {
+    borderColor = reactTheming.getColorV8('neutralHue', SHADE - 300, props.theme);
+    hoverBorderColor = reactTheming.getColorV8('primaryHue', SHADE, props.theme);
+    focusBorderColor = hoverBorderColor;
   }
-  return `${props.theme.space.base * 2}px`;
+  const disabledBackgroundColor = props.isBare ? undefined : reactTheming.getColorV8('neutralHue', SHADE - 500, props.theme);
+  const disabledBorderColor = reactTheming.getColorV8('neutralHue', SHADE - 400, props.theme);
+  const disabledForegroundColor = reactTheming.getColorV8('neutralHue', SHADE - 200, props.theme);
+  const focusSelector = `
+    &:focus-within:not([aria-disabled='true']),
+    &:focus-visible
+  `;
+  return styled.css(["border-color:", ";background-color:", ";color:", ";&:hover{border-color:", ";}", " &[aria-disabled='true']{border-color:", ";background-color:", ";color:", ";}"], props.isLabelHovered ? hoverBorderColor : borderColor, backgroundColor, reactTheming.getColorV8('foreground', 600 , props.theme), hoverBorderColor, reactTheming.focusStyles({
+    theme: props.theme,
+    inset: props.focusInset,
+    color: {
+      hue: focusBorderColor,
+      shade: focusShade
+    },
+    selector: focusSelector,
+    styles: {
+      borderColor: focusBorderColor
+    },
+    condition: !props.isBare
+  }), disabledBorderColor, disabledBackgroundColor, disabledForegroundColor);
 };
-const getColorStyles = props => {
-  let foregroundColor;
-  let backgroundColor;
-  if (props.disabled) {
-    foregroundColor = reactTheming.getColor('neutralHue', 400, props.theme);
-  } else if (props.isDanger) {
-    foregroundColor = reactTheming.getColor('dangerHue', 600, props.theme);
-    backgroundColor = props.isFocused ? polished.rgba(foregroundColor, 0.08) : 'inherit';
+const sizeStyles$7 = props => {
+  const inputHeight = getHeight(props);
+  let minHeight;
+  let horizontalPadding;
+  if (props.isBare) {
+    if (props.isMultiselectable) {
+      minHeight = polished.math(`${props.theme.shadowWidths.sm} * 2 + ${inputHeight}`);
+      horizontalPadding = props.theme.shadowWidths.sm;
+    } else {
+      minHeight = `${inputHeight}px`;
+      horizontalPadding = '0';
+    }
+  } else {
+    minHeight = `${props.theme.space.base * (props.isCompact ? 3 : 2) + inputHeight}px`;
+    horizontalPadding = `${props.theme.space.base * 3}px`;
+  }
+  const maxHeight = props.maxHeight || minHeight;
+  const verticalPadding = polished.math(`(${minHeight} - ${inputHeight} - (${props.isBare ? 0 : props.theme.borderWidths.sm} * 2)) / 2`);
+  return styled.css(["padding:", " ", ";min-height:", ";max-height:", ";font-size:", ";"], verticalPadding, horizontalPadding, minHeight, maxHeight, props.theme.fontSizes.md);
+};
+const StyledTrigger = styled__default.default.div.attrs({
+  'data-garden-id': COMPONENT_ID$m,
+  'data-garden-version': '9.0.0-next.11'
+}).withConfig({
+  displayName: "StyledTrigger",
+  componentId: "sc-116nftk-0"
+})(["overflow-y:auto;transition:border-color 0.25s ease-in-out,box-shadow 0.1s ease-in-out,background-color 0.25s ease-in-out,color 0.25s ease-in-out;border:", ";border-radius:", ";cursor:", ";box-sizing:border-box;", ";&:focus{outline:none;}", ";&[aria-disabled='true']{cursor:default;}", ";"], props => props.isBare ? 'none' : props.theme.borders.sm, props => props.isBare ? '0' : props.theme.borderRadii.md, props => !props.isAutocomplete && props.isEditable ? 'text' : 'pointer', sizeStyles$7, colorStyles$7, props => reactTheming.retrieveComponentStyles(COMPONENT_ID$m, props));
+StyledTrigger.defaultProps = {
+  theme: reactTheming.DEFAULT_THEME
+};
+
+const COMPONENT_ID$l = 'dropdowns.combobox.input_icon';
+const colorStyles$6 = props => {
+  const color = reactTheming.getColorV8('neutralHue', 600, props.theme);
+  const focusColor = reactTheming.getColorV8('neutralHue', 700, props.theme);
+  const disabledColor = reactTheming.getColorV8('neutralHue', 400, props.theme);
+  return styled.css(["color:", ";", ":hover &,", ":focus-within &,", ":focus &{color:", ";}", "[aria-disabled='true'] &{color:", ";}"], props.$isLabelHovered ? focusColor : color, StyledTrigger, StyledTrigger, StyledTrigger, focusColor, StyledTrigger, disabledColor);
+};
+const sizeStyles$6 = props => {
+  const size = props.theme.iconSizes.md;
+  const position = polished.math(`(${getHeight(props)} - ${size}) / 2`);
+  const margin = `${props.theme.space.base * 2}px`;
+  let side;
+  if (props.$isEnd) {
+    side = props.theme.rtl ? 'right' : 'left';
   } else {
-    foregroundColor = props.theme.colors.foreground;
-    backgroundColor = props.isFocused ? reactTheming.getColor('primaryHue', 600, props.theme, 0.08) : 'inherit';
+    side = props.theme.rtl ? 'left' : 'right';
+  }
+  return styled.css(["top:", ";margin-", ":", ";width:", ";height:", ";"], position, side, margin, size, size);
+};
+const StyledInputIcon = styled__default.default(reactTheming.StyledBaseIcon).attrs({
+  'data-garden-id': COMPONENT_ID$l,
+  'data-garden-version': '9.0.0-next.11'
+}).withConfig({
+  displayName: "StyledInputIcon",
+  componentId: "sc-gqbs1s-0"
+})(["position:sticky;flex-shrink:0;transform:", ";transition:transform 0.25s ease-in-out,color 0.25s ease-in-out;", ";", ";", ";"], props => props.$isRotated && `rotate(${props.theme.rtl ? '-' : '+'}180deg)`, sizeStyles$6, colorStyles$6, props => reactTheming.retrieveComponentStyles(COMPONENT_ID$l, props));
+StyledInputIcon.defaultProps = {
+  theme: reactTheming.DEFAULT_THEME
+};
+
+const COMPONENT_ID$k = 'dropdowns.combobox.option';
+const colorStyles$5 = props => {
+  let backgroundColor;
+  let boxShadow;
+  if (props.isActive && props.$type !== 'group' && props.$type !== 'header') {
+    const hue = props.$type === 'danger' ? 'dangerHue' : 'primaryHue';
+    backgroundColor = reactTheming.getColorV8(hue, 600, props.theme, 0.08);
+    boxShadow = `inset ${props.theme.rtl ? `-${props.theme.shadowWidths.md}` : props.theme.shadowWidths.md} 0 ${reactTheming.getColorV8(hue, 600, props.theme)}`;
+  }
+  const disabledForegroundColor = reactTheming.getColorV8('neutralHue', 400, props.theme);
+  let foregroundColor = reactTheming.getColorV8('foreground', 600 , props.theme);
+  if (props.$type === 'add') {
+    foregroundColor = reactTheming.getColorV8('primaryHue', 600, props.theme);
+  } else if (props.$type === 'danger') {
+    foregroundColor = reactTheming.getColorV8('dangerHue', 600, props.theme);
   }
-  return styled.css(["background-color:", ";color:", ";& a,& a:hover,& a:focus,& a:active{color:inherit;}"], backgroundColor, foregroundColor);
+  return styled.css(["box-shadow:", ";background-color:", ";color:", ";&[aria-disabled='true']{background-color:transparent;color:", ";}"], boxShadow, backgroundColor, foregroundColor, disabledForegroundColor);
+};
+const getMinHeight = props => props.theme.space.base * (props.isCompact ? 7 : 9);
+const sizeStyles$5 = props => {
+  const lineHeight = props.theme.lineHeights.md;
+  const minHeight = getMinHeight(props);
+  const paddingHorizontal = props.$type === 'group' ? 0 : `${props.theme.space.base * 9}px`;
+  const paddingVertical = props.$type === 'group' ? 0 : polished.math(`(${minHeight} - ${lineHeight}) / 2`);
+  return styled.css(["box-sizing:border-box;padding:", " ", ";min-height:", "px;line-height:", ";"], paddingVertical, paddingHorizontal, minHeight, lineHeight);
+};
+const StyledOption = styled__default.default.li.attrs({
+  'data-garden-id': COMPONENT_ID$k,
+  'data-garden-version': '9.0.0-next.11'
+}).withConfig({
+  displayName: "StyledOption",
+  componentId: "sc-jl4wn6-0"
+})(["display:flex;position:relative;transition:color 0.25s ease-in-out;cursor:", ";overflow-wrap:anywhere;font-weight:", ";user-select:none;&:focus{outline:none;}", ";", ";&[aria-disabled='true']{cursor:default;}&[aria-hidden='true']{", ";}", ";"], props => props.$type === 'group' || props.$type === 'header' ? 'default' : 'pointer', props => props.$type === 'header' || props.$type === 'previous' ? props.theme.fontWeights.semibold : props.theme.fontWeights.regular, sizeStyles$5, colorStyles$5, polished.hideVisually(), props => reactTheming.retrieveComponentStyles(COMPONENT_ID$k, props));
+StyledOption.defaultProps = {
+  theme: reactTheming.DEFAULT_THEME
 };
-const StyledItem = styled__default.default.li.attrs(props => ({
+
+const COMPONENT_ID$j = 'dropdowns.combobox.option.content';
+const StyledOptionContent = styled__default.default.div.attrs({
   'data-garden-id': COMPONENT_ID$j,
-  'data-garden-version': '9.0.0-next.1',
-  'aria-disabled': props.disabled
-})).withConfig({
-  displayName: "StyledItem",
-  componentId: "sc-1xeog7q-0"
-})(["display:block;position:relative;z-index:0;cursor:", ";padding:", " ", "px;text-decoration:none;line-height:", "px;word-wrap:break-word;user-select:none;&:first-child{margin-top:", "px;}&:last-child{margin-bottom:", "px;}&:focus{outline:none;}& a,& a:hover,& a:focus,& a:active{text-decoration:none;}", ";", ";"], props => props.disabled ? 'default' : 'pointer', props => getItemPaddingVertical(props), props => props.theme.space.base * 9, props => props.theme.space.base * 5, props => props.theme.space.base, props => props.theme.space.base, props => getColorStyles(props), props => reactTheming.retrieveComponentStyles(COMPONENT_ID$j, props));
-StyledItem.defaultProps = {
+  'data-garden-version': '9.0.0-next.11'
+}).withConfig({
+  displayName: "StyledOptionContent",
+  componentId: "sc-121ujpu-0"
+})(["display:flex;flex-direction:column;flex-grow:1;", ";"], props => reactTheming.retrieveComponentStyles(COMPONENT_ID$j, props));
+StyledOptionContent.defaultProps = {
   theme: reactTheming.DEFAULT_THEME
 };
 
-const COMPONENT_ID$i = 'dropdowns.add_item';
-const StyledAddItem = styled__default.default(StyledItem).attrs({
+const COMPONENT_ID$i = 'dropdowns.combobox.optgroup';
+const StyledOptGroup = styled__default.default.ul.attrs({
   'data-garden-id': COMPONENT_ID$i,
-  'data-garden-version': '9.0.0-next.1'
+  'data-garden-version': '9.0.0-next.11'
 }).withConfig({
-  displayName: "StyledAddItem",
-  componentId: "sc-ekqk50-0"
-})(["color:", ";", ";"], props => !props.disabled && reactTheming.getColor('primaryHue', 600, props.theme), props => reactTheming.retrieveComponentStyles(COMPONENT_ID$i, props));
-StyledAddItem.defaultProps = {
+  displayName: "StyledOptGroup",
+  componentId: "sc-1kavqsx-0"
+})(["margin:0;padding:0;list-style-type:none;", ";"], props => reactTheming.retrieveComponentStyles(COMPONENT_ID$i, props));
+StyledOptGroup.defaultProps = {
   theme: reactTheming.DEFAULT_THEME
 };
 
-const COMPONENT_ID$h = 'dropdowns.item_meta';
-const StyledItemMeta = styled__default.default.span.attrs({
+const COMPONENT_ID$h = 'dropdowns.combobox.separator';
+const colorStyles$4 = props => {
+  const backgroundColor = reactTheming.getColorV8('neutralHue', 200, props.theme);
+  return styled.css(["background-color:", ";"], backgroundColor);
+};
+const sizeStyles$4 = props => {
+  const margin = `${props.theme.space.base}px`;
+  const height = props.theme.borderWidths.sm;
+  return styled.css(["margin:", " 0;height:", ";"], margin, height);
+};
+const StyledListboxSeparator = styled__default.default.li.attrs({
   'data-garden-id': COMPONENT_ID$h,
-  'data-garden-version': '9.0.0-next.1'
+  'data-garden-version': '9.0.0-next.11'
 }).withConfig({
-  displayName: "StyledItemMeta",
-  componentId: "sc-k6xy28-0"
-})(["display:block;line-height:", "px;color:", ";font-size:", ";", ";"], props => props.theme.space.base * (props.isCompact ? 3 : 4), props => reactTheming.getColor('neutralHue', props.isDisabled ? 400 : 600, props.theme), props => props.theme.fontSizes.sm, props => reactTheming.retrieveComponentStyles(COMPONENT_ID$h, props));
-StyledItemMeta.defaultProps = {
+  displayName: "StyledListboxSeparator",
+  componentId: "sc-1p6toh2-0"
+})(["cursor:default;", ";", ";", ";"], sizeStyles$4, colorStyles$4, props => reactTheming.retrieveComponentStyles(COMPONENT_ID$h, props));
+StyledListboxSeparator.defaultProps = {
   theme: reactTheming.DEFAULT_THEME
 };
 
-const COMPONENT_ID$g = 'dropdowns.item_icon';
-const getSizeStyles = props => {
-  return styled.css(["width:", ";height:calc(", "px + ", ");"], props.theme.iconSizes.md, props.theme.space.base * 5, polished.math(`${getItemPaddingVertical(props)} * 2`));
+const COMPONENT_ID$g = 'dropdowns.combobox.listbox';
+const sizeStyles$3 = props => {
+  const padding = props.theme.space.base;
+  const minHeight = props.minHeight === undefined ? `${getMinHeight(props) + padding * 2}px` : props.minHeight;
+  return styled.css(["min-height:", ";max-height:", ";&&&{padding-top:", "px;padding-bottom:", "px;}"], minHeight, props.maxHeight, padding, padding);
 };
-const StyledItemIcon = styled__default.default.div.attrs({
+const StyledListbox = styled__default.default.ul.attrs({
   'data-garden-id': COMPONENT_ID$g,
-  'data-garden-version': '9.0.0-next.1'
+  'data-garden-version': '9.0.0-next.11'
 }).withConfig({
-  displayName: "StyledItemIcon",
-  componentId: "sc-1v0ty11-0"
-})(["display:flex;position:absolute;top:0;", ":", "px;align-items:center;justify-content:center;transition:opacity 0.1s ease-in-out;opacity:", ";color:", ";", ";& > *{width:", ";height:", ";}"], props => props.theme.rtl ? 'right' : 'left', props => props.theme.space.base * 3, props => props.isVisible ? '1' : '0', props => props.isDisabled ? 'inherit' : reactTheming.getColor('primaryHue', 600, props.theme), props => getSizeStyles(props), props => props.theme.iconSizes.md, props => props.theme.iconSizes.md);
-StyledItemIcon.defaultProps = {
+  displayName: "StyledListbox",
+  componentId: "sc-1k13ba7-0"
+})(["overflow-y:auto;list-style-type:none;", ";&&&{display:block;}", ":first-child ", " ", ":first-child ", "[role='none']:first-child{display:none;}"], sizeStyles$3, StyledOption, StyledOptionContent, StyledOptGroup, StyledListboxSeparator);
+StyledListbox.defaultProps = {
   theme: reactTheming.DEFAULT_THEME
 };
 
-const COMPONENT_ID$f = 'dropdowns.next_item';
-const StyledNextItem = styled__default.default(StyledItem).attrs({
+const COMPONENT_ID$f = 'dropdowns.combobox.option.icon';
+const sizeStyles$2 = props => {
+  const size = props.theme.iconSizes.md;
+  const marginTop = polished.math(`(${props.theme.lineHeights.md} - ${size}) / 2`);
+  const marginHorizontal = `${props.theme.space.base * 2}px`;
+  return styled.css(["margin-top:", ";margin-", ":", ";width:", ";height:", ";"], marginTop, props.theme.rtl ? 'left' : 'right', marginHorizontal, size, size);
+};
+const StyledOptionIcon = styled__default.default(reactTheming.StyledBaseIcon).attrs({
   'data-garden-id': COMPONENT_ID$f,
-  'data-garden-version': '9.0.0-next.1'
+  'data-garden-version': '9.0.0-next.11'
 }).withConfig({
-  displayName: "StyledNextItem",
-  componentId: "sc-1bcygn5-0"
-})(["", "{right:", ";left:", ";}", ";"], StyledItemIcon, props => props.theme.rtl ? 'auto' : `${props.theme.space.base * 3}px`, props => props.theme.rtl ? `${props.theme.space.base * 3}px` : 'auto', props => reactTheming.retrieveComponentStyles(COMPONENT_ID$f, props));
-StyledNextItem.defaultProps = {
+  displayName: "StyledOptionIcon",
+  componentId: "sc-qsab3y-0"
+})(["flex-shrink:0;", ";", ";"], sizeStyles$2, props => reactTheming.retrieveComponentStyles(COMPONENT_ID$f, props));
+StyledOptionIcon.defaultProps = {
   theme: reactTheming.DEFAULT_THEME
 };
 
-var _path$4;
-function _extends$4() { _extends$4 = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends$4.apply(this, arguments); }
-var SvgChevronRightStroke = function SvgChevronRightStroke(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$4({
-    xmlns: "http://www.w3.org/2000/svg",
-    width: 16,
-    height: 16,
-    focusable: "false",
-    viewBox: "0 0 16 16",
-    "aria-hidden": "true"
-  }, props), _path$4 || (_path$4 = /*#__PURE__*/React__namespace.createElement("path", {
-    fill: "currentColor",
-    d: "M5.61 3.312a.5.5 0 01.718-.69l.062.066 4 5a.5.5 0 01.054.542l-.054.082-4 5a.5.5 0 01-.83-.55l.05-.074L9.359 8l-3.75-4.688z"
-  })));
+const COMPONENT_ID$e = 'dropdowns.combobox.option.meta';
+const colorStyles$3 = props => {
+  const color = reactTheming.getColorV8('neutralHue', props.isDisabled ? 400 : 600, props.theme);
+  return styled.css(["color:", ";"], color);
 };
-
-const COMPONENT_ID$e = 'dropdowns.next_item_icon';
-const NextIconComponent = _ref => {
-  let {
-    className
-  } = _ref;
-  return React__namespace.default.createElement(SvgChevronRightStroke, {
-    "data-garden-id": COMPONENT_ID$e,
-    "data-garden-version": '9.0.0-next.1',
-    className: className
-  });
+const sizeStyles$1 = props => {
+  const lineHeight = props.theme.lineHeights.sm;
+  const fontSize = props.theme.fontSizes.sm;
+  return styled.css(["line-height:", ";font-size:", ";"], lineHeight, fontSize);
 };
-const StyledNextIcon = styled__default.default(NextIconComponent).withConfig({
-  displayName: "StyledNextIcon",
-  componentId: "sc-1rinki2-0"
-})(["transform:", ";color:", ";", ";"], props => props.theme.rtl && 'rotate(180deg)', props => props.isDisabled ? 'inherit' : reactTheming.getColor('neutralHue', 600, props.theme), props => reactTheming.retrieveComponentStyles(COMPONENT_ID$e, props));
-StyledNextIcon.defaultProps = {
+const StyledOptionMeta = styled__default.default.div.attrs({
+  'data-garden-id': COMPONENT_ID$e,
+  'data-garden-version': '9.0.0-next.11'
+}).withConfig({
+  displayName: "StyledOptionMeta",
+  componentId: "sc-j6pu10-0"
+})(["transition:color 0.25s ease-in-out;font-weight:", ";", ";", ";", ";"], props => props.theme.fontWeights.regular, sizeStyles$1, colorStyles$3, props => reactTheming.retrieveComponentStyles(COMPONENT_ID$e, props));
+StyledOptionMeta.defaultProps = {
   theme: reactTheming.DEFAULT_THEME
 };
 
-const COMPONENT_ID$d = 'dropdowns.previous_item';
-const StyledPreviousItem = styled__default.default(StyledItem).attrs({
+const COMPONENT_ID$d = 'dropdowns.combobox.option.type_icon';
+const colorStyles$2 = props => {
+  const opacity = props.$type && props.$type !== 'danger' ? 1 : 0;
+  let color;
+  if (props.$type === 'add' || props.$type === 'danger') {
+    color = 'inherit';
+  } else if (props.$type === 'header' || props.$type === 'next' || props.$type === 'previous') {
+    color = reactTheming.getColorV8('neutralHue', 600, props.theme);
+  } else {
+    color = reactTheming.getColorV8('primaryHue', 600, props.theme);
+  }
+  return styled.css(["opacity:", ";color:", ";", "[aria-selected='true'] > &{opacity:1;}", "[aria-disabled='true'] > &{color:inherit;}"], opacity, color, StyledOption, StyledOption);
+};
+const sizeStyles = props => {
+  const size = props.theme.iconSizes.md;
+  const position = `${props.theme.space.base * 3}px`;
+  const top = polished.math(`(${getMinHeight(props)} - ${size}) / 2`);
+  let side;
+  if (props.$type === 'next') {
+    side = props.theme.rtl ? 'left' : 'right';
+  } else {
+    side = props.theme.rtl ? 'right' : 'left';
+  }
+  return styled.css(["top:", ";", ":", ";width:", ";height:", ";"], top, side, position, size, size);
+};
+const StyledOptionTypeIcon = styled__default.default(reactTheming.StyledBaseIcon).attrs({
   'data-garden-id': COMPONENT_ID$d,
-  'data-garden-version': '9.0.0-next.1'
+  'data-garden-version': '9.0.0-next.11'
 }).withConfig({
-  displayName: "StyledPreviousItem",
-  componentId: "sc-1nmdds9-0"
-})(["font-weight:", ";", ";"], props => props.theme.fontWeights.semibold, props => reactTheming.retrieveComponentStyles(COMPONENT_ID$d, props));
-StyledPreviousItem.defaultProps = {
+  displayName: "StyledOptionTypeIcon",
+  componentId: "sc-xpink2-0"
+})(["position:absolute;transform:", ";transition:opacity 0.1s ease-in-out;", ";", ";", ";"], props => props.theme.rtl && (props.$type === 'next' || props.$type === 'previous') && 'rotate(180deg)', sizeStyles, colorStyles$2, props => reactTheming.retrieveComponentStyles(COMPONENT_ID$d, props));
+StyledOptionTypeIcon.defaultProps = {
   theme: reactTheming.DEFAULT_THEME
 };
 
-var _path$3;
-function _extends$3() { _extends$3 = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends$3.apply(this, arguments); }
-var SvgChevronLeftStroke = function SvgChevronLeftStroke(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$3({
-    xmlns: "http://www.w3.org/2000/svg",
-    width: 16,
-    height: 16,
-    focusable: "false",
-    viewBox: "0 0 16 16",
-    "aria-hidden": "true"
-  }, props), _path$3 || (_path$3 = /*#__PURE__*/React__namespace.createElement("path", {
-    fill: "currentColor",
-    d: "M10.39 12.688a.5.5 0 01-.718.69l-.062-.066-4-5a.5.5 0 01-.054-.542l.054-.082 4-5a.5.5 0 01.83.55l-.05.074L6.641 8l3.75 4.688z"
-  })));
-};
-
-const COMPONENT_ID$c = 'dropdowns.previous_item_icon';
-const PreviousIconComponent = _ref => {
-  let {
-    className
-  } = _ref;
-  return React__namespace.default.createElement(SvgChevronLeftStroke, {
-    "data-garden-id": COMPONENT_ID$c,
-    "data-garden-version": '9.0.0-next.1',
-    className: className
-  });
-};
-const StyledPreviousIcon = styled__default.default(PreviousIconComponent).withConfig({
-  displayName: "StyledPreviousIcon",
-  componentId: "sc-czfwj7-0"
-})(["transform:", ";color:", ";", ";"], props => props.theme.rtl && 'rotate(180deg)', props => props.isDisabled ? 'inherit' : reactTheming.getColor('neutralHue', 600, props.theme), props => reactTheming.retrieveComponentStyles(COMPONENT_ID$c, props));
-StyledPreviousIcon.defaultProps = {
+const COMPONENT_ID$c = 'dropdowns.combobox.tag';
+const StyledTag = styled__default.default(reactTags.Tag).attrs({
+  'data-garden-id': COMPONENT_ID$c,
+  'data-garden-version': '9.0.0-next.11'
+}).withConfig({
+  displayName: "StyledTag",
+  componentId: "sc-1alam0r-0"
+})(["&[aria-disabled='true']{color:", ";}&[hidden]{display:revert;", "}", ";"], props => props.hue ? undefined : reactTheming.getColorV8('neutralHue', 400, props.theme), polished.hideVisually(), props => reactTheming.retrieveComponentStyles(COMPONENT_ID$c, props));
+StyledTag.defaultProps = {
   theme: reactTheming.DEFAULT_THEME
 };
 
-const COMPONENT_ID$b = 'dropdowns.header_icon';
-const StyledHeaderIcon = styled__default.default.div.attrs({
+const COMPONENT_ID$b = 'dropdowns.combobox.value';
+const colorStyles$1 = props => {
+  const foregroundColor = props.isPlaceholder && reactTheming.getColorV8('neutralHue', 400, props.theme);
+  return styled.css(["color:", ";"], foregroundColor);
+};
+const StyledValue = styled__default.default.div.attrs({
   'data-garden-id': COMPONENT_ID$b,
-  'data-garden-version': '9.0.0-next.1'
+  'data-garden-version': '9.0.0-next.11'
 }).withConfig({
-  displayName: "StyledHeaderIcon",
-  componentId: "sc-1fl6nsz-0"
-})(["display:flex;position:absolute;top:0;bottom:0;align-items:center;justify-content:center;", ":", "px;color:", ";& > *{width:", ";height:", ";}", ";"], props => props.theme.rtl ? 'right' : 'left', props => props.theme.space.base * 3, props => reactTheming.getColor('neutralHue', 600, props.theme), props => props.theme.iconSizes.md, props => props.theme.iconSizes.md, props => reactTheming.retrieveComponentStyles(COMPONENT_ID$b, props));
-StyledHeaderIcon.defaultProps = {
+  displayName: "StyledValue",
+  componentId: "sc-t719sx-0"
+})(["flex-basis:0;flex-grow:1;cursor:", ";overflow:hidden;text-overflow:ellipsis;white-space:pre;user-select:none;", ";", ";&[hidden]{display:none;}", ";"], props => {
+  if (props.isDisabled) {
+    return 'default';
+  }
+  return props.isEditable && !props.isAutocomplete ? 'text' : 'pointer';
+}, sizeStyles$9, colorStyles$1, props => reactTheming.retrieveComponentStyles(COMPONENT_ID$b, props));
+StyledValue.defaultProps = {
   theme: reactTheming.DEFAULT_THEME
 };
 
-const COMPONENT_ID$a = 'dropdowns.header_item';
-const getHorizontalPadding = props => {
-  if (props.hasIcon) {
-    return undefined;
-  }
-  return `${props.theme.space.base * 3}px`;
+const COMPONENT_ID$a = 'dropdowns.combobox.tags_button';
+const colorStyles = props => {
+  const color = reactTheming.getColorV8('primaryHue', 600, props.theme);
+  return styled.css(["color:", ";&:disabled{color:inherit;}"], color);
 };
-const StyledHeaderItem = styled__default.default(StyledItem).attrs({
+const StyledTagsButton = styled__default.default(StyledValue).attrs({
+  as: 'button',
   'data-garden-id': COMPONENT_ID$a,
-  'data-garden-version': '9.0.0-next.1'
+  'data-garden-version': '9.0.0-next.11'
 }).withConfig({
-  displayName: "StyledHeaderItem",
-  componentId: "sc-137filx-0"
-})(["cursor:default;padding-right:", ";padding-left:", ";font-weight:", ";", ";"], props => getHorizontalPadding(props), props => getHorizontalPadding(props), props => props.theme.fontWeights.semibold, props => reactTheming.retrieveComponentStyles(COMPONENT_ID$a, props));
-StyledHeaderItem.defaultProps = {
+  displayName: "StyledTagsButton",
+  componentId: "sc-6q5w33-0"
+})(["display:inline-flex;flex:0 1 auto;align-items:center;border:none;background-color:transparent;cursor:pointer;min-width:auto;font-family:inherit;&:hover{text-decoration:underline;}", ";&:disabled{cursor:default;text-decoration:none;}", ";"], colorStyles, props => reactTheming.retrieveComponentStyles(COMPONENT_ID$a, props));
+StyledTagsButton.defaultProps = {
   theme: reactTheming.DEFAULT_THEME
 };
 
-const COMPONENT_ID$9 = 'dropdowns.media_body';
-const StyledMediaBody = styled__default.default.div.attrs({
+const COMPONENT_ID$9 = 'dropdowns.menu';
+const StyledMenu = styled__default.default(StyledListbox).attrs({
   'data-garden-id': COMPONENT_ID$9,
-  'data-garden-version': '9.0.0-next.1'
+  'data-garden-version': '9.0.0-next.11'
 }).withConfig({
-  displayName: "StyledMediaBody",
-  componentId: "sc-36j7ef-0"
-})(["display:block;overflow:hidden;padding-", ":", "px;", ";"], props => props.theme.rtl ? 'right' : 'left', props => props.theme.space.base * 2, props => reactTheming.retrieveComponentStyles(COMPONENT_ID$9, props));
-StyledMediaBody.defaultProps = {
+  displayName: "StyledMenu",
+  componentId: "sc-f77ntu-0"
+})(["position:static !important;", ";", ";"], props => props.arrowPosition && reactTheming.arrowStyles(props.arrowPosition, {
+  size: `${props.theme.space.base * 2}px`,
+  inset: '2px',
+  animationModifier: '[data-garden-animate-arrow="true"]'
+}), props => reactTheming.retrieveComponentStyles(COMPONENT_ID$9, props));
+StyledMenu.defaultProps = {
   theme: reactTheming.DEFAULT_THEME
 };
 
-const COMPONENT_ID$8 = 'dropdowns.media_figure';
-const StyledMediaFigure = styled__default.default(
-_ref => {
-  let {
-    children,
-    isCompact,
-    theme,
-    ...props
-  } = _ref;
-  return (
-    React__namespace.default.cloneElement(React.Children.only(children), props)
-  );
-}).attrs({
+const COMPONENT_ID$8 = 'dropdowns.menu.floating';
+const StyledFloatingMenu = styled__default.default(StyledFloatingListbox).attrs({
   'data-garden-id': COMPONENT_ID$8,
-  'data-garden-version': '9.0.0-next.1'
+  'data-garden-version': '9.0.0-next.11'
 }).withConfig({
-  displayName: "StyledMediaFigure",
-  componentId: "sc-2f2x8x-0"
-})(["float:", ";margin-top:", "px !important;width:", ";height:", ";", ";"], props => props.theme.rtl ? 'right' : 'left', props => props.theme.space.base * 0.5, props => props.theme.iconSizes.md, props => props.theme.iconSizes.md, props => reactTheming.retrieveComponentStyles(COMPONENT_ID$8, props));
-StyledMediaFigure.defaultProps = {
+  displayName: "StyledFloatingMenu",
+  componentId: "sc-1rc7ahb-0"
+})(["", ";"], props => reactTheming.retrieveComponentStyles(COMPONENT_ID$8, props));
+StyledFloatingMenu.defaultProps = {
   theme: reactTheming.DEFAULT_THEME
 };
 
-const COMPONENT_ID$7 = 'dropdowns.media_item';
-const StyledMediaItem = styled__default.default(StyledItem).attrs({
+const COMPONENT_ID$7 = 'dropdowns.menu.item';
+const StyledItem = styled__default.default(StyledOption).attrs({
   'data-garden-id': COMPONENT_ID$7,
-  'data-garden-version': '9.0.0-next.1'
+  'data-garden-version': '9.0.0-next.11'
 }).withConfig({
-  displayName: "StyledMediaItem",
-  componentId: "sc-ikwshz-0"
+  displayName: "StyledItem",
+  componentId: "sc-1jp99dq-0"
 })(["", ";"], props => reactTheming.retrieveComponentStyles(COMPONENT_ID$7, props));
-StyledMediaItem.defaultProps = {
+StyledItem.defaultProps = {
   theme: reactTheming.DEFAULT_THEME
 };
 
-const COMPONENT_ID$6 = 'dropdowns.faux_input';
-const StyledFauxInput = styled__default.default(reactForms.FauxInput).attrs(props => ({
+const COMPONENT_ID$6 = 'dropdowns.menu.item.content';
+const StyledItemContent = styled__default.default(StyledOptionContent).attrs({
   'data-garden-id': COMPONENT_ID$6,
-  'data-garden-version': '9.0.0-next.1',
-  mediaLayout: true,
-  theme: props.theme
-})).withConfig({
-  displayName: "StyledFauxInput",
-  componentId: "sc-1l592ed-0"
-})(["cursor:", ";min-width:", "px;", ";"], props => !props.disabled && 'pointer', props => props.theme.space.base * (props.isCompact ? 25 : 36), props => reactTheming.retrieveComponentStyles(COMPONENT_ID$6, props));
-StyledFauxInput.defaultProps = {
+  'data-garden-version': '9.0.0-next.11'
+}).withConfig({
+  displayName: "StyledItemContent",
+  componentId: "sc-1opglsb-0"
+})(["", ";"], props => reactTheming.retrieveComponentStyles(COMPONENT_ID$6, props));
+StyledItemContent.defaultProps = {
   theme: reactTheming.DEFAULT_THEME
 };
 
-const COMPONENT_ID$5 = 'dropdowns.input';
-const hiddenStyling = styled.css(["position:fixed;border:0;clip:rect(1px,1px,1px,1px);padding:0;width:1px;height:1px;overflow:hidden;white-space:nowrap;"]);
-const StyledInput = styled__default.default(reactForms.Input).attrs({
+const COMPONENT_ID$5 = 'dropdowns.menu.item_group';
+const StyledItemGroup = styled__default.default(StyledOptGroup).attrs({
   'data-garden-id': COMPONENT_ID$5,
-  'data-garden-version': '9.0.0-next.1',
-  isBare: true
+  'data-garden-version': '9.0.0-next.11'
 }).withConfig({
-  displayName: "StyledInput",
-  componentId: "sc-hzhvmp-0"
-})(["", ";", ";"], props => props.isHidden && hiddenStyling, props => reactTheming.retrieveComponentStyles(COMPONENT_ID$5, props));
-StyledInput.defaultProps = {
+  displayName: "StyledItemGroup",
+  componentId: "sc-1umk3cg-0"
+})(["", ";"], props => reactTheming.retrieveComponentStyles(COMPONENT_ID$5, props));
+StyledItemGroup.defaultProps = {
   theme: reactTheming.DEFAULT_THEME
 };
 
-const COMPONENT_ID$4 = 'dropdowns.select';
-const StyledSelect = styled__default.default.div.attrs({
+const COMPONENT_ID$4 = 'dropdowns.menu.item.icon';
+const StyledItemIcon = styled__default.default(StyledOptionIcon).attrs({
   'data-garden-id': COMPONENT_ID$4,
-  'data-garden-version': '9.0.0-next.1'
+  'data-garden-version': '9.0.0-next.11'
 }).withConfig({
-  displayName: "StyledSelect",
-  componentId: "sc-xifmwj-0"
-})(["flex-grow:1;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;", ";"], props => reactTheming.retrieveComponentStyles(COMPONENT_ID$4, props));
-StyledSelect.defaultProps = {
+  displayName: "StyledItemIcon",
+  componentId: "sc-w9orqb-0"
+})(["", ";"], props => reactTheming.retrieveComponentStyles(COMPONENT_ID$4, props));
+StyledItemIcon.defaultProps = {
   theme: reactTheming.DEFAULT_THEME
 };
 
-const COMPONENT_ID$3 = 'dropdowns.multiselect_input';
-const visibleStyling = props => {
-  const margin = props.isVisible ? `${props.theme.space.base / 2}px` : 0;
-  const minWidth = props.isVisible ? `${props.theme.space.base * 15}px` : 0;
-  let height = '0';
-  if (props.isVisible) {
-    height = `${props.theme.space.base * (props.isCompact ? 5 : 8)}px`;
-  }
-  return styled.css(["opacity:", ";margin:", ";width:", ";min-width:", ";height:", ";"], !props.isVisible && 0, margin, !props.isVisible && 0, minWidth, height);
-};
-const StyledMultiselectInput = styled__default.default(StyledInput).attrs({
+const COMPONENT_ID$3 = 'dropdowns.menu.item.meta';
+const StyledItemMeta = styled__default.default(StyledOptionMeta).attrs({
   'data-garden-id': COMPONENT_ID$3,
-  'data-garden-version': '9.0.0-next.1',
-  isBare: true
+  'data-garden-version': '9.0.0-next.11'
 }).withConfig({
-  displayName: "StyledMultiselectInput",
-  componentId: "sc-1avnf6f-0"
-})(["flex-basis:", "px;flex-grow:1;align-self:center;min-height:0;", ";", ";"], props => props.theme.space.base * 15, props => visibleStyling(props), props => reactTheming.retrieveComponentStyles(COMPONENT_ID$3, props));
-StyledMultiselectInput.defaultProps = {
+  displayName: "StyledItemMeta",
+  componentId: "sc-1unw3x1-0"
+})(["", ";"], props => reactTheming.retrieveComponentStyles(COMPONENT_ID$3, props));
+StyledItemMeta.defaultProps = {
   theme: reactTheming.DEFAULT_THEME
 };
 
-const COMPONENT_ID$2 = 'dropdowns.multiselect_items_container';
-const sizeStyles = props => {
-  let margin;
-  let padding;
-  if (!props.isBare) {
-    const marginVertical = props.isCompact ? `-${props.theme.space.base * 1.5}px` : `-${props.theme.space.base * 2.5}px`;
-    margin = `${marginVertical} 0`;
-    const paddingVertical = props.isCompact ? '3px' : '1px';
-    const paddingEnd = `${props.theme.space.base}px`;
-    padding = `${paddingVertical} ${props.theme.rtl ? 0 : paddingEnd} ${paddingVertical} ${props.theme.rtl ? paddingEnd : 0}`;
-  }
-  return styled.css(["margin:", ";padding:", ";"], margin, padding);
-};
-const StyledMultiselectItemsContainer = styled__default.default.div.attrs({
+const COMPONENT_ID$2 = 'dropdowns.menu.item.type_icon';
+const StyledItemTypeIcon = styled__default.default(StyledOptionTypeIcon).attrs({
   'data-garden-id': COMPONENT_ID$2,
-  'data-garden-version': '9.0.0-next.1'
+  'data-garden-version': '9.0.0-next.11'
 }).withConfig({
-  displayName: "StyledMultiselectItemsContainer",
-  componentId: "sc-1jzhet8-0"
-})(["display:inline-flex;flex-grow:1;flex-wrap:wrap;min-width:0;", ";", ";"], props => sizeStyles(props), props => reactTheming.retrieveComponentStyles(COMPONENT_ID$2, props));
-StyledMultiselectItemsContainer.defaultProps = {
+  displayName: "StyledItemTypeIcon",
+  componentId: "sc-1pll3nu-0"
+})(["", "[aria-checked='true'] > &{opacity:1;}", ";"], StyledItem, props => reactTheming.retrieveComponentStyles(COMPONENT_ID$2, props));
+StyledItemTypeIcon.defaultProps = {
   theme: reactTheming.DEFAULT_THEME
 };
 
-const COMPONENT_ID$1 = 'dropdowns.multiselect_item_wrapper';
-const StyledMultiselectItemWrapper = styled__default.default.div.attrs({
+const COMPONENT_ID$1 = 'dropdowns.menu.button';
+const StyledButton = styled__default.default(reactButtons.Button).attrs({
   'data-garden-id': COMPONENT_ID$1,
-  'data-garden-version': '9.0.0-next.1'
+  'data-garden-version': '9.0.0-next.11'
 }).withConfig({
-  displayName: "StyledMultiselectItemWrapper",
-  componentId: "sc-1rb2bye-0"
-})(["display:inline-flex;align-items:center;margin:", "px;max-width:100%;", ";"], props => props.theme.space.base / 2, props => reactTheming.retrieveComponentStyles(COMPONENT_ID$1, props));
-StyledMultiselectItemWrapper.defaultProps = {
+  displayName: "StyledButton",
+  componentId: "sc-5hs2jg-0"
+})(["", ";"], props => reactTheming.retrieveComponentStyles(COMPONENT_ID$1, props));
+StyledButton.defaultProps = {
   theme: reactTheming.DEFAULT_THEME
 };
 
-const COMPONENT_ID = 'dropdowns.multiselect_more_anchor';
-const StyledMultiselectMoreAnchor = styled__default.default.div.attrs({
+const COMPONENT_ID = 'dropdowns.menu.separator';
+const StyledSeparator = styled__default.default(StyledListboxSeparator).attrs({
   'data-garden-id': COMPONENT_ID,
-  'data-garden-version': '9.0.0-next.1'
+  'data-garden-version': '9.0.0-next.11'
 }).withConfig({
-  displayName: "StyledMultiselectMoreAnchor",
-  componentId: "sc-1m9v46e-0"
-})(["display:inline-block;cursor:", ";padding:", "px 0;overflow:hidden;user-select:none;text-overflow:ellipsis;line-height:", ";white-space:nowrap;color:", ";:hover{text-decoration:", ";}", ";"], props => props.isDisabled ? 'default' : 'pointer', props => props.theme.space.base * (props.isCompact ? 0.75 : 1.5), props => props.isCompact ? '1em' : reactTheming.getLineHeight(props.theme.space.base * 5, props.theme.fontSizes.md), props => props.isDisabled ? reactTheming.getColor('neutralHue', 400, props.theme) : reactTheming.getColor('primaryHue', 600, props.theme), props => !props.isDisabled && 'underline', props => reactTheming.retrieveComponentStyles(COMPONENT_ID, props));
-StyledMultiselectMoreAnchor.defaultProps = {
+  displayName: "StyledSeparator",
+  componentId: "sc-8kqwen-0"
+})(["", ";"], props => reactTheming.retrieveComponentStyles(COMPONENT_ID, props));
+StyledSeparator.defaultProps = {
   theme: reactTheming.DEFAULT_THEME
 };
 
-const Trigger = _ref => {
+const Listbox = React.forwardRef((_ref, ref) => {
   let {
+    appendToNode,
     children,
-    refKey,
-    ...triggerProps
+    isCompact,
+    isExpanded,
+    maxHeight,
+    minHeight,
+    onMouseDown,
+    triggerRef,
+    zIndex,
+    ...props
   } = _ref;
+  const floatingRef = React.useRef(null);
+  const [isVisible, setIsVisible] = React.useState(false);
+  const [height, setHeight] = React.useState();
+  const [width, setWidth] = React.useState();
+  const theme = React.useContext(styled.ThemeContext) || reactTheming.DEFAULT_THEME;
   const {
-    hasMenuRef,
-    itemSearchRegistry,
-    downshift: {
-      getRootProps,
-      getToggleButtonProps,
-      getInputProps,
-      isOpen,
-      highlightedIndex,
-      selectItemAtIndex,
-      setHighlightedIndex
+    refs,
+    placement,
+    update,
+    floatingStyles: {
+      transform
     }
-  } = useDropdownContext();
-  const hiddenInputRef = React.useRef(null);
-  const triggerRef = React.useRef(null);
-  const previousIsOpenRef = React.useRef(undefined);
-  const [searchString, setSearchString] = React.useState('');
-  const searchTimeoutRef = React.useRef();
-  const currentSearchIndexRef = React.useRef(0);
+  } = reactDom.useFloating({
+    elements: {
+      reference: triggerRef?.current,
+      floating: floatingRef?.current
+    },
+    placement: 'bottom-start',
+    middleware: [reactDom.offset(theme.space.base), reactDom.flip(), reactDom.size({
+      apply: _ref2 => {
+        let {
+          rects,
+          availableHeight
+        } = _ref2;
+        if (rects.reference.width > 0) {
+          setWidth(rects.reference.width);
+          if (!(minHeight === null || minHeight === 'fit-content') && rects.floating.height > availableHeight) {
+            setHeight(availableHeight);
+          }
+        }
+      }
+    })]
+  });
+  const handleMouseDown = event => event.preventDefault();
   React.useEffect(() => {
-    if (hiddenInputRef.current && isOpen && !previousIsOpenRef.current) {
-      hiddenInputRef.current.focus();
-    }
-    if (triggerRef.current && !isOpen && previousIsOpenRef.current) {
-      triggerRef.current.focus();
+    let cleanup;
+    if (isExpanded && refs.reference.current && refs.floating.current) {
+      cleanup = reactDom.autoUpdate(refs.reference.current, refs.floating.current, update, {
+        elementResize: typeof ResizeObserver === 'function'
+      });
     }
-    previousIsOpenRef.current = isOpen;
-  }, [isOpen, hasMenuRef]);
+    return () => cleanup && cleanup();
+  }, [isExpanded, refs.reference, refs.floating, update]);
   React.useEffect(() => {
-    if (hasMenuRef.current === false) {
-      hasMenuRef.current = true;
+    let timeout;
+    if (isExpanded) {
+      setIsVisible(true);
+    } else {
+      timeout = setTimeout(() => {
+        setIsVisible(false);
+        setHeight(undefined);
+      }, 200 );
     }
-  }, [hasMenuRef]);
+    return () => clearTimeout(timeout);
+  }, [isExpanded]);
   React.useEffect(() => {
-    if (searchTimeoutRef.current) {
-      clearTimeout(searchTimeoutRef.current);
-    }
-    searchTimeoutRef.current = window.setTimeout(() => {
-      setSearchString('');
-    }, 500);
-    return () => {
-      clearTimeout(searchTimeoutRef.current);
-    };
-  }, [searchString]);
-  const searchItems = React.useCallback((searchValue, startIndex, endIndex) => {
-    for (let index = startIndex; index < endIndex; index++) {
-      const itemTextValue = itemSearchRegistry.current[index];
-      if (itemTextValue && itemTextValue.toUpperCase().indexOf(searchValue.toUpperCase()) === 0) {
-        return index;
-      }
-    }
-    return undefined;
-  }, [itemSearchRegistry]);
-  const onInputKeyDown = React.useCallback(e => {
-    if (e.keyCode === containerUtilities.KEY_CODES.SPACE) {
-      if (searchString) {
-        e.preventDefault();
-        e.stopPropagation();
-      } else if (highlightedIndex !== null && highlightedIndex !== undefined) {
-        e.preventDefault();
-        e.stopPropagation();
-        selectItemAtIndex(highlightedIndex);
-      }
-    }
-    if ((e.keyCode < 48 || e.keyCode > 57) && (e.keyCode < 65 || e.keyCode > 90) && e.keyCode !== containerUtilities.KEY_CODES.SPACE) {
-      return;
+    if (height) {
+      setHeight(undefined);
+      update();
     }
-    const character = String.fromCharCode(e.which || e.keyCode);
-    if (!character || character.length === 0) {
-      return;
-    }
-    if (!searchString) {
-      if (highlightedIndex === null || highlightedIndex === undefined) {
-        currentSearchIndexRef.current = -1;
-      } else {
-        currentSearchIndexRef.current = highlightedIndex;
-      }
+  }, [
+  children, update]);
+  const Node = React__namespace.default.createElement(StyledFloatingListbox, {
+    "data-garden-animate": isVisible ? 'true' : 'false',
+    isHidden: !isExpanded,
+    position: placement === 'bottom-start' ? 'bottom' : 'top',
+    style: {
+      transform,
+      width
+    },
+    zIndex: zIndex,
+    ref: floatingRef
+  }, React__namespace.default.createElement(StyledListbox, Object.assign({
+    isCompact: isCompact,
+    maxHeight: maxHeight,
+    minHeight: minHeight,
+    onMouseDown: containerUtilities.composeEventHandlers(onMouseDown, handleMouseDown),
+    style: {
+      height
     }
-    const newSearchString = searchString + character;
-    setSearchString(newSearchString);
-    let matchingIndex = searchItems(newSearchString, currentSearchIndexRef.current + 1, itemSearchRegistry.current.length);
-    if (matchingIndex === undefined) {
-      matchingIndex = searchItems(newSearchString, 0, currentSearchIndexRef.current);
-    }
-    if (matchingIndex !== undefined) {
-      setHighlightedIndex(matchingIndex);
-    }
-  }, [searchString, searchItems, itemSearchRegistry, highlightedIndex, selectItemAtIndex, setHighlightedIndex]);
-  const renderChildren = popperRef => {
-    const {
-      ref: rootPropsRefCallback,
-      ...rootProps
-    } = getRootProps();
-    const listboxToggleProps = getToggleButtonProps({
-      ...rootProps,
-      role: null,
-      'aria-labelledby': undefined,
-      ...triggerProps,
-      ...children.props
-    });
-    const menuToggleProps = {
-      ...listboxToggleProps,
-      'aria-haspopup': 'true',
-      'aria-controls': listboxToggleProps['aria-owns'],
-      'aria-owns': null
-    };
-    const toggleButtonProps = hasMenuRef.current ? menuToggleProps : listboxToggleProps;
-    return React__namespace.default.cloneElement(React__namespace.default.Children.only(children), {
-      ...toggleButtonProps,
-      [refKey]: childRef => {
-        popperRef(childRef);
-        triggerRef.current = childRef;
-        rootPropsRefCallback(childRef);
-      }
-    });
-  };
-  return React__namespace.default.createElement(reactPopper.Reference, null, _ref2 => {
-    let {
-      ref: popperReference
-    } = _ref2;
-    return React__namespace.default.createElement(React__namespace.default.Fragment, null, renderChildren(popperReference), React__namespace.default.createElement(StyledInput, getInputProps({
-      readOnly: true,
-      isHidden: true,
-      tabIndex: -1,
-      ref: hiddenInputRef,
-      value: '',
-      onClick: e => {
-        if (isOpen) {
-          e.nativeEvent.preventDownshiftDefault = true;
-        }
-      },
-      onKeyDown: onInputKeyDown
-    })));
-  });
-};
-Trigger.propTypes = {
-  children: PropTypes__default.default.any,
-  refKey: PropTypes__default.default.string
-};
-Trigger.defaultProps = {
-  refKey: 'ref'
-};
-
-var _path$2;
-function _extends$2() { _extends$2 = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends$2.apply(this, arguments); }
-var SvgChevronDownStroke = function SvgChevronDownStroke(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$2({
-    xmlns: "http://www.w3.org/2000/svg",
-    width: 16,
-    height: 16,
-    focusable: "false",
-    viewBox: "0 0 16 16",
-    "aria-hidden": "true"
-  }, props), _path$2 || (_path$2 = /*#__PURE__*/React__namespace.createElement("path", {
-    fill: "currentColor",
-    d: "M12.688 5.61a.5.5 0 01.69.718l-.066.062-5 4a.5.5 0 01-.542.054l-.082-.054-5-4a.5.5 0 01.55-.83l.074.05L8 9.359l4.688-3.75z"
-  })));
+  }, props, {
+    ref: ref
+  }), isVisible && children));
+  return appendToNode ? reactDom$1.createPortal(Node, appendToNode) : Node;
+});
+Listbox.displayName = 'Listbox';
+Listbox.propTypes = {
+  appendToNode: PropTypes__default.default.any,
+  isCompact: PropTypes__default.default.bool,
+  isExpanded: PropTypes__default.default.bool,
+  maxHeight: PropTypes__default.default.string,
+  triggerRef: PropTypes__default.default.any.isRequired,
+  zIndex: PropTypes__default.default.number
 };
 
-const FieldContext = React__namespace.default.createContext(undefined);
-const useFieldContext = () => {
-  const fieldContext = React.useContext(FieldContext);
-  if (!fieldContext) {
-    throw new Error('This component must be rendered within a `Field` component.');
-  }
-  return fieldContext;
-};
+const TagAvatarComponent = reactTags.Tag.Avatar;
+TagAvatarComponent.displayName = 'Tag.Avatar';
+const TagAvatar = TagAvatarComponent;
 
-const Autocomplete = React.forwardRef((_ref, ref) => {
+const TagComponent = React.forwardRef((_ref, ref) => {
   let {
     children,
-    inputRef: controlledInputRef,
-    start,
+    option,
+    removeLabel,
+    tooltipZIndex,
     ...props
   } = _ref;
   const {
-    popperReferenceElementRef,
-    downshift: {
-      getToggleButtonProps,
-      getInputProps,
-      getRootProps,
-      isOpen
-    },
-    setDropdownType
-  } = useDropdownContext();
-  const {
-    isLabelHovered
-  } = useFieldContext();
-  const inputRef = React.useRef();
-  const triggerRef = React.useRef();
-  const previousIsOpenRef = React.useRef(isOpen);
-  const [isHovered, setIsHovered] = React.useState(false);
-  const [isFocused, setIsFocused] = React.useState(false);
-  React.useEffect(() => {
-    if (inputRef.current && isOpen !== previousIsOpenRef.current) {
-      inputRef.current.focus();
-    }
-    previousIsOpenRef.current = isOpen;
-  }, [inputRef, isOpen]);
-  const {
-    type,
-    onKeyDown,
-    ...selectProps
-  } = getToggleButtonProps(getRootProps({
-    role: null,
-    ...props,
-    onKeyDown: e => {
-      if (isOpen) {
-        e.nativeEvent.preventDownshiftDefault = true;
-      }
-    },
-    onMouseEnter: containerUtilities.composeEventHandlers(props.onMouseEnter, () => setIsHovered(true)),
-    onMouseLeave: containerUtilities.composeEventHandlers(props.onMouseLeave, () => setIsHovered(false))
-  }));
-  const onSelectKeyDown = containerUtilities.composeEventHandlers(props.onKeyDown, onKeyDown);
-  const isContainerHovered = isLabelHovered && !isOpen;
-  const isContainerFocused = isOpen || isFocused;
-  React.useEffect(() => {
-    setDropdownType('autocomplete');
-  }, [setDropdownType]);
-  return React__namespace.default.createElement(reactPopper.Reference, null, _ref2 => {
-    let {
-      ref: popperReference
-    } = _ref2;
-    return React__namespace.default.createElement(StyledFauxInput, _extends$5({
-      isHovered: isContainerHovered,
-      isFocused: isContainerFocused,
-      tabIndex: null,
-      onKeyDown: onSelectKeyDown
-    }, selectProps, {
-      ref: selectRef => {
-        popperReference(selectRef);
-        reactMergeRefs.mergeRefs([triggerRef, ref])(selectRef);
-        popperReferenceElementRef.current = selectRef;
-      }
-    }), start && React__namespace.default.createElement(StyledFauxInput.StartIcon, {
-      isHovered: isHovered || isLabelHovered && !isOpen,
-      isFocused: isContainerFocused,
-      isDisabled: props.disabled
-    }, start), !isOpen && React__namespace.default.createElement(StyledSelect, null, children), React__namespace.default.createElement(StyledInput, getInputProps({
-      isHidden: !isOpen,
-      disabled: props.disabled,
-      onFocus: () => {
-        setIsFocused(true);
-      },
-      onBlur: () => {
-        setIsFocused(false);
-      },
-      onClick: e => {
-        if (isOpen) {
-          e.nativeEvent.preventDownshiftDefault = true;
-        }
-      },
-      role: 'combobox',
-      ref: reactMergeRefs.mergeRefs([inputRef, controlledInputRef || null])
-    })), !props.isBare && React__namespace.default.createElement(StyledFauxInput.EndIcon, {
-      isHovered: isHovered || isLabelHovered && !isOpen,
-      isFocused: isContainerFocused,
-      isDisabled: props.disabled,
-      isRotated: isOpen
-    }, React__namespace.default.createElement(SvgChevronDownStroke, null)));
+    getTagProps,
+    isCompact,
+    removeSelection
+  } = useComboboxContext();
+  const text = option.label || option.value;
+  const ariaLabel = reactTheming.useText(
+  Tag, props, 'aria-label', `${text}, press delete or backspace to remove`, !option.disabled);
+  const tagProps = getTagProps({
+    option,
+    'aria-label': ariaLabel
   });
+  const theme = React.useContext(styled.ThemeContext) || reactTheming.DEFAULT_THEME;
+  const doc = reactTheming.useDocument(theme);
+  const handleClick = () => removeSelection(option.value);
+  return React__namespace.default.createElement(StyledTag, Object.assign({
+    "aria-disabled": option.disabled,
+    tabIndex: option.disabled ? undefined : 0
+  }, tagProps, props, {
+    size: isCompact ? 'medium' : 'large',
+    ref: ref
+  }), children || React__namespace.default.createElement("span", null, text), !option.disabled && (removeLabel ?
+  React__namespace.default.createElement(reactTooltips.Tooltip, {
+    appendToNode: doc?.body,
+    content: removeLabel,
+    zIndex: tooltipZIndex
+  }, React__namespace.default.createElement(StyledTag.Close, {
+    "aria-label": removeLabel,
+    onClick: handleClick
+  })) : React__namespace.default.createElement(StyledTag.Close, {
+    onClick: handleClick
+  })));
 });
-Autocomplete.displayName = 'Autocomplete';
-Autocomplete.propTypes = {
-  isCompact: PropTypes__default.default.bool,
-  isBare: PropTypes__default.default.bool,
-  disabled: PropTypes__default.default.bool,
-  focusInset: PropTypes__default.default.bool,
-  validation: PropTypes__default.default.oneOf(reactForms.VALIDATION)
+TagComponent.displayName = 'Tag';
+TagComponent.propTypes = {
+  hue: PropTypes__default.default.string,
+  isPill: PropTypes__default.default.bool,
+  isRegular: PropTypes__default.default.bool,
+  removeLabel: PropTypes__default.default.string
 };
+const Tag = TagComponent;
+Tag.Avatar = TagAvatar;
 
+const TagGroup = _ref => {
+  let {
+    children,
+    isDisabled,
+    isExpanded,
+    listboxZIndex,
+    maxTags,
+    optionTagProps,
+    selection
+  } = _ref;
+  return React__namespace.default.createElement(React__namespace.default.Fragment, null, selection.map((option, index) => {
+    const disabled = isDisabled || option.disabled;
+    return React__namespace.default.createElement(Tag, Object.assign({
+      key: option.value,
+      hidden: !isExpanded && index >= maxTags,
+      option: {
+        ...option,
+        disabled
+      },
+      tooltipZIndex: listboxZIndex ? listboxZIndex + 1 : undefined
+    }, optionTagProps[option.value]));
+  }), children);
+};
+TagGroup.displayName = 'TagGroup';
+
+const toOption = props => {
+  return {
+    value: props.value,
+    label: props.label,
+    hidden: props.isHidden,
+    disabled: props.isDisabled,
+    selected: props.isSelected
+  };
+};
+const toOptions = (children, optionTagProps) => React.Children.toArray(children).reduce((options, option) => {
+  const retVal = options;
+  if ( React.isValidElement(option)) {
+    if ('value' in option.props) {
+      retVal.push(toOption(option.props));
+      optionTagProps[option.props.value] = option.props.tagProps;
+    } else {
+      const props = option.props;
+      const groupOptions = toOptions(props.children, optionTagProps);
+      retVal.push({
+        label: props.legend,
+        options: groupOptions
+      });
+    }
+  }
+  return retVal;
+}, []);
+
+const MAX_TAGS = 4;
 const Combobox = React.forwardRef((_ref, ref) => {
   let {
-    isCompact,
-    isBare,
-    disabled,
+    children,
+    activeIndex,
+    defaultActiveIndex,
+    defaultExpanded,
+    endIcon,
     focusInset,
+    inputProps: _inputProps,
+    inputValue: _inputValue,
+    isAutocomplete,
+    isBare,
+    isCompact,
+    isDisabled,
+    isEditable,
+    isExpanded: _isExpanded,
+    isMultiselectable,
+    listboxAppendToNode,
+    listboxAriaLabel,
+    listboxMaxHeight,
+    listboxMinHeight,
+    listboxZIndex,
+    maxHeight,
+    maxTags = MAX_TAGS,
+    onChange,
     placeholder,
+    renderExpandTags,
+    renderValue,
+    selectionValue,
+    startIcon,
     validation,
-    inputRef: inputRefProp = null,
-    start,
-    end,
     ...props
   } = _ref;
   const {
-    popperReferenceElementRef,
-    downshift: {
-      getToggleButtonProps,
-      getInputProps,
-      getRootProps,
-      isOpen
-    },
-    setDropdownType
-  } = useDropdownContext();
-  const wrapperRef = React.useRef();
-  const inputRef = React.useRef();
-  const isOpenRef = React.useRef(isOpen);
-  const wrapperProps = getToggleButtonProps(getRootProps({
-    role: null,
-    type: null,
-    onClick: event => {
-      event.nativeEvent.preventDownshiftDefault = true;
-    },
-    ...props,
-    onKeyDown: event => {
-      event.nativeEvent.preventDownshiftDefault = true;
+    hasHint,
+    hasMessage,
+    labelProps,
+    setLabelProps,
+    hintProps,
+    setHintProps,
+    messageProps,
+    setMessageProps
+  } = useFieldContext();
+  const [isInputHidden, setIsInputHidden] = React.useState(true);
+  const [isLabelHovered, setIsLabelHovered] = React.useState(false);
+  const [isTagGroupExpanded, setIsTagGroupExpanded] = React.useState(false);
+  const [optionTagProps, setOptionTagProps] = React.useState({});
+  const options = React.useMemo(() => {
+    const tagProps = {};
+    const retVal = toOptions(children, tagProps);
+    if (isMultiselectable) {
+      setOptionTagProps(value => ({
+        ...value,
+        ...tagProps
+      }));
     }
-  }));
-  const inputProps = getInputProps({
+    return retVal;
+  }, [children, isMultiselectable]);
+  const triggerRef = React.useRef(null);
+  const inputRef = React.useRef(null);
+  const listboxRef = React.useRef(null);
+  const theme = React.useContext(styled.ThemeContext) || reactTheming.DEFAULT_THEME;
+  const environment = reactTheming.useWindow(theme);
+  const {
+    activeValue,
+    inputValue,
+    isExpanded,
+    getTriggerProps,
+    getHintProps,
+    getInputProps,
+    getLabelProps,
+    getListboxProps,
+    getMessageProps,
+    getOptionProps,
+    getOptGroupProps,
+    getTagProps,
+    removeSelection,
+    selection
+  } = containerCombobox.useCombobox({
+    idPrefix: props.id,
+    triggerRef,
+    inputRef,
+    listboxRef,
+    options,
+    environment,
+    hasHint,
+    hasMessage,
+    isAutocomplete,
+    isEditable,
+    isMultiselectable,
+    disabled: isDisabled,
+    inputValue: _inputValue,
+    selectionValue,
+    isExpanded: _isExpanded,
+    defaultExpanded,
+    activeIndex,
+    defaultActiveIndex,
+    onChange
+  });
+  const contextValue = React.useMemo(() => ({
+    activeValue,
+    getOptionProps,
+    getOptGroupProps,
+    getTagProps,
     isCompact,
+    removeSelection
+  }), [activeValue, getOptionProps, getOptGroupProps, getTagProps, isCompact, removeSelection]);
+  const hasChevron = React.useMemo(() => !isBare && (isAutocomplete || !isEditable), [isAutocomplete, isBare, isEditable]);
+  const expandTags = reactTheming.useText(Combobox, {
+    renderExpandTags
+  }, 'renderExpandTags', '+ {{value}} more', isMultiselectable || false);
+  const _listboxAriaLabel = reactTheming.useText(Combobox, {
+    listboxAriaLabel
+  }, 'listboxAriaLabel', 'Options');
+  const triggerProps = {
+    isAutocomplete,
     isBare,
-    disabled,
+    isCompact,
+    isEditable,
+    isLabelHovered,
+    isMultiselectable,
+    maxHeight,
     focusInset,
-    placeholder,
     validation,
-    start,
-    end,
-    role: 'combobox',
-    onKeyDown: event => {
-      if (event.keyCode === containerUtilities.KEY_CODES.SPACE || !isOpen && [containerUtilities.KEY_CODES.DOWN, containerUtilities.KEY_CODES.UP].includes(event.keyCode)) {
-        event.nativeEvent.preventDownshiftDefault = true;
-      }
-    },
-    onClick: event => {
-      event.nativeEvent.preventDownshiftDefault = true;
-    }
-  });
-  React.useEffect(() => {
-    if (inputRef.current && isOpen !== isOpenRef.current) {
-      inputRef.current.focus();
-    }
-    isOpenRef.current = isOpen;
-  }, [inputRef, isOpen]);
-  React.useEffect(() => {
-    setDropdownType('combobox');
-  }, [setDropdownType]);
-  return React__namespace.default.createElement(reactPopper.Reference, null, _ref2 => {
-    let {
-      ref: popperReference
-    } = _ref2;
-    const wrapperRefProp = element => {
-      popperReference(element);
-      reactMergeRefs.mergeRefs([wrapperRef, ref])(element);
-      popperReferenceElementRef.current = element;
-    };
-    return React__namespace.default.createElement(reactForms.MediaInput, _extends$5({}, inputProps, {
-      wrapperProps: wrapperProps,
-      wrapperRef: wrapperRefProp,
-      ref: reactMergeRefs.mergeRefs([inputRef, inputRefProp])
-    }));
-  });
-});
-Combobox.displayName = 'Combobox';
-Combobox.propTypes = {
-  isCompact: PropTypes__default.default.bool,
-  isBare: PropTypes__default.default.bool,
-  disabled: PropTypes__default.default.bool,
-  focusInset: PropTypes__default.default.bool,
-  placeholder: PropTypes__default.default.string,
-  validation: PropTypes__default.default.oneOf(reactForms.VALIDATION)
-};
-
-const Multiselect = React__namespace.default.forwardRef((_ref, ref) => {
-  let {
-    renderItem,
-    placeholder,
-    maxItems,
-    renderShowMore,
-    inputRef: externalInputRef = null,
-    start,
-    onKeyDown,
-    ...props
-  } = _ref;
-  const {
-    popperReferenceElementRef,
-    selectedItems = [],
-    containsMultiselectRef,
-    previousIndexRef,
-    downshift: {
-      getToggleButtonProps,
-      getRootProps,
-      getInputProps,
-      isOpen,
-      closeMenu,
-      inputValue,
-      setState: setDownshiftState,
-      itemToString
-    },
-    setDropdownType
-  } = useDropdownContext();
-  const {
-    isLabelHovered
-  } = useFieldContext();
-  const inputRef = React.useRef();
-  const triggerRef = React.useRef();
-  const blurTimeoutRef = React.useRef();
-  const previousIsOpenRef = React.useRef(undefined);
-  const previousIsFocusedRef = React.useRef(undefined);
-  const [isHovered, setIsHovered] = React.useState(false);
-  const [isFocused, setIsFocused] = React.useState(false);
-  const [focusedItem, setFocusedItem] = React.useState(undefined);
-  const themeContext = React.useContext(styled.ThemeContext);
-  const environment = reactTheming.useDocument(themeContext);
-  const {
-    getContainerProps,
-    getItemProps
-  } = containerSelection.useSelection({
-    rtl: themeContext.rtl,
-    focusedItem,
-    selectedItem: undefined,
-    onFocus: item => {
-      setFocusedItem(item);
-    }
-  });
-  React.useEffect(() => {
-    containsMultiselectRef.current = true;
-    const tempRef = blurTimeoutRef;
-    return () => {
-      clearTimeout(tempRef.current);
-    };
-  }, []);
-  React.useEffect(() => {
-    if (inputRef.current) {
-      if (isOpen && !previousIsOpenRef.current) {
-        inputRef.current.focus();
-      } else if (isFocused && !previousIsFocusedRef.current && focusedItem === undefined) {
-        inputRef.current.focus();
-      }
-    }
-    previousIsOpenRef.current = isOpen;
-    previousIsFocusedRef.current = isFocused;
-  }, [isOpen, inputRef, isFocused, focusedItem]);
-  React.useEffect(() => {
-    if (focusedItem !== undefined && isOpen) {
-      closeMenu();
-    }
-  }, [focusedItem, isOpen, closeMenu]);
-  const {
-    type,
-    ...selectProps
-  } = getToggleButtonProps(getRootProps({
-    tabIndex: props.disabled ? undefined : -1,
-    onKeyDown: containerUtilities.composeEventHandlers(onKeyDown, e => {
-      if (isOpen) {
-        e.nativeEvent.preventDownshiftDefault = true;
-      } else if (!inputValue && e.keyCode === containerUtilities.KEY_CODES.HOME) {
-        setFocusedItem(selectedItems[0]);
-        e.preventDefault();
-      }
-    }),
-    onFocus: () => {
-      setIsFocused(true);
-    },
-    onBlur: e => {
-      const currentTarget = e.currentTarget;
-      blurTimeoutRef.current = setTimeout(() => {
-        if (environment && !currentTarget.contains(environment.activeElement)) {
-          setIsFocused(false);
-        }
-      }, 0);
-    },
-    onMouseEnter: containerUtilities.composeEventHandlers(props.onMouseEnter, () => setIsHovered(true)),
-    onMouseLeave: containerUtilities.composeEventHandlers(props.onMouseLeave, () => setIsHovered(false)),
-    role: null,
-    ...props
-  }));
-  const renderSelectableItem = React.useCallback((item, index) => {
-    const removeValue = () => {
-      setDownshiftState({
-        type: REMOVE_ITEM_STATE_TYPE,
-        selectedItem: item
-      });
-      inputRef.current && inputRef.current.focus();
-    };
-    const renderedItem = renderItem({
-      value: item,
-      removeValue
-    });
-    const focusRef = React__namespace.default.createRef();
-    const clonedChild = React__namespace.default.cloneElement(renderedItem, {
-      ...getItemProps({
-        item,
-        focusRef,
-        onKeyDown: e => {
-          if (e.keyCode === containerUtilities.KEY_CODES.DELETE || e.keyCode === containerUtilities.KEY_CODES.BACKSPACE) {
-            e.preventDefault();
-            removeValue();
-          }
-          if (e.keyCode === containerUtilities.KEY_CODES.END && !inputValue) {
-            inputRef.current && inputRef.current.focus();
-            e.preventDefault();
+    ...getTriggerProps({
+      onFocus: () => {
+        if (!isDisabled) {
+          if (isEditable) {
+            setIsInputHidden(false);
           }
-          if (themeContext.rtl) {
-            if (e.keyCode === containerUtilities.KEY_CODES.RIGHT && index === 0) {
-              e.preventDefault();
-            }
-            if (e.keyCode === containerUtilities.KEY_CODES.LEFT && index === selectedItems.length - 1) {
-              e.preventDefault();
-              inputRef.current && inputRef.current.focus();
-            }
-          } else {
-            if (e.keyCode === containerUtilities.KEY_CODES.LEFT && index === 0) {
-              e.preventDefault();
-            }
-            if (e.keyCode === containerUtilities.KEY_CODES.RIGHT && index === selectedItems.length - 1) {
-              e.preventDefault();
-              inputRef.current && inputRef.current.focus();
-            }
+          if (isMultiselectable) {
+            setIsTagGroupExpanded(true);
           }
-        },
-        onClick: e => {
-          e.nativeEvent.preventDownshiftDefault = true;
-        },
-        tabIndex: -1
-      }),
-      size: props.isCompact ? 'medium' : 'large'
-    });
-    const key = `${itemToString(item)}-${index}`;
-    return React__namespace.default.createElement(StyledMultiselectItemWrapper, {
-      key: key
-    }, clonedChild);
-  }, [getItemProps, inputValue, renderItem, setDownshiftState, itemToString, selectedItems, props, inputRef, themeContext.rtl]);
-  const items = React.useMemo(() => {
-    const itemValues = selectedItems || [];
-    const output = [];
-    for (let x = 0; x < itemValues.length; x++) {
-      const item = itemValues[x];
-      if (x < maxItems) {
-        if (props.disabled) {
-          const renderedItem = React__namespace.default.cloneElement(renderItem({
-            value: item,
-            removeValue: () => {
-              return undefined;
-            }
-          }), {
-            size: props.isCompact ? 'medium' : 'large'
-          });
-          output.push( React__namespace.default.createElement(StyledMultiselectItemWrapper, {
-            key: x
-          }, renderedItem));
-        } else {
-          output.push(renderSelectableItem(item, x));
-        }
-      } else if (!isFocused && !inputValue || props.disabled) {
-        output.push( React__namespace.default.createElement(StyledMultiselectItemWrapper, {
-          key: "more-anchor"
-        }, React__namespace.default.createElement(StyledMultiselectMoreAnchor, {
-          isCompact: props.isCompact,
-          isDisabled: props.disabled
-        }, renderShowMore ? renderShowMore(itemValues.length - x) : `+ ${itemValues.length - x} more`)));
-        break;
-      } else {
-        output.push(renderSelectableItem(item, x));
-      }
-    }
-    return output;
-  }, [isFocused, props.disabled, renderSelectableItem, selectedItems, renderItem, inputValue, maxItems, renderShowMore, props.isCompact]);
-  const isContainerHovered = isLabelHovered && !isOpen;
-  const isContainerFocused = isOpen || isFocused;
-  React.useEffect(() => {
-    setDropdownType('multiselect');
-  }, [setDropdownType]);
-  return React__namespace.default.createElement(reactPopper.Reference, null, _ref2 => {
-    let {
-      ref: popperReference
-    } = _ref2;
-    return React__namespace.default.createElement(StyledFauxInput, getContainerProps({
-      ...selectProps,
-      isHovered: isContainerHovered,
-      isFocused: isContainerFocused,
-      ref: selectRef => {
-        popperReference(selectRef);
-        reactMergeRefs.mergeRefs([triggerRef, popperReferenceElementRef, ref])(selectRef);
-      }
-    }), start && React__namespace.default.createElement(StyledFauxInput.StartIcon, {
-      isHovered: isHovered || isLabelHovered && !isOpen,
-      isFocused: isContainerFocused,
-      isDisabled: props.disabled
-    }, start), React__namespace.default.createElement(StyledMultiselectItemsContainer, {
-      isBare: props.isBare,
-      isCompact: props.isCompact
-    }, items, React__namespace.default.createElement(StyledMultiselectInput, getInputProps({
-      disabled: props.disabled,
-      onFocus: () => {
-        setFocusedItem(undefined);
-      },
-      onClick: e => {
-        if (inputValue && inputValue.length > 0 && isOpen) {
-          e.nativeEvent.preventDownshiftDefault = true;
         }
       },
-      onKeyDown: e => {
-        if (!inputValue) {
-          if (themeContext.rtl && e.keyCode === containerUtilities.KEY_CODES.RIGHT && selectedItems.length > 0 && previousIndexRef.current === undefined) {
-            setFocusedItem(selectedItems[selectedItems.length - 1]);
-          } else if (!themeContext.rtl && e.keyCode === containerUtilities.KEY_CODES.LEFT && selectedItems.length > 0 && previousIndexRef.current === undefined) {
-            setFocusedItem(selectedItems[selectedItems.length - 1]);
-          } else if (e.keyCode === containerUtilities.KEY_CODES.BACKSPACE && selectedItems.length > 0) {
-            setDownshiftState({
-              type: REMOVE_ITEM_STATE_TYPE,
-              selectedItem: selectedItems[selectedItems.length - 1]
-            });
-            e.nativeEvent.preventDownshiftDefault = true;
-            e.preventDefault();
-            e.stopPropagation();
+      onBlur: event => {
+        if (event.relatedTarget === null || !triggerRef.current?.contains(event.relatedTarget)) {
+          if (isEditable) {
+            setIsInputHidden(true);
+          }
+          if (isMultiselectable) {
+            setIsTagGroupExpanded(false);
           }
         }
-      },
-      isVisible: isFocused || inputValue || selectedItems.length === 0,
-      isCompact: props.isCompact,
-      role: 'combobox',
-      ref: reactMergeRefs.mergeRefs([inputRef, externalInputRef]),
-      placeholder: selectedItems.length === 0 ? placeholder : undefined
-    }))), !props.isBare && React__namespace.default.createElement(StyledFauxInput.EndIcon, {
-      isHovered: isHovered || isLabelHovered && !isOpen,
-      isFocused: isContainerFocused,
-      isDisabled: props.disabled,
-      isRotated: isOpen
-    }, React__namespace.default.createElement(SvgChevronDownStroke, null)));
+      }
+    })
+  };
+  const inputProps = {
+    'aria-invalid': validation === 'error' || validation === 'warning',
+    hidden: isInputHidden,
+    isBare,
+    isCompact,
+    isEditable,
+    isMultiselectable,
+    placeholder,
+    ...getInputProps({
+      ..._inputProps
+    })
+  };
+  const listboxProps = getListboxProps({
+    'aria-label': _listboxAriaLabel
   });
-});
-Multiselect.propTypes = {
-  isCompact: PropTypes__default.default.bool,
-  isBare: PropTypes__default.default.bool,
-  disabled: PropTypes__default.default.bool,
-  focusInset: PropTypes__default.default.bool,
-  renderItem: PropTypes__default.default.func.isRequired,
-  maxItems: PropTypes__default.default.number,
-  validation: PropTypes__default.default.oneOf(['success', 'warning', 'error'])
-};
-Multiselect.defaultProps = {
-  maxItems: 4
-};
-Multiselect.displayName = 'Multiselect';
-
-const Select = React__namespace.default.forwardRef((_ref, ref) => {
-  let {
-    children,
-    start,
-    ...props
-  } = _ref;
-  const {
-    popperReferenceElementRef,
-    itemSearchRegistry,
-    downshift: {
-      getToggleButtonProps,
-      getInputProps,
-      isOpen,
-      highlightedIndex,
-      setHighlightedIndex,
-      selectItemAtIndex,
-      closeMenu
-    }
-  } = useDropdownContext();
-  const {
-    isLabelHovered
-  } = useFieldContext();
-  const [isHovered, setIsHovered] = React.useState(false);
-  const [isFocused, setIsFocused] = React.useState(false);
-  const hiddenInputRef = React.useRef();
-  const triggerRef = React.useRef();
-  const previousIsOpenRef = React.useRef(undefined);
-  const [searchString, setSearchString] = React.useState('');
-  const searchTimeoutRef = React.useRef();
-  const currentSearchIndexRef = React.useRef(0);
   React.useEffect(() => {
-    if (hiddenInputRef.current && isOpen && !previousIsOpenRef.current) {
-      hiddenInputRef.current.focus();
-    }
-    if (triggerRef.current && !isOpen && previousIsOpenRef.current) {
-      triggerRef.current.focus();
+    if (!labelProps) {
+      const _labelProps = getLabelProps({
+        onMouseEnter: () => setIsLabelHovered(true),
+        onMouseLeave: () => setIsLabelHovered(false)
+      });
+      setLabelProps(_labelProps);
     }
-    previousIsOpenRef.current = isOpen;
-  }, [isOpen, triggerRef]);
+    return () => labelProps && setLabelProps(undefined);
+  }, [getLabelProps, labelProps, setLabelProps]);
   React.useEffect(() => {
-    if (searchTimeoutRef.current) {
-      clearTimeout(searchTimeoutRef.current);
-    }
-    searchTimeoutRef.current = window.setTimeout(() => {
-      setSearchString('');
-    }, 500);
-    return () => {
-      clearTimeout(searchTimeoutRef.current);
-    };
-  }, [searchString]);
-  const searchItems = React.useCallback((searchValue, startIndex, endIndex) => {
-    for (let index = startIndex; index < endIndex; index++) {
-      const itemTextValue = itemSearchRegistry.current[index];
-      if (itemTextValue && itemTextValue.toUpperCase().indexOf(searchValue.toUpperCase()) === 0) {
-        return index;
-      }
-    }
-    return undefined;
-  }, [itemSearchRegistry]);
-  const onInputKeyDown = React.useCallback(e => {
-    if (e.keyCode === containerUtilities.KEY_CODES.SPACE) {
-      if (searchString) {
-        e.preventDefault();
-        e.stopPropagation();
-      } else if (highlightedIndex !== null && highlightedIndex !== undefined) {
-        e.preventDefault();
-        e.stopPropagation();
-        selectItemAtIndex(highlightedIndex);
-        closeMenu();
-      }
-    }
-    if ((e.keyCode < 48 || e.keyCode > 57) && (e.keyCode < 65 || e.keyCode > 90) && e.keyCode !== containerUtilities.KEY_CODES.SPACE) {
-      return;
-    }
-    const character = String.fromCharCode(e.which || e.keyCode);
-    if (!character || character.length === 0) {
-      return;
-    }
-    if (!searchString) {
-      if (highlightedIndex === null || highlightedIndex === undefined) {
-        currentSearchIndexRef.current = -1;
-      } else {
-        currentSearchIndexRef.current = highlightedIndex;
-      }
-    }
-    const newSearchString = searchString + character;
-    setSearchString(newSearchString);
-    let matchingIndex = searchItems(newSearchString, currentSearchIndexRef.current + 1, itemSearchRegistry.current.length);
-    if (matchingIndex === undefined) {
-      matchingIndex = searchItems(newSearchString, 0, currentSearchIndexRef.current);
+    if (!hintProps) {
+      const _hintProps = getHintProps();
+      setHintProps(_hintProps);
     }
-    if (matchingIndex !== undefined) {
-      setHighlightedIndex(matchingIndex);
+    return () => hintProps && setHintProps(undefined);
+  }, [getHintProps, hintProps, setHintProps]);
+  React.useEffect(() => {
+    if (!messageProps) {
+      const _messageProps = getMessageProps();
+      setMessageProps(_messageProps);
     }
-  }, [searchString, searchItems, itemSearchRegistry, highlightedIndex, selectItemAtIndex, closeMenu, setHighlightedIndex]);
-  const {
-    type,
-    ...selectProps
-  } = getToggleButtonProps({
-    tabIndex: props.disabled ? undefined : 0,
-    onMouseEnter: containerUtilities.composeEventHandlers(props.onMouseEnter, () => setIsHovered(true)),
-    onMouseLeave: containerUtilities.composeEventHandlers(props.onMouseLeave, () => setIsHovered(false)),
-    onFocus: containerUtilities.composeEventHandlers(props.onFocus, () => setIsFocused(true)),
-    onBlur: containerUtilities.composeEventHandlers(props.onBlur, () => setIsFocused(false)),
-    ...props
-  });
-  const isContainerHovered = isLabelHovered && !isOpen;
-  const isContainerFocused = isFocused || isOpen;
-  return React__namespace.default.createElement(reactPopper.Reference, null, _ref2 => {
-    let {
-      ref: popperReference
-    } = _ref2;
-    return React__namespace.default.createElement(StyledFauxInput, _extends$5({
-      isHovered: isContainerHovered,
-      isFocused: isContainerFocused
-    }, selectProps, {
-      role: "none",
-      ref: selectRef => {
-        popperReference(selectRef);
-        reactMergeRefs.mergeRefs([triggerRef, ref, popperReferenceElementRef])(selectRef);
-      }
-    }), start && React__namespace.default.createElement(StyledFauxInput.StartIcon, {
-      isHovered: isHovered || isLabelHovered && !isOpen,
-      isFocused: isContainerFocused,
-      isDisabled: props.disabled
-    }, start), React__namespace.default.createElement(StyledSelect, null, children), React__namespace.default.createElement(StyledInput, getInputProps({
-      readOnly: true,
-      isHidden: true,
-      tabIndex: -1,
-      ref: hiddenInputRef,
-      value: '',
-      onClick: e => {
-        if (isOpen) {
-          e.nativeEvent.preventDownshiftDefault = true;
-        }
-      },
-      onKeyDown: onInputKeyDown
-    })), !props.isBare && React__namespace.default.createElement(StyledFauxInput.EndIcon, {
-      isHovered: isHovered || isLabelHovered && !isOpen,
-      isFocused: isContainerFocused,
-      isDisabled: props.disabled,
-      isRotated: isOpen
-    }, React__namespace.default.createElement(SvgChevronDownStroke, null)));
-  });
+    return () => messageProps && setMessageProps(undefined);
+  }, [getMessageProps, messageProps, setMessageProps]);
+  return React__namespace.default.createElement(ComboboxContext.Provider, {
+    value: contextValue
+  }, React__namespace.default.createElement(StyledCombobox, Object.assign({
+    isCompact: isCompact,
+    tabIndex: -1
+  }, props, {
+    ref: ref
+  }), React__namespace.default.createElement(StyledTrigger, triggerProps, React__namespace.default.createElement(StyledContainer, null, startIcon && React__namespace.default.createElement(StyledInputIcon, {
+    $isLabelHovered: isLabelHovered,
+    $isCompact: isCompact
+  }, startIcon), React__namespace.default.createElement(StyledInputGroup, null, isMultiselectable && Array.isArray(selection) && React__namespace.default.createElement(TagGroup, {
+    isDisabled: isDisabled,
+    isExpanded: isTagGroupExpanded,
+    maxTags: maxTags,
+    optionTagProps: optionTagProps,
+    selection: selection
+  }, selection.length > maxTags && React__namespace.default.createElement(StyledTagsButton, {
+    disabled: isDisabled,
+    hidden: isTagGroupExpanded,
+    isCompact: isCompact,
+    tabIndex: -1,
+    type: "button"
+  }, (() => {
+    const value = selection.length - maxTags;
+    return renderExpandTags ? renderExpandTags(value) : expandTags?.replace('{{value}}', value.toString());
+  })())), React__namespace.default.createElement(StyledValue, {
+    hidden: !isInputHidden,
+    isAutocomplete: isAutocomplete,
+    isBare: isBare,
+    isCompact: isCompact,
+    isDisabled: isDisabled,
+    isEditable: isEditable,
+    isMultiselectable: isMultiselectable,
+    isPlaceholder: !(inputValue || renderValue)
+  }, renderValue ? renderValue({
+    selection,
+    inputValue
+  }) : inputValue || placeholder), React__namespace.default.createElement(StyledInput, inputProps)), (hasChevron || endIcon) && React__namespace.default.createElement(StyledInputIcon, {
+    $isCompact: isCompact,
+    $isEnd: true,
+    $isLabelHovered: isLabelHovered,
+    $isRotated: hasChevron && isExpanded
+  }, hasChevron ? React__namespace.default.createElement(SvgChevronDownStroke, null) : endIcon))), React__namespace.default.createElement(Listbox, Object.assign({
+    appendToNode: listboxAppendToNode,
+    isCompact: isCompact,
+    isExpanded: isExpanded,
+    maxHeight: listboxMaxHeight,
+    minHeight: listboxMinHeight,
+    triggerRef: triggerRef,
+    zIndex: listboxZIndex
+  }, listboxProps), children)));
 });
-Select.displayName = 'Select';
-Select.propTypes = {
-  isCompact: PropTypes__default.default.bool,
-  isBare: PropTypes__default.default.bool,
-  disabled: PropTypes__default.default.bool,
+Combobox.displayName = 'Combobox';
+Combobox.propTypes = {
+  activeIndex: PropTypes__default.default.number,
+  defaultActiveIndex: PropTypes__default.default.number,
+  defaultExpanded: PropTypes__default.default.bool,
+  endIcon: PropTypes__default.default.any,
   focusInset: PropTypes__default.default.bool,
-  validation: PropTypes__default.default.oneOf(reactForms.VALIDATION),
-  start: PropTypes__default.default.any
+  id: PropTypes__default.default.string,
+  inputProps: PropTypes__default.default.object,
+  inputValue: PropTypes__default.default.string,
+  isAutocomplete: PropTypes__default.default.bool,
+  isBare: PropTypes__default.default.bool,
+  isCompact: PropTypes__default.default.bool,
+  isDisabled: PropTypes__default.default.bool,
+  isEditable: PropTypes__default.default.bool,
+  isExpanded: PropTypes__default.default.bool,
+  isMultiselectable: PropTypes__default.default.bool,
+  listboxAppendToNode: PropTypes__default.default.any,
+  listboxAriaLabel: PropTypes__default.default.string,
+  listboxMaxHeight: PropTypes__default.default.string,
+  listboxMinHeight: PropTypes__default.default.string,
+  listboxZIndex: PropTypes__default.default.number,
+  maxHeight: PropTypes__default.default.string,
+  maxTags: PropTypes__default.default.number,
+  onChange: PropTypes__default.default.func,
+  placeholder: PropTypes__default.default.string,
+  renderExpandTags: PropTypes__default.default.func,
+  renderValue: PropTypes__default.default.func,
+  selectionValue: PropTypes__default.default.any,
+  startIcon: PropTypes__default.default.any,
+  validation: PropTypes__default.default.oneOf(reactForms.VALIDATION)
+};
+Combobox.defaultProps = {
+  isEditable: true,
+  listboxMaxHeight: '400px',
+  listboxZIndex: 1000,
+  maxTags: MAX_TAGS
 };
 
-const Field = React.forwardRef((props, fieldRef) => {
+const Hint = React.forwardRef((props, ref) => {
   const {
-    downshift: {
-      getRootProps
-    }
-  } = useDropdownContext();
-  const [isLabelHovered, setIsLabelHovered] = React.useState(false);
-  const {
-    ref
-  } = getRootProps();
-  const value = React.useMemo(() => ({
-    isLabelHovered,
-    setIsLabelHovered
-  }), [isLabelHovered, setIsLabelHovered]);
-  return React__namespace.default.createElement(FieldContext.Provider, {
-    value: value
-  }, React__namespace.default.createElement(reactForms.Field, _extends$5({
-    ref: reactMergeRefs.mergeRefs([ref, fieldRef])
-  }, props)));
+    hintProps,
+    setHasHint
+  } = useFieldContext();
+  React.useEffect(() => {
+    setHasHint(true);
+    return () => setHasHint(false);
+  }, [setHasHint]);
+  return React__namespace.default.createElement(StyledHint, Object.assign({}, hintProps, props, {
+    ref: ref
+  }));
 });
-Field.displayName = 'Field';
-
-const Hint = React__namespace.default.forwardRef((props, ref) => React__namespace.default.createElement(reactForms.Hint, _extends$5({
-  ref: ref
-}, props)));
 Hint.displayName = 'Hint';
 
-const Label = React__namespace.default.forwardRef((_ref, ref) => {
+const Label = React.forwardRef((_ref, ref) => {
   let {
+    onClick,
     onMouseEnter,
     onMouseLeave,
-    ...other
+    ...props
   } = _ref;
   const {
-    downshift: {
-      getLabelProps
-    }
-  } = useDropdownContext();
-  const {
-    setIsLabelHovered
+    labelProps
   } = useFieldContext();
-  const labelProps = getLabelProps({
-    onMouseEnter: containerUtilities.composeEventHandlers(onMouseEnter, () => {
-      setIsLabelHovered(true);
-    }),
-    onMouseLeave: containerUtilities.composeEventHandlers(onMouseLeave, () => {
-      setIsLabelHovered(false);
-    }),
-    ...other
-  });
-  return React__namespace.default.createElement(reactForms.Label, _extends$5({
+  return React__namespace.default.createElement(StyledLabel, Object.assign({}, labelProps, {
+    onClick: containerUtilities.composeEventHandlers(onClick, labelProps?.onClick),
+    onMouseEnter: containerUtilities.composeEventHandlers(onMouseEnter, labelProps?.onMouseEnter),
+    onMouseLeave: containerUtilities.composeEventHandlers(onMouseLeave, labelProps?.onMouseLeave)
+  }, props, {
     ref: ref
-  }, labelProps));
+  }));
 });
 Label.displayName = 'Label';
 Label.propTypes = {
+  hidden: PropTypes__default.default.bool,
   isRegular: PropTypes__default.default.bool
 };
 
-const Message = React__namespace.default.forwardRef((props, ref) => React__namespace.default.createElement(reactForms.Message, _extends$5({
-  ref: ref
-}, props)));
+const Message = React.forwardRef((props, ref) => {
+  const {
+    messageProps,
+    setHasMessage
+  } = useFieldContext();
+  React.useEffect(() => {
+    setHasMessage(true);
+    return () => setHasMessage(false);
+  }, [setHasMessage]);
+  return React__namespace.default.createElement(StyledMessage, Object.assign({}, messageProps, props, {
+    ref: ref
+  }));
+});
 Message.displayName = 'Message';
 Message.propTypes = {
-  validation: PropTypes__default.default.oneOf(reactForms.VALIDATION)
-};
-
-const SHARED_PLACEMENT = ['auto', 'top', 'top-start', 'top-end', 'bottom', 'bottom-start', 'bottom-end'];
-const PLACEMENT = [...SHARED_PLACEMENT, 'end', 'end-top', 'end-bottom', 'start', 'start-top', 'start-bottom'];
-
-const MenuContext = React__namespace.default.createContext(undefined);
-const useMenuContext = () => {
-  const menuContext = React.useContext(MenuContext);
-  if (!menuContext) {
-    throw new Error('This component must be rendered within a `Menu` component.');
-  }
-  return menuContext;
+  validation: PropTypes__default.default.oneOf(reactForms.VALIDATION),
+  validationLabel: PropTypes__default.default.string
 };
 
-const Menu = React.forwardRef((props, menuRef) => {
-  const {
-    placement,
-    popperModifiers,
-    eventsEnabled,
-    isAnimated,
-    maxHeight,
-    style: menuStyle,
-    zIndex,
-    isCompact,
-    children,
-    appendToNode,
-    ...otherProps
-  } = props;
-  const {
-    hasMenuRef,
-    itemIndexRef,
-    previousIndexRef,
-    nextItemsHashRef,
-    popperReferenceElementRef,
-    itemSearchRegistry,
-    downshift: {
-      isOpen,
-      getMenuProps
-    }
-  } = useDropdownContext();
-  const scheduleUpdateRef = React.useRef(undefined);
-  React.useEffect(() => {
-    if (scheduleUpdateRef.current && isOpen) {
-      scheduleUpdateRef.current();
-    }
-  });
-  const [isVisible, setIsVisible] = React.useState(isOpen);
-  React.useEffect(() => {
-    let timeout;
-    if (isOpen) {
-      setIsVisible(true);
-    } else if (isAnimated) {
-      timeout = setTimeout(() => setIsVisible(false), 200);
-    } else {
-      setIsVisible(false);
-    }
-    return () => clearTimeout(timeout);
-  }, [isOpen, isAnimated]);
-  const themeContext = React.useContext(styled.ThemeContext);
-  itemIndexRef.current = 0;
-  nextItemsHashRef.current = {};
-  previousIndexRef.current = undefined;
-  itemSearchRegistry.current = [];
-  const popperPlacement = themeContext.rtl ? getRtlPopperPlacement(placement) : getPopperPlacement(placement);
-  return (
-    React__namespace.default.createElement(MenuContext.Provider, {
-      value: {
-        itemIndexRef,
-        isCompact
-      }
-    }, React__namespace.default.createElement(reactPopper.Popper, {
-      placement: popperPlacement,
-      modifiers: popperModifiers
-      ,
-      eventsEnabled: isOpen && eventsEnabled
-    }, _ref => {
-      let {
-        ref,
-        style,
-        scheduleUpdate,
-        placement: currentPlacement
-      } = _ref;
-      let computedStyle = menuStyle;
-      scheduleUpdateRef.current = scheduleUpdate;
-      if ((isOpen || isVisible) && popperReferenceElementRef.current && popperReferenceElementRef.current.getBoundingClientRect) {
-        computedStyle = {
-          width: popperReferenceElementRef.current.getBoundingClientRect().width,
-          ...menuStyle
-        };
-      }
-      const menuProps = getMenuProps({
-        role: hasMenuRef.current ? 'menu' : 'listbox',
-        placement: currentPlacement,
-        isAnimated: isAnimated && (isOpen || isVisible),
-        ...otherProps
-      });
-      const menu = React__namespace.default.createElement(StyledMenuWrapper, {
-        ref: isOpen ? ref : undefined,
-        hasArrow: menuProps.hasArrow,
-        placement: menuProps.placement,
-        style: style,
-        isHidden: !isOpen,
-        isAnimated: menuProps.isAnimated,
-        zIndex: zIndex
-      }, React__namespace.default.createElement(StyledMenu, _extends$5({
-        ref: menuRef,
-        isCompact: isCompact,
-        maxHeight: maxHeight,
-        style: computedStyle
-      }, menuProps), (isOpen || isVisible) && children));
-      return appendToNode ? reactDom.createPortal(menu, appendToNode) : menu;
-    }))
-  );
+const FieldComponent = React.forwardRef((props, ref) => {
+  const [labelProps, setLabelProps] = React.useState(undefined);
+  const [hintProps, setHintProps] = React.useState(undefined);
+  const [messageProps, setMessageProps] = React.useState(undefined);
+  const [hasHint, setHasHint] = React.useState(false);
+  const [hasMessage, setHasMessage] = React.useState(false);
+  const contextValue = React.useMemo(() => ({
+    labelProps,
+    setLabelProps,
+    hasHint,
+    setHasHint,
+    hintProps,
+    setHintProps,
+    hasMessage,
+    setHasMessage,
+    messageProps,
+    setMessageProps
+  }), [labelProps, setLabelProps, hasHint, setHasHint, hintProps, setHintProps, hasMessage, setHasMessage, messageProps, setMessageProps]);
+  return React__namespace.default.createElement(FieldContext.Provider, {
+    value: contextValue
+  }, React__namespace.default.createElement(StyledField, Object.assign({}, props, {
+    ref: ref
+  })));
 });
-Menu.displayName = 'Menu';
-Menu.propTypes = {
-  popperModifiers: PropTypes__default.default.any,
-  eventsEnabled: PropTypes__default.default.bool,
-  zIndex: PropTypes__default.default.number,
-  style: PropTypes__default.default.object,
-  placement: PropTypes__default.default.oneOf(PLACEMENT),
-  isAnimated: PropTypes__default.default.bool,
-  isCompact: PropTypes__default.default.bool,
-  hasArrow: PropTypes__default.default.bool,
-  maxHeight: PropTypes__default.default.string
-};
-Menu.defaultProps = {
-  placement: 'bottom-start',
-  isAnimated: true,
-  eventsEnabled: true,
-  maxHeight: '400px',
-  zIndex: 1000
+FieldComponent.displayName = 'Field';
+const Field = FieldComponent;
+Field.Hint = Hint;
+Field.Label = Label;
+Field.Message = Message;
+
+var _path$3;
+function _extends$3() { _extends$3 = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends$3.apply(this, arguments); }
+var SvgPlusStroke = function SvgPlusStroke(props) {
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$3({
+    xmlns: "http://www.w3.org/2000/svg",
+    width: 16,
+    height: 16,
+    focusable: "false",
+    viewBox: "0 0 16 16",
+    "aria-hidden": "true"
+  }, props), _path$3 || (_path$3 = /*#__PURE__*/React__namespace.createElement("path", {
+    stroke: "currentColor",
+    strokeLinecap: "round",
+    d: "M7.5 2.5v12m6-6h-12"
+  })));
 };
 
-const Separator = React__namespace.default.forwardRef((props, ref) => React__namespace.default.createElement(StyledSeparator, _extends$5({
-  ref: ref
-}, props)));
-Separator.displayName = 'Separator';
+var _path$2;
+function _extends$2() { _extends$2 = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends$2.apply(this, arguments); }
+var SvgChevronRightStroke = function SvgChevronRightStroke(props) {
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$2({
+    xmlns: "http://www.w3.org/2000/svg",
+    width: 16,
+    height: 16,
+    focusable: "false",
+    viewBox: "0 0 16 16",
+    "aria-hidden": "true"
+  }, props), _path$2 || (_path$2 = /*#__PURE__*/React__namespace.createElement("path", {
+    fill: "currentColor",
+    d: "M5.61 3.312a.5.5 0 01.718-.69l.062.066 4 5a.5.5 0 01.054.542l-.054.082-4 5a.5.5 0 01-.83-.55l.05-.074L9.359 8l-3.75-4.688z"
+  })));
+};
 
 var _path$1;
 function _extends$1() { _extends$1 = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends$1.apply(this, arguments); }
-var SvgPlusStroke = function SvgPlusStroke(props) {
+var SvgChevronLeftStroke = function SvgChevronLeftStroke(props) {
   return /*#__PURE__*/React__namespace.createElement("svg", _extends$1({
     xmlns: "http://www.w3.org/2000/svg",
     width: 16,
@@ -1716,9 +1305,8 @@ var SvgPlusStroke = function SvgPlusStroke(props) {
     viewBox: "0 0 16 16",
     "aria-hidden": "true"
   }, props), _path$1 || (_path$1 = /*#__PURE__*/React__namespace.createElement("path", {
-    stroke: "currentColor",
-    strokeLinecap: "round",
-    d: "M7.5 2.5v12m6-6h-12"
+    fill: "currentColor",
+    d: "M10.39 12.688a.5.5 0 01-.718.69l-.062-.066-4-5a.5.5 0 01-.054-.542l.054-.082 4-5a.5.5 0 01.83.55l-.05.074L6.641 8l3.75 4.688z"
   })));
 };
 
@@ -1741,342 +1329,638 @@ var SvgCheckLgStroke = function SvgCheckLgStroke(props) {
   })));
 };
 
-const ItemContext = React__namespace.default.createContext(undefined);
-const useItemContext = () => {
-  const context = React.useContext(ItemContext);
+const OPTION_TYPE = ['add', 'danger', 'next', 'previous'];
+const PLACEMENT = ['auto', ...reactTheming.PLACEMENT];
+
+const OptionContext = React.createContext(undefined);
+const useOptionContext = () => {
+  const context = React.useContext(OptionContext);
   if (!context) {
-    throw new Error('This component must be rendered within an `Item` component.');
+    throw new Error('Error: this component must be rendered within an <Option>.');
   }
   return context;
 };
 
-const Item = React__namespace.default.forwardRef((_ref, forwardRef) => {
+const OptionMetaComponent = React.forwardRef((props, ref) => {
+  const {
+    isDisabled
+  } = useOptionContext();
+  return React__namespace.default.createElement(StyledOptionMeta, Object.assign({
+    isDisabled: isDisabled
+  }, props, {
+    ref: ref
+  }));
+});
+OptionMetaComponent.displayName = 'Option.Meta';
+const OptionMeta = OptionMetaComponent;
+
+const OptionComponent = React.forwardRef((_ref, ref) => {
   let {
-    value,
-    disabled,
-    isDanger,
-    component = StyledItem,
-    hasIcon,
     children,
+    icon,
+    isDisabled,
+    isHidden,
+    isSelected,
+    label,
+    type,
+    value,
     ...props
   } = _ref;
+  const contextValue = React.useMemo(() => ({
+    isDisabled
+  }), [isDisabled]);
   const {
-    selectedItems,
-    hasMenuRef,
-    itemSearchRegistry,
-    downshift: {
-      isOpen,
-      selectedItem,
-      highlightedIndex,
-      getItemProps,
-      setHighlightedIndex,
-      itemToString
-    }
-  } = useDropdownContext();
-  const {
-    itemIndexRef,
+    activeValue,
+    getOptionProps,
     isCompact
-  } = useMenuContext();
-  const itemRef = React.useRef();
-  const Component = component;
-  if ((value === undefined || value === null) && !disabled) {
-    throw new Error('All Item components require a `value` prop');
-  }
-  const currentIndex = itemIndexRef.current;
-  const isFocused = highlightedIndex === currentIndex;
-  let isSelected;
+  } = useComboboxContext();
+  const isActive = value === activeValue;
+  const optionRef = React.useRef(null);
   React.useEffect(() => {
-    if (!disabled && itemRef.current) {
-      const itemTextValue = itemRef.current.innerText;
-      if (itemTextValue) {
-        itemSearchRegistry.current[currentIndex] = itemTextValue;
-      }
-    }
-  });
-  if (value) {
-    if (selectedItems) {
-      isSelected = selectedItems.some(item => {
-        return itemToString(item) === itemToString(value);
+    if (isActive) {
+      setTimeout(() => {
+        if (optionRef.current && optionRef.current.scrollIntoView) {
+          optionRef.current.scrollIntoView({
+            block: 'nearest'
+          });
+        }
       });
-    } else {
-      isSelected = itemToString(selectedItem) === itemToString(value);
     }
-  } else {
-    isSelected = false;
-  }
-  React.useEffect(() => {
-    if (isOpen && !disabled && !selectedItems && isSelected) {
-      setHighlightedIndex(currentIndex);
+  }, [isActive]);
+  const renderActionIcon = iconType => {
+    switch (iconType) {
+      case 'add':
+        return React__namespace.default.createElement(SvgPlusStroke, null);
+      case 'next':
+        return React__namespace.default.createElement(SvgChevronRightStroke, null);
+      case 'previous':
+        return React__namespace.default.createElement(SvgChevronLeftStroke, null);
+      default:
+        return React__namespace.default.createElement(SvgCheckLgStroke, null);
     }
-  }, [currentIndex, disabled, isOpen, isSelected, selectedItems, setHighlightedIndex]);
-  const contextValue = React.useMemo(() => ({
-    isDisabled: disabled
-  }), [disabled]);
-  const ref = reactMergeRefs.mergeRefs([itemRef, forwardRef]);
-  if (disabled) {
-    return React__namespace.default.createElement(ItemContext.Provider, {
-      value: contextValue
-    }, React__namespace.default.createElement(Component, _extends$5({
-      ref: ref,
-      disabled: disabled,
-      isDanger: isDanger,
-      isCompact: isCompact
-    }, props), isSelected && !hasIcon && React__namespace.default.createElement(StyledItemIcon, {
-      isCompact: isCompact,
-      isVisible: isSelected,
-      isDisabled: disabled
-    }, React__namespace.default.createElement(SvgCheckLgStroke, null)), children));
-  }
-  itemIndexRef.current++;
-  return React__namespace.default.createElement(ItemContext.Provider, {
+  };
+  const option = toOption({
+    value,
+    label,
+    isDisabled,
+    isHidden,
+    isSelected
+  });
+  const optionProps = getOptionProps({
+    option,
+    ref: reactMergeRefs.mergeRefs([optionRef, ref])
+  });
+  return React__namespace.default.createElement(OptionContext.Provider, {
     value: contextValue
-  }, React__namespace.default.createElement(Component, getItemProps({
-    item: value,
-    isFocused,
-    ref,
-    isCompact,
-    isDanger,
-    ...(hasMenuRef.current && {
-      role: 'menuitem',
-      'aria-selected': null
-    }),
-    ...props
-  }), isSelected && !hasIcon && React__namespace.default.createElement(StyledItemIcon, {
+  }, React__namespace.default.createElement(StyledOption, Object.assign({
+    isActive: isActive,
     isCompact: isCompact,
-    isVisible: isSelected
-  }, React__namespace.default.createElement(SvgCheckLgStroke, null)), children));
+    $type: type
+  }, props, optionProps), React__namespace.default.createElement(StyledOptionTypeIcon, {
+    $isCompact: isCompact,
+    $type: type
+  }, renderActionIcon(type)), icon && React__namespace.default.createElement(StyledOptionIcon, null, icon), React__namespace.default.createElement(StyledOptionContent, null, children || label || value)));
 });
-Item.displayName = 'Item';
-Item.propTypes = {
-  value: PropTypes__default.default.any,
-  disabled: PropTypes__default.default.bool
+OptionComponent.displayName = 'Option';
+OptionComponent.propTypes = {
+  icon: PropTypes__default.default.any,
+  isDisabled: PropTypes__default.default.bool,
+  isSelected: PropTypes__default.default.bool,
+  isHidden: PropTypes__default.default.bool,
+  label: PropTypes__default.default.string,
+  tagProps: PropTypes__default.default.object,
+  type: PropTypes__default.default.oneOf(OPTION_TYPE),
+  value: PropTypes__default.default.string.isRequired
 };
+const Option = OptionComponent;
+Option.Meta = OptionMeta;
 
-const AddItemComponent = React__namespace.default.forwardRef((_ref, ref) => {
+const OptGroup = React.forwardRef((_ref, ref) => {
   let {
     children,
-    disabled,
+    content,
+    icon,
+    legend,
+    'aria-label': ariaLabel,
+    onMouseDown,
     ...props
   } = _ref;
   const {
+    getOptGroupProps,
     isCompact
-  } = useMenuContext();
-  return React__namespace.default.createElement(StyledAddItem, _extends$5({
-    ref: ref,
-    disabled: disabled
-  }, props), React__namespace.default.createElement(StyledItemIcon, {
+  } = useComboboxContext();
+  const handleMouseDown = event => event.preventDefault();
+  const groupAriaLabel = reactTheming.useText(OptGroup, {
+    'aria-label': ariaLabel
+  }, 'aria-label', 'Group', !legend );
+  const optGroupProps = getOptGroupProps({
+    'aria-label': groupAriaLabel || legend
+  });
+  return React__namespace.default.createElement(StyledOption, Object.assign({
     isCompact: isCompact,
-    isVisible: true,
-    isDisabled: disabled
-  }, React__namespace.default.createElement(SvgPlusStroke, null)), children);
-});
-const AddItem = React__namespace.default.forwardRef((props, ref) => React__namespace.default.createElement(Item, _extends$5({
-  component: AddItemComponent,
-  ref: ref
-}, props, {
-  hasIcon: true
-})));
-AddItem.displayName = 'AddItem';
-AddItem.propTypes = {
-  value: PropTypes__default.default.any,
-  disabled: PropTypes__default.default.bool
-};
-
-const HeaderIcon = React__namespace.default.forwardRef((props, ref) => {
-  const {
-    isCompact
-  } = useMenuContext();
-  return React__namespace.default.createElement(StyledHeaderIcon, _extends$5({
-    ref: ref,
+    $type: "group",
+    onMouseDown: containerUtilities.composeEventHandlers(onMouseDown, handleMouseDown),
+    role: "none"
+  }, props, {
+    ref: ref
+  }), React__namespace.default.createElement(StyledOptionContent, null, (content || legend) && React__namespace.default.createElement(StyledOption, {
+    as: "div",
+    isCompact: isCompact,
+    $type: "header"
+  }, icon && React__namespace.default.createElement(StyledOptionTypeIcon, {
+    $isCompact: isCompact,
+    $type: "header"
+  }, icon), content || legend), React__namespace.default.createElement(StyledOptGroup, Object.assign({
     isCompact: isCompact
-  }, props));
+  }, optGroupProps), React__namespace.default.createElement(StyledListboxSeparator, {
+    role: "none"
+  }), children)));
 });
-HeaderIcon.displayName = 'HeaderIcon';
+OptGroup.displayName = 'OptGroup';
+OptGroup.propTypes = {
+  content: PropTypes__default.default.any,
+  icon: PropTypes__default.default.any,
+  legend: PropTypes__default.default.string
+};
 
-const HeaderItem = React__namespace.default.forwardRef((props, ref) => {
-  const {
-    isCompact
-  } = useMenuContext();
-  return React__namespace.default.createElement(StyledHeaderItem, _extends$5({
-    ref: ref,
-    isCompact: isCompact
-  }, props));
+const MenuContext = React.createContext(undefined);
+const useMenuContext = () => {
+  const context = React.useContext(MenuContext);
+  if (!context) {
+    throw new Error('Error: this component must be rendered within a <Menu>.');
+  }
+  return context;
+};
+
+const toItem = props => ({
+  value: props.value,
+  label: props.label,
+  ...(props.name && {
+    name: props.name
+  }),
+  ...(props.isDisabled && {
+    disabled: props.isDisabled
+  }),
+  ...(props.isSelected && {
+    selected: props.isSelected
+  }),
+  ...(props.selectionType && {
+    type: props.selectionType
+  }),
+  ...(props.type === 'next' && {
+    isNext: true
+  }),
+  ...(props.type === 'previous' && {
+    isPrevious: true
+  })
 });
-HeaderItem.displayName = 'HeaderItem';
+const toItems = (children, type) => React.Children.toArray(children).reduce((items, item) => {
+  const retVal = items;
+  if ( React.isValidElement(item)) {
+    if ('value' in item.props) {
+      retVal.push(toItem({
+        ...item.props,
+        selectionType: type
+      }));
+    } else {
+      const props = item.props;
+      const groupLabel = props.legend || props['aria-label'];
+      const isSelectableGroup = props.type && ['checkbox', 'radio'].includes(props.type);
+      if (groupLabel || isSelectableGroup) {
+        const groupItems = toItems(props.children, props.type);
+        retVal.push({
+          label: props.legend || props['aria-label'],
+          items: groupItems
+        });
+      }
+    }
+  }
+  return retVal;
+}, []);
 
-const ItemMeta = React__namespace.default.forwardRef((props, ref) => {
-  const {
-    isCompact
-  } = useMenuContext();
+const PLACEMENT_DEFAULT = 'bottom-start';
+const MenuList = React.forwardRef((_ref, ref) => {
+  let {
+    appendToNode,
+    hasArrow,
+    isCompact,
+    isExpanded,
+    fallbackPlacements: _fallbackPlacements,
+    maxHeight,
+    minHeight,
+    placement: _placement,
+    triggerRef,
+    zIndex,
+    children,
+    ...props
+  } = _ref;
+  const floatingRef = React.useRef(null);
+  const [isVisible, setIsVisible] = React.useState(isExpanded);
+  const [height, setHeight] = React.useState();
+  const theme = React.useContext(styled.ThemeContext) || reactTheming.DEFAULT_THEME;
+  const [floatingPlacement, fallbackPlacements] = reactTheming.getFloatingPlacements(theme, _placement === 'auto' ? PLACEMENT_DEFAULT : _placement, _fallbackPlacements);
   const {
-    isDisabled
-  } = useItemContext();
-  return React__namespace.default.createElement(StyledItemMeta, _extends$5({
-    ref: ref,
+    refs,
+    placement,
+    update,
+    floatingStyles: {
+      transform
+    }
+  } = reactDom.useFloating({
+    platform: {
+      ...reactDom.platform,
+      isRTL: () => theme.rtl
+    },
+    elements: {
+      reference: triggerRef?.current,
+      floating: floatingRef?.current
+    },
+    placement: floatingPlacement,
+    middleware: [reactDom.offset(theme.space.base * (hasArrow ? 2 : 1)), _placement === 'auto' ? reactDom.autoPlacement() : reactDom.flip({
+      fallbackPlacements
+    }), reactDom.size({
+      apply: _ref2 => {
+        let {
+          rects,
+          availableHeight
+        } = _ref2;
+        if (!(minHeight === null || minHeight === 'fit-content')) {
+          if (rects.floating.height > availableHeight) {
+            setHeight(availableHeight);
+          }
+        }
+      }
+    })]
+  });
+  React.useEffect(() => {
+    let cleanup;
+    if (isExpanded && refs.reference.current && refs.floating.current) {
+      cleanup = reactDom.autoUpdate(refs.reference.current, refs.floating.current, update, {
+        elementResize: typeof ResizeObserver === 'function'
+      });
+    }
+    return () => cleanup && cleanup();
+  }, [isExpanded, refs.reference, refs.floating, update]);
+  React.useEffect(() => {
+    let timeout;
+    if (isExpanded) {
+      setIsVisible(true);
+    } else {
+      timeout = setTimeout(() => {
+        setIsVisible(false);
+        setHeight(undefined);
+      }, 200 );
+    }
+    return () => clearTimeout(timeout);
+  }, [isExpanded]);
+  React.useEffect(() => {
+    if (height) {
+      setHeight(undefined);
+      update();
+    }
+  }, [
+  children, update]);
+  const Node = React__namespace.default.createElement(StyledFloatingMenu, {
+    "data-garden-animate": isVisible,
+    isHidden: !isExpanded,
+    position: reactTheming.getMenuPosition(placement),
+    zIndex: zIndex,
+    style: {
+      transform
+    },
+    ref: floatingRef
+  }, React__namespace.default.createElement(StyledMenu, Object.assign({
+    "data-garden-animate-arrow": isVisible,
+    arrowPosition: hasArrow ? reactTheming.getArrowPosition(theme, placement) : undefined,
     isCompact: isCompact,
-    isDisabled: isDisabled
-  }, props));
+    minHeight: minHeight,
+    maxHeight: maxHeight,
+    style: {
+      height
+    }
+  }, props, {
+    ref: ref
+  }), isVisible && children));
+  return appendToNode ? reactDom$1.createPortal(Node, appendToNode) : Node;
 });
-ItemMeta.displayName = 'ItemMeta';
+MenuList.displayName = 'MenuList';
+MenuList.propTypes = {
+  appendToNode: PropTypes__default.default.any,
+  hasArrow: PropTypes__default.default.bool,
+  isCompact: PropTypes__default.default.bool,
+  isExpanded: PropTypes__default.default.bool,
+  maxHeight: PropTypes__default.default.string,
+  minHeight: PropTypes__default.default.string,
+  placement: PropTypes__default.default.oneOf(PLACEMENT),
+  triggerRef: PropTypes__default.default.any,
+  zIndex: PropTypes__default.default.number
+};
+MenuList.defaultProps = {
+  maxHeight: '400px',
+  placement: PLACEMENT_DEFAULT,
+  zIndex: 1000
+};
 
-const MediaBody = React__namespace.default.forwardRef((props, ref) => {
+const Menu = React.forwardRef((_ref, ref) => {
+  let {
+    button,
+    buttonProps: _buttonProps = {},
+    children,
+    isCompact,
+    focusedValue: _focusedValue,
+    defaultFocusedValue,
+    defaultExpanded,
+    isExpanded: _isExpanded,
+    selectedItems,
+    onChange,
+    onMouseLeave,
+    ...props
+  } = _ref;
+  const triggerRef = React.useRef(null);
+  const menuRef = React.useRef(null);
+  const items = toItems(children);
+  const theme = React.useContext(styled.ThemeContext) || reactTheming.DEFAULT_THEME;
+  const environment = reactTheming.useWindow(theme);
   const {
-    isCompact
-  } = useMenuContext();
-  return React__namespace.default.createElement(StyledMediaBody, _extends$5({
-    ref: ref,
-    isCompact: isCompact
-  }, props));
-});
-MediaBody.displayName = 'MediaBody';
-
-const MediaFigure = props => {
+    isExpanded,
+    focusedValue,
+    getTriggerProps,
+    getMenuProps,
+    getItemProps,
+    getItemGroupProps,
+    getSeparatorProps
+  } = containerMenu.useMenu({
+    rtl: theme.rtl,
+    environment,
+    defaultFocusedValue,
+    focusedValue: _focusedValue,
+    defaultExpanded,
+    isExpanded: _isExpanded,
+    selectedItems,
+    items,
+    menuRef,
+    triggerRef,
+    onChange
+  });
   const {
-    isCompact
-  } = useMenuContext();
-  return React__namespace.default.createElement(StyledMediaFigure, _extends$5({
-    isCompact: isCompact
-  }, props));
+    onClick,
+    onKeyDown,
+    disabled,
+    ...buttonProps
+  } = _buttonProps;
+  const triggerProps = {
+    ...(isCompact && {
+      size: 'small'
+    }),
+    ...buttonProps,
+    ...getTriggerProps({
+      type: 'button',
+      onClick,
+      onKeyDown,
+      disabled
+    }),
+    ref: reactMergeRefs.mergeRefs([triggerRef, ref])
+  };
+  const trigger = typeof button === 'function' ? button(triggerProps) : React__namespace.default.createElement(StyledButton, triggerProps, button, React__namespace.default.createElement(StyledButton.EndIcon, {
+    isRotated: isExpanded
+  }, React__namespace.default.createElement(SvgChevronDownStroke, null)));
+  const contextValue = React.useMemo(() => ({
+    isCompact,
+    focusedValue,
+    getItemProps,
+    getItemGroupProps,
+    getSeparatorProps
+  }), [isCompact, focusedValue, getItemProps, getItemGroupProps, getSeparatorProps]);
+  return React__namespace.default.createElement(MenuContext.Provider, {
+    value: contextValue
+  }, trigger, React__namespace.default.createElement(MenuList, Object.assign({}, props, getMenuProps({
+    onMouseLeave
+  }), {
+    ref: reactMergeRefs.mergeRefs([menuRef, ref]),
+    isCompact: isCompact,
+    isExpanded: isExpanded,
+    triggerRef: triggerRef
+  }), children));
+});
+Menu.displayName = 'Menu';
+Menu.propTypes = {
+  appendToNode: PropTypes__default.default.any,
+  button: PropTypes__default.default.any.isRequired,
+  buttonProps: PropTypes__default.default.object,
+  defaultExpanded: PropTypes__default.default.bool,
+  defaultFocusedValue: PropTypes__default.default.string,
+  fallbackPlacements: PropTypes__default.default.arrayOf(PropTypes__default.default.any),
+  focusedValue: PropTypes__default.default.string,
+  hasArrow: PropTypes__default.default.bool,
+  isCompact: PropTypes__default.default.bool,
+  isExpanded: PropTypes__default.default.bool,
+  maxHeight: PropTypes__default.default.string,
+  minHeight: PropTypes__default.default.string,
+  onChange: PropTypes__default.default.func,
+  placement: PropTypes__default.default.oneOf(PLACEMENT),
+  selectedItems: PropTypes__default.default.arrayOf(PropTypes__default.default.any),
+  zIndex: PropTypes__default.default.number
+};
+Menu.defaultProps = {
+  maxHeight: '400px',
+  placement: 'bottom-start',
+  zIndex: 1000
 };
 
-const MediaItem = React__namespace.default.forwardRef((props, ref) => React__namespace.default.createElement(Item, _extends$5({
-  component: StyledMediaItem,
-  ref: ref
-}, props)));
-MediaItem.displayName = 'MediaItem';
-MediaItem.propTypes = {
-  value: PropTypes__default.default.any,
-  disabled: PropTypes__default.default.bool
+const ItemGroupContext = React.createContext({});
+const useItemGroupContext = () => {
+  return React.useContext(ItemGroupContext);
 };
 
-const NextItemComponent = React__namespace.default.forwardRef((_ref, ref) => {
+const ItemGroup = React.forwardRef((_ref, ref) => {
   let {
     children,
-    disabled,
+    content,
+    legend,
+    icon,
+    'aria-label': ariaLabel,
+    type,
     ...props
   } = _ref;
   const {
-    isCompact
+    isCompact,
+    getItemGroupProps
   } = useMenuContext();
-  return React__namespace.default.createElement(StyledNextItem, _extends$5({
-    ref: ref,
-    disabled: disabled
-  }, props), React__namespace.default.createElement(StyledItemIcon, {
+  const groupAriaLabel = reactTheming.useText(ItemGroup, {
+    'aria-label': ariaLabel
+  }, 'aria-label', 'Group', !legend );
+  const groupProps = getItemGroupProps({
+    'aria-label': groupAriaLabel || legend
+  });
+  const contextValue = React.useMemo(() => ({
+    type
+  }), [type]);
+  return React__namespace.default.createElement(ItemGroupContext.Provider, {
+    value: contextValue
+  }, React__namespace.default.createElement(StyledItem, Object.assign({
+    isCompact: isCompact,
+    $type: "group"
+  }, props, {
+    ref: ref
+  }), React__namespace.default.createElement(StyledItemContent, null, (content || legend) && React__namespace.default.createElement(StyledItem, {
+    as: "div",
     isCompact: isCompact,
-    isDisabled: disabled,
-    isVisible: true
-  }, React__namespace.default.createElement(StyledNextIcon, {
-    isDisabled: disabled
-  })), children);
+    $type: "header"
+  }, icon && React__namespace.default.createElement(StyledItemTypeIcon, {
+    $isCompact: isCompact,
+    $type: "header"
+  }, icon), content || legend), React__namespace.default.createElement(StyledItemGroup, Object.assign({
+    isCompact: isCompact
+  }, groupProps), React__namespace.default.createElement(StyledSeparator, {
+    role: "none"
+  }), children))));
 });
-const NextItem = React__namespace.default.forwardRef((_ref2, ref) => {
-  let {
-    value,
-    disabled,
-    ...props
-  } = _ref2;
-  const {
-    nextItemsHashRef,
-    downshift: {
-      itemToString
-    }
-  } = useDropdownContext();
-  const {
-    itemIndexRef
-  } = useMenuContext();
-  if (!disabled) {
-    nextItemsHashRef.current[itemToString(value)] = itemIndexRef.current;
+ItemGroup.displayName = 'ItemGroup';
+ItemGroup.propTypes = {
+  content: PropTypes__default.default.any,
+  icon: PropTypes__default.default.any,
+  legend: PropTypes__default.default.string,
+  type: PropTypes__default.default.oneOf(['checkbox', 'radio', undefined])
+};
+
+const ItemContext = React.createContext(undefined);
+const useItemContext = () => {
+  const context = React.useContext(ItemContext);
+  if (!context) {
+    throw new Error('Error: this component must be rendered within an <Item>.');
   }
-  return React__namespace.default.createElement(Item, _extends$5({
-    component: NextItemComponent,
-    "aria-expanded": true,
-    disabled: disabled,
-    value: value,
-    ref: ref
+  return context;
+};
+
+const ItemMetaComponent = React.forwardRef((props, ref) => {
+  const {
+    isDisabled
+  } = useItemContext();
+  return React__namespace.default.createElement(StyledItemMeta, Object.assign({
+    isDisabled: isDisabled
   }, props, {
-    hasIcon: true
+    ref: ref
   }));
 });
-NextItem.displayName = 'NextItem';
-NextItem.propTypes = {
-  value: PropTypes__default.default.any,
-  disabled: PropTypes__default.default.bool
-};
+ItemMetaComponent.displayName = 'Item.Meta';
+const ItemMeta = ItemMetaComponent;
 
-const PreviousItemComponent = React__namespace.default.forwardRef((_ref, ref) => {
+const ItemComponent = React.forwardRef((_ref, ref) => {
   let {
     children,
-    disabled,
+    value,
+    label = value,
+    isSelected,
+    icon,
+    isDisabled,
+    type,
+    name,
+    onClick,
+    onKeyDown,
+    onMouseEnter,
     ...props
   } = _ref;
+  const {
+    type: selectionType
+  } = useItemGroupContext();
+  const {
+    focusedValue,
+    getItemProps
+  } = useMenuContext();
+  const item = {
+    ...toItem({
+      value,
+      label,
+      name,
+      type,
+      isSelected,
+      isDisabled
+    }),
+    type: selectionType
+  };
+  const {
+    ref: _itemRef,
+    ...itemProps
+  } = getItemProps({
+    item,
+    onClick,
+    onKeyDown,
+    onMouseEnter
+  });
+  const isActive = value === focusedValue;
   const {
     isCompact
   } = useMenuContext();
-  return React__namespace.default.createElement(StyledPreviousItem, _extends$5({
-    ref: ref,
-    disabled: disabled
-  }, props), React__namespace.default.createElement(StyledItemIcon, {
+  const renderActionIcon = iconType => {
+    switch (iconType) {
+      case 'add':
+        return React__namespace.default.createElement(SvgPlusStroke, null);
+      case 'next':
+        return React__namespace.default.createElement(SvgChevronRightStroke, null);
+      case 'previous':
+        return React__namespace.default.createElement(SvgChevronLeftStroke, null);
+      default:
+        return React__namespace.default.createElement(SvgCheckLgStroke, null);
+    }
+  };
+  const contextValue = React.useMemo(() => ({
+    isDisabled
+  }), [isDisabled]);
+  return React__namespace.default.createElement(ItemContext.Provider, {
+    value: contextValue
+  }, React__namespace.default.createElement(StyledItem, Object.assign({
+    $type: type,
     isCompact: isCompact,
-    isDisabled: disabled,
-    isVisible: true
-  }, React__namespace.default.createElement(StyledPreviousIcon, {
-    isDisabled: disabled
-  })), children);
+    isActive: isActive
+  }, props, itemProps, {
+    ref: reactMergeRefs.mergeRefs([_itemRef, ref])
+  }), React__namespace.default.createElement(StyledItemTypeIcon, {
+    $isCompact: isCompact,
+    $type: type
+  }, renderActionIcon(type)), icon && React__namespace.default.createElement(StyledItemIcon, null, icon), React__namespace.default.createElement(StyledItemContent, null, children || label)));
 });
-const PreviousItem = React__namespace.default.forwardRef((_ref2, ref) => {
+ItemComponent.displayName = 'Item';
+ItemComponent.propTypes = {
+  icon: PropTypes__default.default.any,
+  isDisabled: PropTypes__default.default.bool,
+  isSelected: PropTypes__default.default.bool,
+  label: PropTypes__default.default.string,
+  name: PropTypes__default.default.string,
+  type: PropTypes__default.default.oneOf(OPTION_TYPE),
+  value: PropTypes__default.default.string.isRequired
+};
+const Item = ItemComponent;
+Item.Meta = ItemMeta;
+
+const Separator = React.forwardRef(
+(_ref, ref) => {
   let {
-    value,
-    disabled,
+    children,
     ...props
-  } = _ref2;
-  const {
-    previousIndexRef
-  } = useDropdownContext();
+  } = _ref;
   const {
-    itemIndexRef
+    getSeparatorProps
   } = useMenuContext();
-  if (!disabled) {
-    previousIndexRef.current = itemIndexRef.current;
-  }
-  return React__namespace.default.createElement(Item, _extends$5({
-    component: PreviousItemComponent,
-    "aria-expanded": true,
-    value: value,
-    disabled: disabled
-  }, props, {
-    ref: ref,
-    hasIcon: true
+  const separatorProps = getSeparatorProps();
+  return React__namespace.default.createElement(StyledSeparator, Object.assign({}, props, separatorProps, {
+    ref: ref
   }));
 });
-PreviousItem.displayName = 'PreviousItem';
-PreviousItem.propTypes = {
-  value: PropTypes__default.default.any,
-  disabled: PropTypes__default.default.bool
-};
+Separator.displayName = 'Separator';
 
-Object.defineProperty(exports, "resetIdCounter", {
+Object.defineProperty(exports, "VALIDATION", {
   enumerable: true,
-  get: function () { return Downshift.resetIdCounter; }
+  get: function () { return reactForms.VALIDATION; }
 });
-exports.AddItem = AddItem;
-exports.Autocomplete = Autocomplete;
 exports.Combobox = Combobox;
-exports.Dropdown = Dropdown;
 exports.Field = Field;
-exports.HeaderIcon = HeaderIcon;
-exports.HeaderItem = HeaderItem;
 exports.Hint = Hint;
 exports.Item = Item;
-exports.ItemMeta = ItemMeta;
+exports.ItemGroup = ItemGroup;
 exports.Label = Label;
-exports.MediaBody = MediaBody;
-exports.MediaFigure = MediaFigure;
-exports.MediaItem = MediaItem;
 exports.Menu = Menu;
 exports.Message = Message;
-exports.Multiselect = Multiselect;
-exports.NextItem = NextItem;
-exports.PreviousItem = PreviousItem;
-exports.Select = Select;
+exports.OptGroup = OptGroup;
+exports.Option = Option;
 exports.Separator = Separator;
-exports.Trigger = Trigger;
+exports.Tag = Tag;