{"version":3,"sources":["webpack:////build/gitlab/src/gitlab-foss/node_modules/@gitlab/ui/dist/components/shared_components/clear_icon_button/clear_icon_button.js","webpack:////build/gitlab/src/gitlab-foss/node_modules/lodash/clamp.js","webpack:///./super_sidebar/constants.js","webpack:////build/gitlab/src/gitlab-foss/node_modules/lodash/_baseClamp.js","webpack:////build/gitlab/src/gitlab-foss/node_modules/@gitlab/ui/dist/directives/outside/outside.js","webpack:////build/gitlab/src/gitlab-foss/node_modules/@gitlab/ui/dist/components/base/new_dropdowns/constants.js","webpack:////build/gitlab/src/gitlab-foss/node_modules/@floating-ui/dom/dist/floating-ui.dom.esm.js","webpack:////build/gitlab/src/gitlab-foss/node_modules/@floating-ui/utils/dist/floating-ui.utils.esm.js","webpack:///./super_sidebar/super_sidebar_collapsed_state_manager.js","webpack:////build/gitlab/src/gitlab-foss/node_modules/@gitlab/ui/dist/components/base/search_box_by_type/search_box_by_type.js","webpack:////build/gitlab/src/gitlab-foss/node_modules/@gitlab/ui/dist/components/base/new_dropdowns/base_dropdown/base_dropdown.js","webpack:////build/gitlab/src/gitlab-foss/node_modules/@gitlab/ui/dist/components/base/new_dropdowns/base_dropdown/constants.js","webpack:////build/gitlab/src/gitlab-foss/node_modules/@floating-ui/core/dist/floating-ui.core.esm.js"],"names":["__vue_script__","name","components","GlButton","directives","GlTooltip","props","title","type","String","required","default","tooltipContainer","validator","value","HTMLElement","__vue_component__","render","_h","this","$createElement","_self","_c","_g","rawName","container","expression","modifiers","staticClass","attrs","$listeners","staticRenderFns","undefined","baseClamp","toNumber","module","exports","number","lower","upper","SIDEBAR_PORTAL_ID","JS_TOGGLE_COLLAPSE_CLASS","JS_TOGGLE_EXPAND_CLASS","portalState","Vue","observable","ready","sidebarState","isCollapsed","hasPeeked","isPeek","isPeekable","isHoverPeek","wasHoverPeek","duoChatGlobalState","commands","isShown","SUPER_SIDEBAR_PEEK_OPEN_DELAY","SUPER_SIDEBAR_PEEK_CLOSE_DELAY","SUPER_SIDEBAR_PEEK_STATE_CLOSED","SUPER_SIDEBAR_PEEK_STATE_WILL_OPEN","SUPER_SIDEBAR_PEEK_STATE_OPEN","SUPER_SIDEBAR_PEEK_STATE_WILL_CLOSE","TRACKING_UNKNOWN_ID","TRACKING_UNKNOWN_PANEL","CLICK_MENU_ITEM_ACTION","CLICK_PINNED_MENU_ITEM_ACTION","PANELS_WITH_PINS","USER_MENU_TRACKING_DEFAULTS","HELP_MENU_TRACKING_DEFAULTS","SIDEBAR_PINS_EXPANDED_COOKIE","SIDEBAR_COOKIE_EXPIRATION","PINNED_NAV_STORAGE_KEY","DROPDOWN_Y_OFFSET","NAV_ITEM_LINK_ACTIVE_CLASS","IMPERSONATING_OFFSET","FREQUENT_ITEMS","MAX_COUNT","ELIGIBLE_FREQUENCY","FIFTEEN_MINUTES_IN_MS","STORAGE_KEY","projects","CONTEXT_NAMESPACE_GROUPS","callbacks","Map","activeEventTypes","Set","lastMousedown","globalListener","event","forEach","_ref","element","callback","eventTypes","originalEvent","contains","target","includes","e","onMousedown","OutsideDirective","bind","el","bindings","_ref3","arg","modifiersList","Object","keys","length","parseBinding","has","set","eventType","document","addEventListener","capture","add","startListening","unbind","entry","get","eventTypesToUnbind","delete","values","every","_ref2","removeEventListener","GL_DROPDOWN_SHOWN","GL_DROPDOWN_HIDDEN","GL_DROPDOWN_BEFORE_CLOSE","GL_DROPDOWN_FOCUS_CONTENT","ARROW_DOWN","ARROW_UP","END","ENTER","HOME","SPACE","POSITION_ABSOLUTE","POSITION_FIXED","GL_DROPDOWN_CONTENTS_CLASS","getWindow","node","_node$ownerDocument","ownerDocument","defaultView","window","getComputedStyle$1","getComputedStyle","isNode","Node","getNodeName","nodeName","toLowerCase","isHTMLElement","isElement","Element","isShadowRoot","ShadowRoot","isOverflowElement","overflow","overflowX","overflowY","display","test","isTableElement","isContainingBlock","safari","isSafari","css","transform","perspective","containerType","backdropFilter","filter","some","willChange","contain","CSS","supports","isLastTraversableNode","min","Math","max","round","floor","createEmptyCoords","v","x","y","getCssDimensions","width","parseFloat","height","hasOffset","offsetWidth","offsetHeight","shouldFallback","$","unwrapElement","contextElement","getScale","domElement","rect","getBoundingClientRect","Number","isFinite","noOffsets","getVisualOffsets","isFixed","floatingOffsetParent","_win$visualViewport","_win$visualViewport2","win","visualViewport","offsetLeft","offsetTop","includeScale","isFixedStrategy","offsetParent","clientRect","scale","visualOffsets","left","top","offsetWin","currentIFrame","frameElement","iframeScale","iframeRect","clientLeft","paddingLeft","clientTop","paddingTop","getDocumentElement","documentElement","getNodeScroll","scrollLeft","scrollTop","pageXOffset","pageYOffset","getWindowScrollBarX","getParentNode","result","assignedSlot","parentNode","host","getOverflowAncestors","list","scrollableAncestor","getNearestOverflowAncestor","body","isBody","concat","getClientRectFromClippingAncestor","clippingAncestor","strategy","html","clientWidth","clientHeight","visualViewportBased","getViewportRect","scroll","scrollWidth","scrollHeight","direction","getDocumentRect","getInnerBoundingClientRect","hasFixedPositionAncestor","stopNode","position","getTrueOffsetParent","polyfill","getOffsetParent","currentNode","getContainingBlock","getRectRelativeToOffsetParent","isOffsetParentAnElement","offsets","offsetRect","platform","getClippingRect","boundary","rootBoundary","clippingAncestors","cache","cachedResult","currentContainingBlockComputedStyle","elementIsFixed","computedStyle","currentNodeIsContaining","ancestor","getClippingElementAncestors","firstClippingAncestor","clippingRect","reduce","accRect","right","bottom","convertOffsetParentRelativeRectToViewportRelativeRect","getDimensions","reference","floating","getOffsetParentFn","getDimensionsFn","getClientRects","Array","from","isRTL","autoUpdate","update","options","ancestorScroll","ancestorResize","elementResize","ResizeObserver","layoutShift","IntersectionObserver","animationFrame","referenceEl","ancestors","passive","cleanupIo","onMove","timeoutId","io","root","cleanup","clearTimeout","disconnect","refresh","skip","threshold","rootMargin","isFirstUpdate","handleObserve","entries","ratio","intersectionRatio","setTimeout","observe","observeMove","frameId","reobserveFrame","resizeObserver","firstEntry","unobserve","cancelAnimationFrame","requestAnimationFrame","prevRefRect","frameLoop","nextRefRect","computePosition","mergedOptions","platformWithCache","sides","alignments","placements","acc","side","oppositeSideMap","oppositeAlignmentMap","start","end","clamp","evaluate","param","getSide","placement","split","getAlignment","getOppositeAxis","axis","getAxisLength","getSideAxis","getAlignmentAxis","getAlignmentSides","rects","rtl","alignment","alignmentAxis","mainAlignmentSide","getOppositePlacement","getExpandedPlacements","oppositePlacement","getOppositeAlignmentPlacement","replace","getOppositeAxisPlacements","flipAlignment","isStart","lr","rl","tb","bt","getSideList","map","getPaddingObject","padding","expandPaddingObject","rectToClientRect","findPage","querySelector","classList","isDesktopBreakpoint","bp","windowWidth","breakpoints","xl","toggleSuperSidebarCollapsed","collapsed","saveCookie","toggle","setCookie","expires","initSuperSidebarCollapsedState","forceDesktopExpandedSidebar","getCookie","bindSuperSidebarCollapsedEvents","previousWindowWidth","innerWidth","_debounce","newWindowWidth","collapsedBeforeResize","collapsedAfterResize","Tracking","label","property","GlClearIconButton","GlIcon","GlFormInput","GlLoadingIcon","inheritAttrs","model","prop","borderless","Boolean","clearButtonTitle","disabled","isLoading","computed","attributes","placeholder","$attrs","input","onInput","focusin","onFocusin","focusout","onFocusout","hasValue","methods","_this$$refs$input","_this$$refs$clearButt","$refs","$el","clearButton","focusInput","focus","$emit","relatedTarget","isInputOrClearButton","_vm","_v","_b","ref","class","inputAttributes","inputListeners","showClearButton","_e","on","$event","stopPropagation","clearInput","apply","arguments","BASE_DROPDOWN_CLASS","Outside","toggleText","textSrOnly","block","category","primary","variant","size","icon","loading","toggleClass","noCaret","ariaHaspopup","toggleId","ariaLabelledby","offset","mainAxis","fluidWidth","positioningStrategy","data","openedYet","visible","baseDropdownId","_this$toggleText","hasNoVisibleToggleText","isIconOnly","toggleLabelledBy","isEllipsisButton","isCaretOnly","$scopedSlots","isDefaultToggle","is","buttonTextClasses","toggleButtonTextClasses","toggleButtonClasses","ariaAttributes","listeners","keydown","onKeydown","click","toggleOptions","_this$$refs$toggle","firstElementChild","middleware","allowedPlacements","dropdownArrow","_this$nonScrollableCo","availableHeight","elements","contentsEl","contentsAvailableHeight","nonScrollableContentHeight","assign","style","maxHeight","watch","deep","key","toggleElement","setAttribute","checkToggleFocusable","stopFloating","actualPlacement","offsetConfigs","staticSide","rotation","calculateNonScrollableAreaHeight","observer","MutationObserver","content","childList","subtree","stopAutoUpdate","async","floatingUIConfig","middlewareData","getArrowOffsets","arrow","arrowX","arrowY","toggleRect","contentRect","clampedArrowX","_this$observer","_this$stopAutoUpdate","call","prevented","$nextTick","startFloating","hadFocusWithin","activeElement","hasToggled","focusToggle","code","tagName","toggleOnEnter","toggleOnSpace","_this$$refs$content","scrollableArea","floatingElementBoundingBox","scrollableAreaBoundingBox","$options","toggleComponent","tag","indexOf","_k","keyCode","preventDefault","close","toggleAttributes","toggleListeners","_t","_s","panelClasses","closeAndFocus","computeCoordsFromPlacement","sideAxis","alignLength","isVertical","commonX","commonY","commonAlign","coords","config","validMiddleware","getElementRects","statefulPlacement","resetCount","i","fn","nextX","nextY","reset","initialPlacement","detectOverflow","state","_await$platform$isEle","elementContext","altBoundary","paddingObject","clippingClientRect","offsetScale","elementClientRect","arrowDimensions","isYAxis","minProp","maxProp","clientProp","endDiff","startDiff","arrowOffsetParent","clientSize","centerToReference","largestPossiblePadding","minPadding","maxPadding","min$1","center","shouldAddOffset","alignmentOffset","centerOffset","autoPlacement","_middlewareData$autoP","_middlewareData$autoP2","_placementsThatFitOnE","crossAxis","autoAlignment","detectOverflowOptions","placements$1","getPlacementList","currentIndex","index","currentPlacement","alignmentSides","currentOverflows","allOverflows","overflows","nextPlacement","placementsSortedByMostSpace","d","slice","sort","a","b","resetPlacement","flip","_middlewareData$arrow","_middlewareData$flip","checkMainAxis","checkCrossAxis","fallbackPlacements","specifiedFallbackPlacements","fallbackStrategy","fallbackAxisSideDirection","initialSideAxis","isBasePlacement","hasFallbackAxisSideDirection","push","overflowsData","_middlewareData$flip2","_overflowsData$filter","nextIndex","_overflowsData$filter2","currentSideAxis","getSideOffsets","isAnySideFullyClipped","hide","referenceHiddenOffsets","referenceHidden","escapedOffsets","escaped","getBoundingRect","minX","minY","inline","nativeClientRects","clientRects","sortedRects","groups","prevRect","getRectsByLine","fallback","resetRects","find","firstRect","lastRect","isTop","isLeftSide","maxRight","minLeft","measureRects","_middlewareData$offse","diffCoords","mainAxisMulti","crossAxisMulti","rawValue","convertValueToCoords","shift","limiter","mainAxisCoord","crossAxisCoord","maxSide","limitedCoords","enabled","limitShift","rawOffset","computedOffset","len","limitMin","limitMax","_middlewareData$offse2","isOriginSide","_state$middlewareData","_state$middlewareData2","heightSide","widthSide","maximumClippingHeight","maximumClippingWidth","overflowAvailableHeight","overflowAvailableWidth","noShift","availableWidth","xMin","xMax","yMin","yMax","nextDimensions"],"mappings":"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","file":"commons-pages.groups.new-pages.import.gitlab_projects.new-pages.import.manifest.new-pages.projects.n-a0973272.dc791a28.chunk.js","sourcesContent":["import { GlTooltipDirective } from '../../../directives/tooltip';\nimport GlButton from '../../base/button/button';\nimport { translate } from '../../../utils/i18n';\nimport __vue_normalize__ from 'vue-runtime-helpers/dist/normalize-component.js';\n\nvar script = {\n  name: 'ClearIconButton',\n  components: {\n    GlButton\n  },\n  directives: {\n    GlTooltip: GlTooltipDirective\n  },\n  props: {\n    title: {\n      type: String,\n      required: false,\n      default: () => translate('ClearIconButton.title', 'Clear')\n    },\n    tooltipContainer: {\n      required: false,\n      default: false,\n      validator: value => value === false || typeof value === 'string' || value instanceof HTMLElement\n    }\n  }\n};\n\n/* script */\nconst __vue_script__ = script;\n\n/* template */\nvar __vue_render__ = function () {var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;return _c('gl-button',_vm._g({directives:[{name:\"gl-tooltip\",rawName:\"v-gl-tooltip.hover\",value:({ container: _vm.tooltipContainer }),expression:\"{ container: tooltipContainer }\",modifiers:{\"hover\":true}}],staticClass:\"gl-clear-icon-button\",attrs:{\"variant\":\"default\",\"category\":\"tertiary\",\"size\":\"small\",\"name\":\"clear\",\"icon\":\"clear\",\"title\":_vm.title,\"aria-label\":_vm.title}},_vm.$listeners))};\nvar __vue_staticRenderFns__ = [];\n\n  /* style */\n  const __vue_inject_styles__ = undefined;\n  /* scoped */\n  const __vue_scope_id__ = undefined;\n  /* module identifier */\n  const __vue_module_identifier__ = undefined;\n  /* functional template */\n  const __vue_is_functional_template__ = false;\n  /* style inject */\n  \n  /* style inject SSR */\n  \n  /* style inject shadow dom */\n  \n\n  \n  const __vue_component__ = __vue_normalize__(\n    { render: __vue_render__, staticRenderFns: __vue_staticRenderFns__ },\n    __vue_inject_styles__,\n    __vue_script__,\n    __vue_scope_id__,\n    __vue_is_functional_template__,\n    __vue_module_identifier__,\n    false,\n    undefined,\n    undefined,\n    undefined\n  );\n\nexport default __vue_component__;\n","var baseClamp = require('./_baseClamp'),\n    toNumber = require('./toNumber');\n\n/**\n * Clamps `number` within the inclusive `lower` and `upper` bounds.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Number\n * @param {number} number The number to clamp.\n * @param {number} [lower] The lower bound.\n * @param {number} upper The upper bound.\n * @returns {number} Returns the clamped number.\n * @example\n *\n * _.clamp(-10, -5, 5);\n * // => -5\n *\n * _.clamp(10, -5, 5);\n * // => 5\n */\nfunction clamp(number, lower, upper) {\n  if (upper === undefined) {\n    upper = lower;\n    lower = undefined;\n  }\n  if (upper !== undefined) {\n    upper = toNumber(upper);\n    upper = upper === upper ? upper : 0;\n  }\n  if (lower !== undefined) {\n    lower = toNumber(lower);\n    lower = lower === lower ? lower : 0;\n  }\n  return baseClamp(toNumber(number), lower, upper);\n}\n\nmodule.exports = clamp;\n","// Note: all constants defined here are considered internal implementation\n// details for the sidebar. They should not be imported by anything outside of\n// the super_sidebar directory.\n\nimport Vue from 'vue';\n\nexport const SIDEBAR_PORTAL_ID = 'sidebar-portal-mount';\nexport const JS_TOGGLE_COLLAPSE_CLASS = 'js-super-sidebar-toggle-collapse';\nexport const JS_TOGGLE_EXPAND_CLASS = 'js-super-sidebar-toggle-expand';\n\nexport const portalState = Vue.observable({\n  ready: false,\n});\n\nexport const sidebarState = Vue.observable({\n  isCollapsed: false,\n  hasPeeked: false,\n  isPeek: false,\n  isPeekable: false,\n  isHoverPeek: false,\n  wasHoverPeek: false,\n});\n\nexport const duoChatGlobalState = Vue.observable({\n  commands: [],\n  isShown: false,\n});\n\nexport const SUPER_SIDEBAR_PEEK_OPEN_DELAY = 200;\nexport const SUPER_SIDEBAR_PEEK_CLOSE_DELAY = 500;\nexport const SUPER_SIDEBAR_PEEK_STATE_CLOSED = 'closed';\nexport const SUPER_SIDEBAR_PEEK_STATE_WILL_OPEN = 'will-open';\nexport const SUPER_SIDEBAR_PEEK_STATE_OPEN = 'open';\nexport const SUPER_SIDEBAR_PEEK_STATE_WILL_CLOSE = 'will-close';\n\nexport const TRACKING_UNKNOWN_ID = 'item_without_id';\nexport const TRACKING_UNKNOWN_PANEL = 'nav_panel_unknown';\nexport const CLICK_MENU_ITEM_ACTION = 'click_menu_item';\nexport const CLICK_PINNED_MENU_ITEM_ACTION = 'click_pinned_menu_item';\n\nexport const PANELS_WITH_PINS = ['group', 'project', 'organization'];\n\nexport const USER_MENU_TRACKING_DEFAULTS = {\n  'data-track-property': 'nav_user_menu',\n  'data-track-action': 'click_link',\n};\n\nexport const HELP_MENU_TRACKING_DEFAULTS = {\n  'data-track-property': 'nav_help_menu',\n  'data-track-action': 'click_link',\n};\n\nexport const SIDEBAR_PINS_EXPANDED_COOKIE = 'sidebar_pinned_section_expanded';\nexport const SIDEBAR_COOKIE_EXPIRATION = 365 * 10;\n\nexport const PINNED_NAV_STORAGE_KEY = 'super-sidebar-pinned-nav-item-clicked';\n\nexport const DROPDOWN_Y_OFFSET = 4;\n\nexport const NAV_ITEM_LINK_ACTIVE_CLASS = 'super-sidebar-nav-item-current';\n\nexport const IMPERSONATING_OFFSET = 34;\n\n// Frequent items constants\nexport const FREQUENT_ITEMS = {\n  MAX_COUNT: 20,\n  ELIGIBLE_FREQUENCY: 3,\n};\n\nexport const FIFTEEN_MINUTES_IN_MS = 900000;\n\nexport const STORAGE_KEY = {\n  projects: 'frequent-projects',\n};\n\nexport const CONTEXT_NAMESPACE_GROUPS = 'groups';\n","/**\n * The base implementation of `_.clamp` which doesn't coerce arguments.\n *\n * @private\n * @param {number} number The number to clamp.\n * @param {number} [lower] The lower bound.\n * @param {number} upper The upper bound.\n * @returns {number} Returns the clamped number.\n */\nfunction baseClamp(number, lower, upper) {\n  if (number === number) {\n    if (upper !== undefined) {\n      number = number <= upper ? number : upper;\n    }\n    if (lower !== undefined) {\n      number = number >= lower ? number : lower;\n    }\n  }\n  return number;\n}\n\nmodule.exports = baseClamp;\n","/**\n * Map<HTMLElement, { callback: Function, eventTypes: Array<string> }>\n */\nconst callbacks = new Map();\nconst click = 'click';\nconst focusin = 'focusin';\nconst supportedEventTypes = [click, focusin];\nconst defaultEventType = click;\n\n/**\n * A Set to keep track of currently active event types.\n * This ensures that event listeners are only added for the event types that are in use.\n *\n * @type {Set<string>}\n */\nconst activeEventTypes = new Set();\nlet lastMousedown = null;\nconst globalListener = event => {\n  callbacks.forEach((_ref, element) => {\n    let {\n      callback,\n      eventTypes\n    } = _ref;\n    const originalEvent = event.type === click ? lastMousedown || event : event;\n    if (\n    // Ignore events that aren't targeted outside the element\n    element.contains(originalEvent.target) ||\n    // Ignore events that aren't the specified types for this element\n    !eventTypes.includes(event.type)) {\n      return;\n    }\n    try {\n      callback(event);\n    } catch (e) {\n      if (process.env.NODE_ENV !== 'production') {\n        // eslint-disable-next-line no-console\n        console.error(e);\n      }\n    }\n  });\n  if (event.type === click) {\n    lastMousedown = null;\n  }\n};\n\n// We need to listen for mouse events because text selection fires click event only when selection ends.\n// This means that the click event target could differ from the element where it originally started.\n// As example: if we use mouse events we could guarantee that selecting text within a dropdown won't close it.\nconst onMousedown = event => {\n  lastMousedown = event;\n};\nconst startListening = eventTypes => {\n  eventTypes.forEach(eventType => {\n    if (!activeEventTypes.has(eventType)) {\n      // Listening to mousedown events, ensures that a text selection doesn't trigger the\n      // GlOutsideDirective 'click' callback if the selection started within the target element.\n      if (eventType === click) {\n        document.addEventListener('mousedown', onMousedown);\n      }\n\n      // Added { capture: true } to all event types to prevent the behavior discussed in https://gitlab.com/gitlab-org/gitlab-ui/-/merge_requests/1686#note_412545027\n      // Ensures the event listener handles the event in the capturing phase, avoiding issues encountered previously.\n      // Cannot be tested with Jest or Cypress, but can be tested with Playwright in the future: https://gitlab.com/gitlab-org/gitlab-ui/-/merge_requests/4272#note_1947425384\n      document.addEventListener(eventType, globalListener, {\n        capture: true\n      });\n      activeEventTypes.add(eventType);\n    }\n  });\n  lastMousedown = null;\n};\nconst stopListening = eventTypesToUnbind => {\n  eventTypesToUnbind.forEach(eventType => {\n    if (activeEventTypes.has(eventType)) {\n      if ([...callbacks.values()].every(_ref2 => {\n        let {\n          eventTypes\n        } = _ref2;\n        return !eventTypes.includes(eventType);\n      })) {\n        document.removeEventListener(eventType, globalListener);\n        activeEventTypes.delete(eventType);\n      }\n    }\n  });\n  if (eventTypesToUnbind.includes(click) && !activeEventTypes.has(click)) {\n    document.removeEventListener('mousedown', onMousedown);\n  }\n};\nfunction parseBinding(_ref3) {\n  let {\n    arg,\n    value,\n    modifiers\n  } = _ref3;\n  const modifiersList = Object.keys(modifiers);\n  if (process.env.NODE_ENV !== 'production') {\n    if (typeof value !== 'function') {\n      throw new Error(`[GlOutsideDirective] Value must be a function; got ${typeof value}!`);\n    }\n    if (typeof arg !== 'undefined') {\n      throw new Error(`[GlOutsideDirective] Arguments are not supported. Consider using modifiers instead.`);\n    }\n    const unsupportedModifiers = modifiersList.filter(modifier => !supportedEventTypes.includes(modifier));\n    if (unsupportedModifiers.length > 0) {\n      throw new Error(`[GlOutsideDirective] Cannot bind ${unsupportedModifiers.join(', ')} events; supported event types are: ${supportedEventTypes.join(', ')}`);\n    }\n  }\n  return {\n    callback: value,\n    eventTypes: modifiersList.length > 0 ? modifiersList : [defaultEventType]\n  };\n}\nconst bind = (el, bindings) => {\n  const {\n    callback,\n    eventTypes\n  } = parseBinding(bindings);\n  if (callbacks.has(el)) {\n    // This element is already bound. This is possible if two components, which\n    // share the same root node, (i.e., one is a higher-order component\n    // wrapping another) _both_ have this directive applied.\n    //\n    // Because Vue binds directives in the direction towards the root, only the\n    // deepest instance of this directive will be bound.\n    //\n    // A future iteration may add support for binding all instances on a given\n    // element.\n    return;\n  }\n  callbacks.set(el, {\n    callback,\n    eventTypes\n  });\n  startListening(eventTypes);\n};\nconst unbind = el => {\n  const entry = callbacks.get(el);\n  if (entry) {\n    callbacks.delete(el);\n    stopListening(entry.eventTypes);\n  }\n};\nconst OutsideDirective = {\n  bind,\n  unbind\n};\n\nexport { OutsideDirective };\n","// base dropdown events\nconst GL_DROPDOWN_SHOWN = 'shown';\nconst GL_DROPDOWN_HIDDEN = 'hidden';\nconst GL_DROPDOWN_BEFORE_CLOSE = 'beforeClose';\nconst GL_DROPDOWN_FOCUS_CONTENT = 'focusContent';\n\n// KEY Codes\nconst ARROW_DOWN = 'ArrowDown';\nconst ARROW_UP = 'ArrowUp';\nconst END = 'End';\nconst ENTER = 'Enter';\nconst HOME = 'Home';\nconst SPACE = 'Space';\n\n// Positioning strategies\n// https://floating-ui.com/docs/computePosition#strategy\nconst POSITION_ABSOLUTE = 'absolute';\nconst POSITION_FIXED = 'fixed';\nconst GL_DROPDOWN_CONTENTS_CLASS = 'gl-new-dropdown-contents';\n\nexport { ARROW_DOWN, ARROW_UP, END, ENTER, GL_DROPDOWN_BEFORE_CLOSE, GL_DROPDOWN_CONTENTS_CLASS, GL_DROPDOWN_FOCUS_CONTENT, GL_DROPDOWN_HIDDEN, GL_DROPDOWN_SHOWN, HOME, POSITION_ABSOLUTE, POSITION_FIXED, SPACE };\n","import { rectToClientRect, computePosition as computePosition$1 } from '@floating-ui/core';\nexport { arrow, autoPlacement, detectOverflow, flip, hide, inline, limitShift, offset, shift, size } from '@floating-ui/core';\n\nfunction getWindow(node) {\n  var _node$ownerDocument;\n  return ((_node$ownerDocument = node.ownerDocument) == null ? void 0 : _node$ownerDocument.defaultView) || window;\n}\n\nfunction getComputedStyle$1(element) {\n  return getWindow(element).getComputedStyle(element);\n}\n\nfunction isNode(value) {\n  return value instanceof getWindow(value).Node;\n}\nfunction getNodeName(node) {\n  if (isNode(node)) {\n    return (node.nodeName || '').toLowerCase();\n  }\n  // Mocked nodes in testing environments may not be instances of Node. By\n  // returning `#document` an infinite loop won't occur.\n  // https://github.com/floating-ui/floating-ui/issues/2317\n  return '#document';\n}\n\nfunction isHTMLElement(value) {\n  return value instanceof getWindow(value).HTMLElement;\n}\nfunction isElement(value) {\n  return value instanceof getWindow(value).Element;\n}\nfunction isShadowRoot(node) {\n  // Browsers without `ShadowRoot` support.\n  if (typeof ShadowRoot === 'undefined') {\n    return false;\n  }\n  return node instanceof getWindow(node).ShadowRoot || node instanceof ShadowRoot;\n}\nfunction isOverflowElement(element) {\n  const {\n    overflow,\n    overflowX,\n    overflowY,\n    display\n  } = getComputedStyle$1(element);\n  return /auto|scroll|overlay|hidden|clip/.test(overflow + overflowY + overflowX) && !['inline', 'contents'].includes(display);\n}\nfunction isTableElement(element) {\n  return ['table', 'td', 'th'].includes(getNodeName(element));\n}\nfunction isContainingBlock(element) {\n  const safari = isSafari();\n  const css = getComputedStyle$1(element);\n\n  // https://developer.mozilla.org/en-US/docs/Web/CSS/Containing_block#identifying_the_containing_block\n  return css.transform !== 'none' || css.perspective !== 'none' || (css.containerType ? css.containerType !== 'normal' : false) || !safari && (css.backdropFilter ? css.backdropFilter !== 'none' : false) || !safari && (css.filter ? css.filter !== 'none' : false) || ['transform', 'perspective', 'filter'].some(value => (css.willChange || '').includes(value)) || ['paint', 'layout', 'strict', 'content'].some(value => (css.contain || '').includes(value));\n}\nfunction isSafari() {\n  if (typeof CSS === 'undefined' || !CSS.supports) return false;\n  return CSS.supports('-webkit-backdrop-filter', 'none');\n}\nfunction isLastTraversableNode(node) {\n  return ['html', 'body', '#document'].includes(getNodeName(node));\n}\n\nconst min = Math.min;\nconst max = Math.max;\nconst round = Math.round;\nconst floor = Math.floor;\nconst createEmptyCoords = v => ({\n  x: v,\n  y: v\n});\n\nfunction getCssDimensions(element) {\n  const css = getComputedStyle$1(element);\n  // In testing environments, the `width` and `height` properties are empty\n  // strings for SVG elements, returning NaN. Fallback to `0` in this case.\n  let width = parseFloat(css.width) || 0;\n  let height = parseFloat(css.height) || 0;\n  const hasOffset = isHTMLElement(element);\n  const offsetWidth = hasOffset ? element.offsetWidth : width;\n  const offsetHeight = hasOffset ? element.offsetHeight : height;\n  const shouldFallback = round(width) !== offsetWidth || round(height) !== offsetHeight;\n  if (shouldFallback) {\n    width = offsetWidth;\n    height = offsetHeight;\n  }\n  return {\n    width,\n    height,\n    $: shouldFallback\n  };\n}\n\nfunction unwrapElement(element) {\n  return !isElement(element) ? element.contextElement : element;\n}\n\nfunction getScale(element) {\n  const domElement = unwrapElement(element);\n  if (!isHTMLElement(domElement)) {\n    return createEmptyCoords(1);\n  }\n  const rect = domElement.getBoundingClientRect();\n  const {\n    width,\n    height,\n    $\n  } = getCssDimensions(domElement);\n  let x = ($ ? round(rect.width) : rect.width) / width;\n  let y = ($ ? round(rect.height) : rect.height) / height;\n\n  // 0, NaN, or Infinity should always fallback to 1.\n\n  if (!x || !Number.isFinite(x)) {\n    x = 1;\n  }\n  if (!y || !Number.isFinite(y)) {\n    y = 1;\n  }\n  return {\n    x,\n    y\n  };\n}\n\nconst noOffsets = /*#__PURE__*/createEmptyCoords(0);\nfunction getVisualOffsets(element, isFixed, floatingOffsetParent) {\n  var _win$visualViewport, _win$visualViewport2;\n  if (isFixed === void 0) {\n    isFixed = true;\n  }\n  if (!isSafari()) {\n    return noOffsets;\n  }\n  const win = element ? getWindow(element) : window;\n  if (!floatingOffsetParent || isFixed && floatingOffsetParent !== win) {\n    return noOffsets;\n  }\n  return {\n    x: ((_win$visualViewport = win.visualViewport) == null ? void 0 : _win$visualViewport.offsetLeft) || 0,\n    y: ((_win$visualViewport2 = win.visualViewport) == null ? void 0 : _win$visualViewport2.offsetTop) || 0\n  };\n}\n\nfunction getBoundingClientRect(element, includeScale, isFixedStrategy, offsetParent) {\n  if (includeScale === void 0) {\n    includeScale = false;\n  }\n  if (isFixedStrategy === void 0) {\n    isFixedStrategy = false;\n  }\n  const clientRect = element.getBoundingClientRect();\n  const domElement = unwrapElement(element);\n  let scale = createEmptyCoords(1);\n  if (includeScale) {\n    if (offsetParent) {\n      if (isElement(offsetParent)) {\n        scale = getScale(offsetParent);\n      }\n    } else {\n      scale = getScale(element);\n    }\n  }\n  const visualOffsets = getVisualOffsets(domElement, isFixedStrategy, offsetParent);\n  let x = (clientRect.left + visualOffsets.x) / scale.x;\n  let y = (clientRect.top + visualOffsets.y) / scale.y;\n  let width = clientRect.width / scale.x;\n  let height = clientRect.height / scale.y;\n  if (domElement) {\n    const win = getWindow(domElement);\n    const offsetWin = offsetParent && isElement(offsetParent) ? getWindow(offsetParent) : offsetParent;\n    let currentIFrame = win.frameElement;\n    while (currentIFrame && offsetParent && offsetWin !== win) {\n      const iframeScale = getScale(currentIFrame);\n      const iframeRect = currentIFrame.getBoundingClientRect();\n      const css = getComputedStyle(currentIFrame);\n      const left = iframeRect.left + (currentIFrame.clientLeft + parseFloat(css.paddingLeft)) * iframeScale.x;\n      const top = iframeRect.top + (currentIFrame.clientTop + parseFloat(css.paddingTop)) * iframeScale.y;\n      x *= iframeScale.x;\n      y *= iframeScale.y;\n      width *= iframeScale.x;\n      height *= iframeScale.y;\n      x += left;\n      y += top;\n      currentIFrame = getWindow(currentIFrame).frameElement;\n    }\n  }\n  return rectToClientRect({\n    width,\n    height,\n    x,\n    y\n  });\n}\n\nfunction getDocumentElement(node) {\n  return ((isNode(node) ? node.ownerDocument : node.document) || window.document).documentElement;\n}\n\nfunction getNodeScroll(element) {\n  if (isElement(element)) {\n    return {\n      scrollLeft: element.scrollLeft,\n      scrollTop: element.scrollTop\n    };\n  }\n  return {\n    scrollLeft: element.pageXOffset,\n    scrollTop: element.pageYOffset\n  };\n}\n\nfunction convertOffsetParentRelativeRectToViewportRelativeRect(_ref) {\n  let {\n    rect,\n    offsetParent,\n    strategy\n  } = _ref;\n  const isOffsetParentAnElement = isHTMLElement(offsetParent);\n  const documentElement = getDocumentElement(offsetParent);\n  if (offsetParent === documentElement) {\n    return rect;\n  }\n  let scroll = {\n    scrollLeft: 0,\n    scrollTop: 0\n  };\n  let scale = createEmptyCoords(1);\n  const offsets = createEmptyCoords(0);\n  if (isOffsetParentAnElement || !isOffsetParentAnElement && strategy !== 'fixed') {\n    if (getNodeName(offsetParent) !== 'body' || isOverflowElement(documentElement)) {\n      scroll = getNodeScroll(offsetParent);\n    }\n    if (isHTMLElement(offsetParent)) {\n      const offsetRect = getBoundingClientRect(offsetParent);\n      scale = getScale(offsetParent);\n      offsets.x = offsetRect.x + offsetParent.clientLeft;\n      offsets.y = offsetRect.y + offsetParent.clientTop;\n    }\n  }\n  return {\n    width: rect.width * scale.x,\n    height: rect.height * scale.y,\n    x: rect.x * scale.x - scroll.scrollLeft * scale.x + offsets.x,\n    y: rect.y * scale.y - scroll.scrollTop * scale.y + offsets.y\n  };\n}\n\nfunction getWindowScrollBarX(element) {\n  // If <html> has a CSS width greater than the viewport, then this will be\n  // incorrect for RTL.\n  return getBoundingClientRect(getDocumentElement(element)).left + getNodeScroll(element).scrollLeft;\n}\n\n// Gets the entire size of the scrollable document area, even extending outside\n// of the `<html>` and `<body>` rect bounds if horizontally scrollable.\nfunction getDocumentRect(element) {\n  const html = getDocumentElement(element);\n  const scroll = getNodeScroll(element);\n  const body = element.ownerDocument.body;\n  const width = max(html.scrollWidth, html.clientWidth, body.scrollWidth, body.clientWidth);\n  const height = max(html.scrollHeight, html.clientHeight, body.scrollHeight, body.clientHeight);\n  let x = -scroll.scrollLeft + getWindowScrollBarX(element);\n  const y = -scroll.scrollTop;\n  if (getComputedStyle$1(body).direction === 'rtl') {\n    x += max(html.clientWidth, body.clientWidth) - width;\n  }\n  return {\n    width,\n    height,\n    x,\n    y\n  };\n}\n\nfunction getParentNode(node) {\n  if (getNodeName(node) === 'html') {\n    return node;\n  }\n  const result =\n  // Step into the shadow DOM of the parent of a slotted node.\n  node.assignedSlot ||\n  // DOM Element detected.\n  node.parentNode ||\n  // ShadowRoot detected.\n  isShadowRoot(node) && node.host ||\n  // Fallback.\n  getDocumentElement(node);\n  return isShadowRoot(result) ? result.host : result;\n}\n\nfunction getNearestOverflowAncestor(node) {\n  const parentNode = getParentNode(node);\n  if (isLastTraversableNode(parentNode)) {\n    return node.ownerDocument ? node.ownerDocument.body : node.body;\n  }\n  if (isHTMLElement(parentNode) && isOverflowElement(parentNode)) {\n    return parentNode;\n  }\n  return getNearestOverflowAncestor(parentNode);\n}\n\nfunction getOverflowAncestors(node, list) {\n  var _node$ownerDocument;\n  if (list === void 0) {\n    list = [];\n  }\n  const scrollableAncestor = getNearestOverflowAncestor(node);\n  const isBody = scrollableAncestor === ((_node$ownerDocument = node.ownerDocument) == null ? void 0 : _node$ownerDocument.body);\n  const win = getWindow(scrollableAncestor);\n  if (isBody) {\n    return list.concat(win, win.visualViewport || [], isOverflowElement(scrollableAncestor) ? scrollableAncestor : []);\n  }\n  return list.concat(scrollableAncestor, getOverflowAncestors(scrollableAncestor));\n}\n\nfunction getViewportRect(element, strategy) {\n  const win = getWindow(element);\n  const html = getDocumentElement(element);\n  const visualViewport = win.visualViewport;\n  let width = html.clientWidth;\n  let height = html.clientHeight;\n  let x = 0;\n  let y = 0;\n  if (visualViewport) {\n    width = visualViewport.width;\n    height = visualViewport.height;\n    const visualViewportBased = isSafari();\n    if (!visualViewportBased || visualViewportBased && strategy === 'fixed') {\n      x = visualViewport.offsetLeft;\n      y = visualViewport.offsetTop;\n    }\n  }\n  return {\n    width,\n    height,\n    x,\n    y\n  };\n}\n\n// Returns the inner client rect, subtracting scrollbars if present.\nfunction getInnerBoundingClientRect(element, strategy) {\n  const clientRect = getBoundingClientRect(element, true, strategy === 'fixed');\n  const top = clientRect.top + element.clientTop;\n  const left = clientRect.left + element.clientLeft;\n  const scale = isHTMLElement(element) ? getScale(element) : createEmptyCoords(1);\n  const width = element.clientWidth * scale.x;\n  const height = element.clientHeight * scale.y;\n  const x = left * scale.x;\n  const y = top * scale.y;\n  return {\n    width,\n    height,\n    x,\n    y\n  };\n}\nfunction getClientRectFromClippingAncestor(element, clippingAncestor, strategy) {\n  let rect;\n  if (clippingAncestor === 'viewport') {\n    rect = getViewportRect(element, strategy);\n  } else if (clippingAncestor === 'document') {\n    rect = getDocumentRect(getDocumentElement(element));\n  } else if (isElement(clippingAncestor)) {\n    rect = getInnerBoundingClientRect(clippingAncestor, strategy);\n  } else {\n    const visualOffsets = getVisualOffsets(element);\n    rect = {\n      ...clippingAncestor,\n      x: clippingAncestor.x - visualOffsets.x,\n      y: clippingAncestor.y - visualOffsets.y\n    };\n  }\n  return rectToClientRect(rect);\n}\nfunction hasFixedPositionAncestor(element, stopNode) {\n  const parentNode = getParentNode(element);\n  if (parentNode === stopNode || !isElement(parentNode) || isLastTraversableNode(parentNode)) {\n    return false;\n  }\n  return getComputedStyle$1(parentNode).position === 'fixed' || hasFixedPositionAncestor(parentNode, stopNode);\n}\n\n// A \"clipping ancestor\" is an `overflow` element with the characteristic of\n// clipping (or hiding) child elements. This returns all clipping ancestors\n// of the given element up the tree.\nfunction getClippingElementAncestors(element, cache) {\n  const cachedResult = cache.get(element);\n  if (cachedResult) {\n    return cachedResult;\n  }\n  let result = getOverflowAncestors(element).filter(el => isElement(el) && getNodeName(el) !== 'body');\n  let currentContainingBlockComputedStyle = null;\n  const elementIsFixed = getComputedStyle$1(element).position === 'fixed';\n  let currentNode = elementIsFixed ? getParentNode(element) : element;\n\n  // https://developer.mozilla.org/en-US/docs/Web/CSS/Containing_block#identifying_the_containing_block\n  while (isElement(currentNode) && !isLastTraversableNode(currentNode)) {\n    const computedStyle = getComputedStyle$1(currentNode);\n    const currentNodeIsContaining = isContainingBlock(currentNode);\n    if (!currentNodeIsContaining && computedStyle.position === 'fixed') {\n      currentContainingBlockComputedStyle = null;\n    }\n    const shouldDropCurrentNode = elementIsFixed ? !currentNodeIsContaining && !currentContainingBlockComputedStyle : !currentNodeIsContaining && computedStyle.position === 'static' && !!currentContainingBlockComputedStyle && ['absolute', 'fixed'].includes(currentContainingBlockComputedStyle.position) || isOverflowElement(currentNode) && !currentNodeIsContaining && hasFixedPositionAncestor(element, currentNode);\n    if (shouldDropCurrentNode) {\n      // Drop non-containing blocks.\n      result = result.filter(ancestor => ancestor !== currentNode);\n    } else {\n      // Record last containing block for next iteration.\n      currentContainingBlockComputedStyle = computedStyle;\n    }\n    currentNode = getParentNode(currentNode);\n  }\n  cache.set(element, result);\n  return result;\n}\n\n// Gets the maximum area that the element is visible in due to any number of\n// clipping ancestors.\nfunction getClippingRect(_ref) {\n  let {\n    element,\n    boundary,\n    rootBoundary,\n    strategy\n  } = _ref;\n  const elementClippingAncestors = boundary === 'clippingAncestors' ? getClippingElementAncestors(element, this._c) : [].concat(boundary);\n  const clippingAncestors = [...elementClippingAncestors, rootBoundary];\n  const firstClippingAncestor = clippingAncestors[0];\n  const clippingRect = clippingAncestors.reduce((accRect, clippingAncestor) => {\n    const rect = getClientRectFromClippingAncestor(element, clippingAncestor, strategy);\n    accRect.top = max(rect.top, accRect.top);\n    accRect.right = min(rect.right, accRect.right);\n    accRect.bottom = min(rect.bottom, accRect.bottom);\n    accRect.left = max(rect.left, accRect.left);\n    return accRect;\n  }, getClientRectFromClippingAncestor(element, firstClippingAncestor, strategy));\n  return {\n    width: clippingRect.right - clippingRect.left,\n    height: clippingRect.bottom - clippingRect.top,\n    x: clippingRect.left,\n    y: clippingRect.top\n  };\n}\n\nfunction getDimensions(element) {\n  return getCssDimensions(element);\n}\n\nfunction getTrueOffsetParent(element, polyfill) {\n  if (!isHTMLElement(element) || getComputedStyle$1(element).position === 'fixed') {\n    return null;\n  }\n  if (polyfill) {\n    return polyfill(element);\n  }\n  return element.offsetParent;\n}\nfunction getContainingBlock(element) {\n  let currentNode = getParentNode(element);\n  while (isHTMLElement(currentNode) && !isLastTraversableNode(currentNode)) {\n    if (isContainingBlock(currentNode)) {\n      return currentNode;\n    } else {\n      currentNode = getParentNode(currentNode);\n    }\n  }\n  return null;\n}\n\n// Gets the closest ancestor positioned element. Handles some edge cases,\n// such as table ancestors and cross browser bugs.\nfunction getOffsetParent(element, polyfill) {\n  const window = getWindow(element);\n  if (!isHTMLElement(element)) {\n    return window;\n  }\n  let offsetParent = getTrueOffsetParent(element, polyfill);\n  while (offsetParent && isTableElement(offsetParent) && getComputedStyle$1(offsetParent).position === 'static') {\n    offsetParent = getTrueOffsetParent(offsetParent, polyfill);\n  }\n  if (offsetParent && (getNodeName(offsetParent) === 'html' || getNodeName(offsetParent) === 'body' && getComputedStyle$1(offsetParent).position === 'static' && !isContainingBlock(offsetParent))) {\n    return window;\n  }\n  return offsetParent || getContainingBlock(element) || window;\n}\n\nfunction getRectRelativeToOffsetParent(element, offsetParent, strategy) {\n  const isOffsetParentAnElement = isHTMLElement(offsetParent);\n  const documentElement = getDocumentElement(offsetParent);\n  const isFixed = strategy === 'fixed';\n  const rect = getBoundingClientRect(element, true, isFixed, offsetParent);\n  let scroll = {\n    scrollLeft: 0,\n    scrollTop: 0\n  };\n  const offsets = createEmptyCoords(0);\n  if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) {\n    if (getNodeName(offsetParent) !== 'body' || isOverflowElement(documentElement)) {\n      scroll = getNodeScroll(offsetParent);\n    }\n    if (isHTMLElement(offsetParent)) {\n      const offsetRect = getBoundingClientRect(offsetParent, true, isFixed, offsetParent);\n      offsets.x = offsetRect.x + offsetParent.clientLeft;\n      offsets.y = offsetRect.y + offsetParent.clientTop;\n    } else if (documentElement) {\n      offsets.x = getWindowScrollBarX(documentElement);\n    }\n  }\n  return {\n    x: rect.left + scroll.scrollLeft - offsets.x,\n    y: rect.top + scroll.scrollTop - offsets.y,\n    width: rect.width,\n    height: rect.height\n  };\n}\n\nconst platform = {\n  getClippingRect,\n  convertOffsetParentRelativeRectToViewportRelativeRect,\n  isElement,\n  getDimensions,\n  getOffsetParent,\n  getDocumentElement,\n  getScale,\n  async getElementRects(_ref) {\n    let {\n      reference,\n      floating,\n      strategy\n    } = _ref;\n    const getOffsetParentFn = this.getOffsetParent || getOffsetParent;\n    const getDimensionsFn = this.getDimensions;\n    return {\n      reference: getRectRelativeToOffsetParent(reference, await getOffsetParentFn(floating), strategy),\n      floating: {\n        x: 0,\n        y: 0,\n        ...(await getDimensionsFn(floating))\n      }\n    };\n  },\n  getClientRects: element => Array.from(element.getClientRects()),\n  isRTL: element => getComputedStyle$1(element).direction === 'rtl'\n};\n\n// https://samthor.au/2021/observing-dom/\nfunction observeMove(element, onMove) {\n  let io = null;\n  let timeoutId;\n  const root = getDocumentElement(element);\n  function cleanup() {\n    clearTimeout(timeoutId);\n    io && io.disconnect();\n    io = null;\n  }\n  function refresh(skip, threshold) {\n    if (skip === void 0) {\n      skip = false;\n    }\n    if (threshold === void 0) {\n      threshold = 1;\n    }\n    cleanup();\n    const {\n      left,\n      top,\n      width,\n      height\n    } = element.getBoundingClientRect();\n    if (!skip) {\n      onMove();\n    }\n    if (!width || !height) {\n      return;\n    }\n    const insetTop = floor(top);\n    const insetRight = floor(root.clientWidth - (left + width));\n    const insetBottom = floor(root.clientHeight - (top + height));\n    const insetLeft = floor(left);\n    const rootMargin = -insetTop + \"px \" + -insetRight + \"px \" + -insetBottom + \"px \" + -insetLeft + \"px\";\n    const options = {\n      rootMargin,\n      threshold: max(0, min(1, threshold)) || 1\n    };\n    let isFirstUpdate = true;\n    function handleObserve(entries) {\n      const ratio = entries[0].intersectionRatio;\n      if (ratio !== threshold) {\n        if (!isFirstUpdate) {\n          return refresh();\n        }\n        if (!ratio) {\n          timeoutId = setTimeout(() => {\n            refresh(false, 1e-7);\n          }, 100);\n        } else {\n          refresh(false, ratio);\n        }\n      }\n      isFirstUpdate = false;\n    }\n\n    // Older browsers don't support a `document` as the root and will throw an\n    // error.\n    try {\n      io = new IntersectionObserver(handleObserve, {\n        ...options,\n        // Handle <iframe>s\n        root: root.ownerDocument\n      });\n    } catch (e) {\n      io = new IntersectionObserver(handleObserve, options);\n    }\n    io.observe(element);\n  }\n  refresh(true);\n  return cleanup;\n}\n\n/**\n * Automatically updates the position of the floating element when necessary.\n * Should only be called when the floating element is mounted on the DOM or\n * visible on the screen.\n * @returns cleanup function that should be invoked when the floating element is\n * removed from the DOM or hidden from the screen.\n * @see https://floating-ui.com/docs/autoUpdate\n */\nfunction autoUpdate(reference, floating, update, options) {\n  if (options === void 0) {\n    options = {};\n  }\n  const {\n    ancestorScroll = true,\n    ancestorResize = true,\n    elementResize = typeof ResizeObserver === 'function',\n    layoutShift = typeof IntersectionObserver === 'function',\n    animationFrame = false\n  } = options;\n  const referenceEl = unwrapElement(reference);\n  const ancestors = ancestorScroll || ancestorResize ? [...(referenceEl ? getOverflowAncestors(referenceEl) : []), ...getOverflowAncestors(floating)] : [];\n  ancestors.forEach(ancestor => {\n    ancestorScroll && ancestor.addEventListener('scroll', update, {\n      passive: true\n    });\n    ancestorResize && ancestor.addEventListener('resize', update);\n  });\n  const cleanupIo = referenceEl && layoutShift ? observeMove(referenceEl, update) : null;\n  let reobserveFrame = -1;\n  let resizeObserver = null;\n  if (elementResize) {\n    resizeObserver = new ResizeObserver(_ref => {\n      let [firstEntry] = _ref;\n      if (firstEntry && firstEntry.target === referenceEl && resizeObserver) {\n        // Prevent update loops when using the `size` middleware.\n        // https://github.com/floating-ui/floating-ui/issues/1740\n        resizeObserver.unobserve(floating);\n        cancelAnimationFrame(reobserveFrame);\n        reobserveFrame = requestAnimationFrame(() => {\n          resizeObserver && resizeObserver.observe(floating);\n        });\n      }\n      update();\n    });\n    if (referenceEl && !animationFrame) {\n      resizeObserver.observe(referenceEl);\n    }\n    resizeObserver.observe(floating);\n  }\n  let frameId;\n  let prevRefRect = animationFrame ? getBoundingClientRect(reference) : null;\n  if (animationFrame) {\n    frameLoop();\n  }\n  function frameLoop() {\n    const nextRefRect = getBoundingClientRect(reference);\n    if (prevRefRect && (nextRefRect.x !== prevRefRect.x || nextRefRect.y !== prevRefRect.y || nextRefRect.width !== prevRefRect.width || nextRefRect.height !== prevRefRect.height)) {\n      update();\n    }\n    prevRefRect = nextRefRect;\n    frameId = requestAnimationFrame(frameLoop);\n  }\n  update();\n  return () => {\n    ancestors.forEach(ancestor => {\n      ancestorScroll && ancestor.removeEventListener('scroll', update);\n      ancestorResize && ancestor.removeEventListener('resize', update);\n    });\n    cleanupIo && cleanupIo();\n    resizeObserver && resizeObserver.disconnect();\n    resizeObserver = null;\n    if (animationFrame) {\n      cancelAnimationFrame(frameId);\n    }\n  };\n}\n\n/**\n * Computes the `x` and `y` coordinates that will place the floating element\n * next to a reference element when it is given a certain CSS positioning\n * strategy.\n */\nconst computePosition = (reference, floating, options) => {\n  // This caches the expensive `getClippingElementAncestors` function so that\n  // multiple lifecycle resets re-use the same result. It only lives for a\n  // single call. If other functions become expensive, we can add them as well.\n  const cache = new Map();\n  const mergedOptions = {\n    platform,\n    ...options\n  };\n  const platformWithCache = {\n    ...mergedOptions.platform,\n    _c: cache\n  };\n  return computePosition$1(reference, floating, {\n    ...mergedOptions,\n    platform: platformWithCache\n  });\n};\n\nexport { autoUpdate, computePosition, getOverflowAncestors, platform };\n","/**\n * Custom positioning reference element.\n * @see https://floating-ui.com/docs/virtual-elements\n */\n\nconst sides = ['top', 'right', 'bottom', 'left'];\nconst alignments = ['start', 'end'];\nconst placements = /*#__PURE__*/sides.reduce((acc, side) => acc.concat(side, side + \"-\" + alignments[0], side + \"-\" + alignments[1]), []);\nconst min = Math.min;\nconst max = Math.max;\nconst round = Math.round;\nconst floor = Math.floor;\nconst createCoords = v => ({\n  x: v,\n  y: v\n});\nconst oppositeSideMap = {\n  left: 'right',\n  right: 'left',\n  bottom: 'top',\n  top: 'bottom'\n};\nconst oppositeAlignmentMap = {\n  start: 'end',\n  end: 'start'\n};\nfunction clamp(start, value, end) {\n  return max(start, min(value, end));\n}\nfunction evaluate(value, param) {\n  return typeof value === 'function' ? value(param) : value;\n}\nfunction getSide(placement) {\n  return placement.split('-')[0];\n}\nfunction getAlignment(placement) {\n  return placement.split('-')[1];\n}\nfunction getOppositeAxis(axis) {\n  return axis === 'x' ? 'y' : 'x';\n}\nfunction getAxisLength(axis) {\n  return axis === 'y' ? 'height' : 'width';\n}\nfunction getSideAxis(placement) {\n  return ['top', 'bottom'].includes(getSide(placement)) ? 'y' : 'x';\n}\nfunction getAlignmentAxis(placement) {\n  return getOppositeAxis(getSideAxis(placement));\n}\nfunction getAlignmentSides(placement, rects, rtl) {\n  if (rtl === void 0) {\n    rtl = false;\n  }\n  const alignment = getAlignment(placement);\n  const alignmentAxis = getAlignmentAxis(placement);\n  const length = getAxisLength(alignmentAxis);\n  let mainAlignmentSide = alignmentAxis === 'x' ? alignment === (rtl ? 'end' : 'start') ? 'right' : 'left' : alignment === 'start' ? 'bottom' : 'top';\n  if (rects.reference[length] > rects.floating[length]) {\n    mainAlignmentSide = getOppositePlacement(mainAlignmentSide);\n  }\n  return [mainAlignmentSide, getOppositePlacement(mainAlignmentSide)];\n}\nfunction getExpandedPlacements(placement) {\n  const oppositePlacement = getOppositePlacement(placement);\n  return [getOppositeAlignmentPlacement(placement), oppositePlacement, getOppositeAlignmentPlacement(oppositePlacement)];\n}\nfunction getOppositeAlignmentPlacement(placement) {\n  return placement.replace(/start|end/g, alignment => oppositeAlignmentMap[alignment]);\n}\nfunction getSideList(side, isStart, rtl) {\n  const lr = ['left', 'right'];\n  const rl = ['right', 'left'];\n  const tb = ['top', 'bottom'];\n  const bt = ['bottom', 'top'];\n  switch (side) {\n    case 'top':\n    case 'bottom':\n      if (rtl) return isStart ? rl : lr;\n      return isStart ? lr : rl;\n    case 'left':\n    case 'right':\n      return isStart ? tb : bt;\n    default:\n      return [];\n  }\n}\nfunction getOppositeAxisPlacements(placement, flipAlignment, direction, rtl) {\n  const alignment = getAlignment(placement);\n  let list = getSideList(getSide(placement), direction === 'start', rtl);\n  if (alignment) {\n    list = list.map(side => side + \"-\" + alignment);\n    if (flipAlignment) {\n      list = list.concat(list.map(getOppositeAlignmentPlacement));\n    }\n  }\n  return list;\n}\nfunction getOppositePlacement(placement) {\n  return placement.replace(/left|right|bottom|top/g, side => oppositeSideMap[side]);\n}\nfunction expandPaddingObject(padding) {\n  return {\n    top: 0,\n    right: 0,\n    bottom: 0,\n    left: 0,\n    ...padding\n  };\n}\nfunction getPaddingObject(padding) {\n  return typeof padding !== 'number' ? expandPaddingObject(padding) : {\n    top: padding,\n    right: padding,\n    bottom: padding,\n    left: padding\n  };\n}\nfunction rectToClientRect(rect) {\n  const {\n    x,\n    y,\n    width,\n    height\n  } = rect;\n  return {\n    width,\n    height,\n    top: y,\n    left: x,\n    right: x + width,\n    bottom: y + height,\n    x,\n    y\n  };\n}\n\nexport { alignments, clamp, createCoords, evaluate, expandPaddingObject, floor, getAlignment, getAlignmentAxis, getAlignmentSides, getAxisLength, getExpandedPlacements, getOppositeAlignmentPlacement, getOppositeAxis, getOppositeAxisPlacements, getOppositePlacement, getPaddingObject, getSide, getSideAxis, max, min, placements, rectToClientRect, round, sides };\n","import { GlBreakpointInstance as bp, breakpoints } from '@gitlab/ui/dist/utils';\nimport { debounce } from 'lodash';\nimport { setCookie, getCookie } from '~/lib/utils/common_utils';\nimport Tracking from '~/tracking';\nimport { sidebarState } from './constants';\n\nexport const SIDEBAR_COLLAPSED_CLASS = 'page-with-super-sidebar-collapsed';\nexport const SIDEBAR_COLLAPSED_COOKIE = 'super_sidebar_collapsed';\nexport const SIDEBAR_COLLAPSED_COOKIE_EXPIRATION = 365 * 10;\nexport const SIDEBAR_TRANSITION_DURATION = 200;\n\nexport const findPage = () => document.querySelector('.page-with-super-sidebar');\nexport const findSidebar = () => document.querySelector('.super-sidebar');\n\nexport const isCollapsed = () => findPage().classList.contains(SIDEBAR_COLLAPSED_CLASS);\n\n// See documentation: https://design.gitlab.com/patterns/navigation#left-sidebar\n// NOTE: at 1200px nav sidebar should not overlap the content\n// https://gitlab.com/gitlab-org/gitlab-foss/merge_requests/24555#note_134136110\nexport const isDesktopBreakpoint = () => bp.windowWidth() >= breakpoints.xl;\n\nexport const getCollapsedCookie = () => getCookie(SIDEBAR_COLLAPSED_COOKIE) === 'true';\n\nexport const toggleSuperSidebarCollapsed = (collapsed, saveCookie) => {\n  findPage().classList.toggle(SIDEBAR_COLLAPSED_CLASS, collapsed);\n\n  sidebarState.isPeek = false;\n  sidebarState.isPeekable = collapsed;\n  sidebarState.hasPeeked = false;\n  sidebarState.isHoverPeek = false;\n  sidebarState.wasHoverPeek = false;\n  sidebarState.isCollapsed = collapsed;\n\n  if (saveCookie && isDesktopBreakpoint()) {\n    setCookie(SIDEBAR_COLLAPSED_COOKIE, collapsed, {\n      expires: SIDEBAR_COLLAPSED_COOKIE_EXPIRATION,\n    });\n  }\n};\n\nexport const initSuperSidebarCollapsedState = (forceDesktopExpandedSidebar = false) => {\n  let collapsed = true;\n  if (isDesktopBreakpoint()) {\n    collapsed = forceDesktopExpandedSidebar ? false : getCollapsedCookie();\n  }\n  toggleSuperSidebarCollapsed(collapsed, false);\n};\n\nexport const bindSuperSidebarCollapsedEvents = (forceDesktopExpandedSidebar = false) => {\n  let previousWindowWidth = window.innerWidth;\n\n  const callback = debounce(() => {\n    const newWindowWidth = window.innerWidth;\n    const widthChanged = previousWindowWidth !== newWindowWidth;\n\n    if (widthChanged) {\n      const collapsedBeforeResize = sidebarState.isCollapsed;\n      initSuperSidebarCollapsedState(forceDesktopExpandedSidebar);\n      const collapsedAfterResize = sidebarState.isCollapsed;\n      if (!collapsedBeforeResize && collapsedAfterResize) {\n        Tracking.event(undefined, 'nav_hide', {\n          label: 'browser_resize',\n          property: 'nav_sidebar',\n        });\n      }\n    }\n    previousWindowWidth = newWindowWidth;\n  }, 100);\n\n  window.addEventListener('resize', callback);\n\n  return () => window.removeEventListener('resize', callback);\n};\n","import GlClearIconButton from '../../shared_components/clear_icon_button/clear_icon_button';\nimport GlFormInput from '../form/form_input/form_input';\nimport GlIcon from '../icon/icon';\nimport GlLoadingIcon from '../loading_icon/loading_icon';\nimport { translate } from '../../../utils/i18n';\nimport __vue_normalize__ from 'vue-runtime-helpers/dist/normalize-component.js';\n\nvar script = {\n  name: 'GlSearchBoxByType',\n  components: {\n    GlClearIconButton,\n    GlIcon,\n    GlFormInput,\n    GlLoadingIcon\n  },\n  inheritAttrs: false,\n  model: {\n    prop: 'value',\n    event: 'input'\n  },\n  props: {\n    /**\n     * If provided, used as value of search input\n     */\n    value: {\n      type: String,\n      required: false,\n      default: ''\n    },\n    borderless: {\n      type: Boolean,\n      required: false,\n      default: false\n    },\n    clearButtonTitle: {\n      type: String,\n      required: false,\n      default: () => translate('GlSearchBoxByType.clearButtonTitle', 'Clear')\n    },\n    /**\n     * If provided and true, disables the input and controls\n     */\n    disabled: {\n      type: Boolean,\n      required: false,\n      default: false\n    },\n    /**\n     * Puts search box into loading state, rendering spinner\n     */\n    isLoading: {\n      type: Boolean,\n      required: false,\n      default: false\n    },\n    /**\n     * Container for tooltip. Valid values: DOM node, selector string or `false` for default\n     */\n    tooltipContainer: {\n      required: false,\n      default: false,\n      validator: value => value === false || typeof value === 'string' || value instanceof HTMLElement\n    }\n  },\n  computed: {\n    inputAttributes() {\n      const attributes = {\n        type: 'search',\n        placeholder: translate('GlSearchBoxByType.input.placeholder', 'Search'),\n        ...this.$attrs\n      };\n      if (!attributes['aria-label']) {\n        attributes['aria-label'] = attributes.placeholder;\n      }\n      return attributes;\n    },\n    hasValue() {\n      return Boolean(this.value.length);\n    },\n    inputListeners() {\n      return {\n        ...this.$listeners,\n        input: this.onInput,\n        focusin: this.onFocusin,\n        focusout: this.onFocusout\n      };\n    },\n    showClearButton() {\n      return this.hasValue && !this.disabled;\n    }\n  },\n  methods: {\n    isInputOrClearButton(element) {\n      var _this$$refs$input, _this$$refs$clearButt;\n      return element === ((_this$$refs$input = this.$refs.input) === null || _this$$refs$input === void 0 ? void 0 : _this$$refs$input.$el) || element === ((_this$$refs$clearButt = this.$refs.clearButton) === null || _this$$refs$clearButt === void 0 ? void 0 : _this$$refs$clearButt.$el);\n    },\n    clearInput() {\n      this.onInput('');\n      this.focusInput();\n    },\n    focusInput() {\n      this.$refs.input.$el.focus();\n    },\n    onInput(value) {\n      this.$emit('input', value);\n    },\n    onFocusout(event) {\n      const {\n        relatedTarget\n      } = event;\n      if (this.isInputOrClearButton(relatedTarget)) {\n        return;\n      }\n      this.$emit('focusout', event);\n    },\n    onFocusin(event) {\n      const {\n        relatedTarget\n      } = event;\n      if (this.isInputOrClearButton(relatedTarget)) {\n        return;\n      }\n      this.$emit('focusin', event);\n    }\n  }\n};\n\n/* script */\nconst __vue_script__ = script;\n\n/* template */\nvar __vue_render__ = function () {var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;return _c('div',{staticClass:\"gl-search-box-by-type\"},[_c('gl-icon',{staticClass:\"gl-search-box-by-type-search-icon\",attrs:{\"name\":\"search\",\"variant\":\"subtle\"}}),_vm._v(\" \"),_c('gl-form-input',_vm._g(_vm._b({ref:\"input\",class:{\n      'gl-search-box-by-type-input': !_vm.borderless,\n      'gl-search-box-by-type-input-borderless': _vm.borderless,\n    },attrs:{\"value\":_vm.value,\"disabled\":_vm.disabled}},'gl-form-input',_vm.inputAttributes,false),_vm.inputListeners)),_vm._v(\" \"),(_vm.isLoading || _vm.showClearButton)?_c('div',{staticClass:\"gl-search-box-by-type-right-icons\"},[(_vm.isLoading)?_c('gl-loading-icon',{staticClass:\"gl-search-box-by-type-loading-icon\"}):_vm._e(),_vm._v(\" \"),(_vm.showClearButton)?_c('gl-clear-icon-button',{ref:\"clearButton\",staticClass:\"gl-search-box-by-type-clear gl-clear-icon-button\",attrs:{\"title\":_vm.clearButtonTitle,\"tooltip-container\":_vm.tooltipContainer},on:{\"click\":function($event){$event.stopPropagation();return _vm.clearInput.apply(null, arguments)},\"focusin\":_vm.onFocusin,\"focusout\":_vm.onFocusout}}):_vm._e()],1):_vm._e()],1)};\nvar __vue_staticRenderFns__ = [];\n\n  /* style */\n  const __vue_inject_styles__ = undefined;\n  /* scoped */\n  const __vue_scope_id__ = undefined;\n  /* module identifier */\n  const __vue_module_identifier__ = undefined;\n  /* functional template */\n  const __vue_is_functional_template__ = false;\n  /* style inject */\n  \n  /* style inject SSR */\n  \n  /* style inject shadow dom */\n  \n\n  \n  const __vue_component__ = __vue_normalize__(\n    { render: __vue_render__, staticRenderFns: __vue_staticRenderFns__ },\n    __vue_inject_styles__,\n    __vue_script__,\n    __vue_scope_id__,\n    __vue_is_functional_template__,\n    __vue_module_identifier__,\n    false,\n    undefined,\n    undefined,\n    undefined\n  );\n\nexport default __vue_component__;\n","import uniqueId from 'lodash/uniqueId';\nimport { offset, autoPlacement, shift, arrow, size, autoUpdate, computePosition } from '@floating-ui/dom';\nimport { buttonCategoryOptions, dropdownVariantOptions, buttonSizeOptions, dropdownPlacements, dropdownAllowedAutoPlacements } from '../../../../utils/constants';\nimport { POSITION_ABSOLUTE, POSITION_FIXED, GL_DROPDOWN_CONTENTS_CLASS, GL_DROPDOWN_BEFORE_CLOSE, GL_DROPDOWN_SHOWN, GL_DROPDOWN_HIDDEN, ENTER, SPACE, ARROW_DOWN, GL_DROPDOWN_FOCUS_CONTENT } from '../constants';\nimport { logWarning, isElementFocusable, isElementTabbable } from '../../../../utils/utils';\nimport { OutsideDirective } from '../../../../directives/outside/outside';\nimport GlButton from '../../button/button';\nimport GlIcon from '../../icon/icon';\nimport { DEFAULT_OFFSET, FIXED_WIDTH_CLASS, ARROW_X_MINIMUM } from './constants';\nimport __vue_normalize__ from 'vue-runtime-helpers/dist/normalize-component.js';\n\nconst BASE_DROPDOWN_CLASS = 'gl-new-dropdown';\nvar script = {\n  name: 'BaseDropdown',\n  BASE_DROPDOWN_CLASS,\n  components: {\n    GlButton,\n    GlIcon\n  },\n  directives: {\n    Outside: OutsideDirective\n  },\n  props: {\n    toggleText: {\n      type: String,\n      required: false,\n      default: ''\n    },\n    textSrOnly: {\n      type: Boolean,\n      required: false,\n      default: false\n    },\n    block: {\n      type: Boolean,\n      required: false,\n      default: false\n    },\n    category: {\n      type: String,\n      required: false,\n      default: buttonCategoryOptions.primary,\n      validator: value => Object.keys(buttonCategoryOptions).includes(value)\n    },\n    variant: {\n      type: String,\n      required: false,\n      default: dropdownVariantOptions.default,\n      validator: value => Object.keys(dropdownVariantOptions).includes(value)\n    },\n    size: {\n      type: String,\n      required: false,\n      default: 'medium',\n      validator: value => Object.keys(buttonSizeOptions).includes(value)\n    },\n    icon: {\n      type: String,\n      required: false,\n      default: ''\n    },\n    disabled: {\n      type: Boolean,\n      required: false,\n      default: false\n    },\n    loading: {\n      type: Boolean,\n      required: false,\n      default: false\n    },\n    toggleClass: {\n      type: [String, Array, Object],\n      required: false,\n      default: null\n    },\n    noCaret: {\n      type: Boolean,\n      required: false,\n      default: false\n    },\n    placement: {\n      type: String,\n      required: false,\n      default: 'bottom-start',\n      validator: value => {\n        if (['left', 'center', 'right'].includes(value)) {\n          logWarning(`GlDisclosureDropdown/GlCollapsibleListbox: \"${value}\" placement is deprecated.\n            Use ${dropdownPlacements[value]} instead.`);\n        }\n        return Object.keys(dropdownPlacements).includes(value);\n      }\n    },\n    // ARIA props\n    ariaHaspopup: {\n      type: [String, Boolean],\n      required: false,\n      default: false,\n      validator: value => {\n        return ['menu', 'listbox', 'tree', 'grid', 'dialog', true, false].includes(value);\n      }\n    },\n    /**\n     * Id that will be referenced by `aria-labelledby` attribute of the dropdown content`\n     */\n    toggleId: {\n      type: String,\n      required: true\n    },\n    /**\n     * The `aria-labelledby` attribute value for the  toggle `button`\n     */\n    ariaLabelledby: {\n      type: String,\n      required: false,\n      default: null\n    },\n    /**\n     * Custom value to be passed to the offset middleware.\n     * https://floating-ui.com/docs/offset\n     */\n    offset: {\n      type: [Number, Object],\n      required: false,\n      default: () => ({\n        mainAxis: DEFAULT_OFFSET\n      })\n    },\n    fluidWidth: {\n      type: Boolean,\n      required: false,\n      default: false\n    },\n    /**\n     * Strategy to be applied by computePosition. If this is set to fixed, the dropdown's position\n     * needs to be set to fixed in CSS as well.\n     * https://floating-ui.com/docs/computePosition#strategy\n     */\n    positioningStrategy: {\n      type: String,\n      required: false,\n      default: POSITION_ABSOLUTE,\n      validator: strategy => [POSITION_ABSOLUTE, POSITION_FIXED].includes(strategy)\n    }\n  },\n  data() {\n    return {\n      openedYet: false,\n      visible: false,\n      baseDropdownId: uniqueId('base-dropdown-')\n    };\n  },\n  computed: {\n    hasNoVisibleToggleText() {\n      var _this$toggleText;\n      return !((_this$toggleText = this.toggleText) !== null && _this$toggleText !== void 0 && _this$toggleText.length) || this.textSrOnly;\n    },\n    isIconOnly() {\n      return Boolean(this.icon && this.hasNoVisibleToggleText);\n    },\n    isEllipsisButton() {\n      return this.isIconOnly && this.icon === 'ellipsis_h';\n    },\n    isCaretOnly() {\n      return !this.noCaret && !this.icon && this.hasNoVisibleToggleText;\n    },\n    ariaAttributes() {\n      return {\n        'aria-haspopup': this.ariaHaspopup,\n        'aria-expanded': String(this.visible),\n        'aria-controls': this.baseDropdownId,\n        'aria-labelledby': this.toggleLabelledBy\n      };\n    },\n    toggleButtonClasses() {\n      return [this.toggleClass, {\n        'gl-new-dropdown-toggle': true,\n        'button-ellipsis-horizontal': this.isEllipsisButton,\n        'gl-new-dropdown-icon-only btn-icon': this.isIconOnly && !this.isEllipsisButton,\n        'gl-new-dropdown-toggle-no-caret': this.noCaret,\n        'gl-new-dropdown-caret-only btn-icon': this.isCaretOnly\n      }];\n    },\n    toggleButtonTextClasses() {\n      return this.block ? 'gl-w-full' : '';\n    },\n    toggleLabelledBy() {\n      return this.ariaLabelledby ? `${this.ariaLabelledby} ${this.toggleId}` : this.toggleId;\n    },\n    isDefaultToggle() {\n      return !this.$scopedSlots.toggle;\n    },\n    toggleOptions() {\n      if (this.isDefaultToggle) {\n        return {\n          is: GlButton,\n          icon: this.icon,\n          block: this.block,\n          buttonTextClasses: this.toggleButtonTextClasses,\n          category: this.category,\n          variant: this.variant,\n          size: this.size,\n          disabled: this.disabled,\n          loading: this.loading,\n          class: this.toggleButtonClasses,\n          ...this.ariaAttributes,\n          listeners: {\n            keydown: event => this.onKeydown(event),\n            click: event => this.toggle(event)\n          }\n        };\n      }\n      return {\n        is: 'div',\n        class: 'gl-new-dropdown-custom-toggle',\n        listeners: {\n          keydown: event => this.onKeydown(event),\n          click: event => this.toggle(event)\n        }\n      };\n    },\n    toggleListeners() {\n      return this.toggleOptions.listeners;\n    },\n    toggleAttributes() {\n      const {\n        listeners,\n        is,\n        ...attributes\n      } = this.toggleOptions;\n      return attributes;\n    },\n    toggleComponent() {\n      return this.toggleOptions.is;\n    },\n    toggleElement() {\n      var _this$$refs$toggle;\n      return this.$refs.toggle.$el || ((_this$$refs$toggle = this.$refs.toggle) === null || _this$$refs$toggle === void 0 ? void 0 : _this$$refs$toggle.firstElementChild);\n    },\n    panelClasses() {\n      return {\n        '!gl-block': this.visible,\n        [FIXED_WIDTH_CLASS]: !this.fluidWidth,\n        'gl-fixed': this.openedYet && this.isFixed,\n        'gl-absolute': this.openedYet && !this.isFixed\n      };\n    },\n    isFixed() {\n      return this.positioningStrategy === POSITION_FIXED;\n    },\n    floatingUIConfig() {\n      const placement = dropdownPlacements[this.placement];\n      const [, alignment] = placement.split('-');\n      return {\n        placement,\n        strategy: this.positioningStrategy,\n        middleware: [offset(this.offset), autoPlacement({\n          alignment,\n          allowedPlacements: dropdownAllowedAutoPlacements[this.placement]\n        }), shift(), arrow({\n          element: this.$refs.dropdownArrow\n        }), size({\n          apply: _ref => {\n            var _this$nonScrollableCo;\n            let {\n              availableHeight,\n              elements\n            } = _ref;\n            const contentsEl = elements.floating.querySelector(`.${GL_DROPDOWN_CONTENTS_CLASS}`);\n            if (!contentsEl) return;\n            const contentsAvailableHeight = availableHeight - ((_this$nonScrollableCo = this.nonScrollableContentHeight) !== null && _this$nonScrollableCo !== void 0 ? _this$nonScrollableCo : 0) - DEFAULT_OFFSET;\n            Object.assign(contentsEl.style, {\n              maxHeight: `${Math.max(contentsAvailableHeight, 0)}px`\n            });\n          }\n        })]\n      };\n    }\n  },\n  watch: {\n    ariaAttributes: {\n      deep: true,\n      handler(ariaAttributes) {\n        if (this.$scopedSlots.toggle) {\n          Object.keys(ariaAttributes).forEach(key => {\n            this.toggleElement.setAttribute(key, ariaAttributes[key]);\n          });\n        }\n      }\n    }\n  },\n  mounted() {\n    this.checkToggleFocusable();\n  },\n  beforeDestroy() {\n    this.stopFloating();\n  },\n  methods: {\n    checkToggleFocusable() {\n      if (!isElementFocusable(this.toggleElement) && !isElementTabbable(this.toggleElement)) {\n        logWarning(`GlDisclosureDropdown/GlCollapsibleListbox: Toggle is missing a 'tabindex' and cannot be focused.\n          Use 'a' or 'button' element instead or make sure to add 'role=\"button\"' along with 'tabindex' otherwise.`, this.$el);\n      }\n    },\n    getArrowOffsets(actualPlacement) {\n      // Try to extract the base direction (top, bottom, left, right) from the placement\n      const direction = actualPlacement === null || actualPlacement === void 0 ? void 0 : actualPlacement.split('-')[0];\n      const offsetConfigs = {\n        top: {\n          staticSide: 'bottom',\n          rotation: '225deg'\n        },\n        bottom: {\n          staticSide: 'top',\n          rotation: '45deg'\n        },\n        left: {\n          staticSide: 'right',\n          rotation: '135deg'\n        },\n        right: {\n          staticSide: 'left',\n          rotation: '315deg'\n        }\n      };\n      return offsetConfigs[direction] || offsetConfigs.bottom;\n    },\n    async startFloating() {\n      this.calculateNonScrollableAreaHeight();\n      this.observer = new MutationObserver(this.calculateNonScrollableAreaHeight);\n      this.observer.observe(this.$refs.content, {\n        childList: true,\n        subtree: true\n      });\n      this.stopAutoUpdate = autoUpdate(this.toggleElement, this.$refs.content, async () => {\n        const result = await computePosition(this.toggleElement, this.$refs.content, this.floatingUIConfig);\n\n        /**\n         * Due to the asynchronous nature of computePosition, it's technically possible for the\n         * component to have been destroyed by the time the promise resolves. In such case, we exit\n         * early to prevent a TypeError.\n         */\n        if (!this.$refs.content) return;\n        const {\n          x,\n          y,\n          middlewareData,\n          placement\n        } = result;\n\n        // Get offsets based on actual placement, not requested placement\n        const {\n          rotation,\n          staticSide\n        } = this.getArrowOffsets(placement);\n\n        // Assign dropdown window position\n        Object.assign(this.$refs.content.style, {\n          left: `${x}px`,\n          top: `${y}px`\n        });\n\n        // Assign arrow position\n        if (middlewareData && middlewareData.arrow) {\n          const {\n            x: arrowX,\n            y: arrowY\n          } = middlewareData.arrow;\n\n          /**\n           * Clamp arrow X position to a minimum of 24px from the edge of the dropdown.\n           * This prevents wide toggles from pushing the arrow to the very edge of the dropdown.\n           */\n          const toggleRect = this.toggleElement.getBoundingClientRect();\n          const contentRect = this.$refs.content.getBoundingClientRect();\n          const clampedArrowX = toggleRect.width > contentRect.width ? Math.min(Math.max(arrowX, ARROW_X_MINIMUM), contentRect.width - ARROW_X_MINIMUM) : arrowX;\n          Object.assign(this.$refs.dropdownArrow.style, {\n            left: arrowX != null ? `${clampedArrowX}px` : '',\n            top: arrowY != null ? `${arrowY}px` : '',\n            right: '',\n            bottom: '',\n            [staticSide]: '-4px',\n            transform: `rotate(${rotation})`\n          });\n        }\n      });\n    },\n    stopFloating() {\n      var _this$observer, _this$stopAutoUpdate;\n      (_this$observer = this.observer) === null || _this$observer === void 0 ? void 0 : _this$observer.disconnect();\n      (_this$stopAutoUpdate = this.stopAutoUpdate) === null || _this$stopAutoUpdate === void 0 ? void 0 : _this$stopAutoUpdate.call(this);\n    },\n    async toggle(event) {\n      if (event && this.visible) {\n        let prevented = false;\n        this.$emit(GL_DROPDOWN_BEFORE_CLOSE, {\n          originalEvent: event,\n          preventDefault() {\n            prevented = true;\n          }\n        });\n        if (prevented) return false;\n      }\n      this.visible = !this.visible;\n      if (this.visible) {\n        // The dropdown needs to be actually visible before we compute its position with Floating UI.\n        await this.$nextTick();\n        this.openedYet = true;\n        /**\n         * We wait until the dropdown's position has been computed before emitting the `shown` event.\n         * This ensures that, if the parent component attempts to focus an inner element, the dropdown\n         * is already properly placed in the page. Otherwise, the page would scroll back to the top.\n         */\n        this.startFloating();\n        this.$emit(GL_DROPDOWN_SHOWN);\n      } else {\n        this.stopFloating();\n        this.$emit(GL_DROPDOWN_HIDDEN);\n      }\n\n      // this is to check whether `toggle` was prevented or not\n      return true;\n    },\n    open() {\n      if (this.visible) {\n        return;\n      }\n      this.toggle();\n    },\n    close(event) {\n      if (!this.visible) {\n        return;\n      }\n      this.toggle(event);\n    },\n    /**\n     * Closes the dropdown and returns the focus to the toggle unless it has has moved outside\n     * of the dropdown, meaning that the consumer needed to put some other element in focus.\n     *\n     * @param {KeyboardEvent?} event The keyboard event that caused the dropdown to close.\n     */\n    async closeAndFocus(event) {\n      if (!this.visible) {\n        return;\n      }\n      const hadFocusWithin = this.$el.contains(document.activeElement);\n      const hasToggled = await this.toggle(event);\n      if (!hadFocusWithin) {\n        return;\n      }\n      if (hasToggled) {\n        this.focusToggle();\n      }\n    },\n    focusToggle() {\n      this.toggleElement.focus();\n    },\n    onKeydown(event) {\n      const {\n        code,\n        target: {\n          tagName\n        }\n      } = event;\n      let toggleOnEnter = true;\n      let toggleOnSpace = true;\n      if (tagName === 'BUTTON') {\n        toggleOnEnter = false;\n        toggleOnSpace = false;\n      } else if (tagName === 'A') {\n        toggleOnEnter = false;\n      }\n      if (code === ENTER && toggleOnEnter || code === SPACE && toggleOnSpace) {\n        this.toggle(event);\n      }\n      if (code === ARROW_DOWN) {\n        this.$emit(GL_DROPDOWN_FOCUS_CONTENT, event);\n      }\n    },\n    calculateNonScrollableAreaHeight() {\n      var _this$$refs$content;\n      const scrollableArea = (_this$$refs$content = this.$refs.content) === null || _this$$refs$content === void 0 ? void 0 : _this$$refs$content.querySelector(`.${GL_DROPDOWN_CONTENTS_CLASS}`);\n      if (!scrollableArea) return;\n      const floatingElementBoundingBox = this.$refs.content.getBoundingClientRect();\n      const scrollableAreaBoundingBox = scrollableArea.getBoundingClientRect();\n      this.nonScrollableContentHeight = floatingElementBoundingBox.height - scrollableAreaBoundingBox.height;\n    }\n  }\n};\n\n/* script */\nconst __vue_script__ = script;\n\n/* template */\nvar __vue_render__ = function () {var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;return _c('div',{directives:[{name:\"outside\",rawName:\"v-outside.click.focusin\",value:(_vm.close),expression:\"close\",modifiers:{\"click\":true,\"focusin\":true}}],class:[_vm.$options.BASE_DROPDOWN_CLASS, { '!gl-block': _vm.block }]},[_c(_vm.toggleComponent,_vm._g(_vm._b({ref:\"toggle\",tag:\"component\",attrs:{\"id\":_vm.toggleId,\"data-testid\":\"base-dropdown-toggle\"},on:{\"keydown\":function($event){if(!$event.type.indexOf('key')&&_vm._k($event.keyCode,\"esc\",27,$event.key,[\"Esc\",\"Escape\"])){ return null; }$event.stopPropagation();$event.preventDefault();return _vm.close.apply(null, arguments)}}},'component',_vm.toggleAttributes,false),_vm.toggleListeners),[_vm._t(\"toggle\",function(){return [_c('span',{staticClass:\"gl-new-dropdown-button-text\",class:{ 'gl-sr-only': _vm.textSrOnly }},[_vm._v(\"\\n        \"+_vm._s(_vm.toggleText)+\"\\n      \")]),_vm._v(\" \"),(!_vm.noCaret)?_c('gl-icon',{staticClass:\"gl-button-icon gl-new-dropdown-chevron\",attrs:{\"name\":\"chevron-down\"}}):_vm._e()]})],2),_vm._v(\" \"),_c('div',{ref:\"content\",staticClass:\"gl-new-dropdown-panel\",class:_vm.panelClasses,attrs:{\"id\":_vm.baseDropdownId,\"data-testid\":\"base-dropdown-menu\"},on:{\"keydown\":function($event){if(!$event.type.indexOf('key')&&_vm._k($event.keyCode,\"esc\",27,$event.key,[\"Esc\",\"Escape\"])){ return null; }$event.stopPropagation();$event.preventDefault();return _vm.closeAndFocus.apply(null, arguments)}}},[_c('div',{ref:\"dropdownArrow\",staticClass:\"gl-new-dropdown-arrow\"}),_vm._v(\" \"),_c('div',{staticClass:\"gl-new-dropdown-inner\"},[_vm._t(\"default\")],2)])],1)};\nvar __vue_staticRenderFns__ = [];\n\n  /* style */\n  const __vue_inject_styles__ = undefined;\n  /* scoped */\n  const __vue_scope_id__ = undefined;\n  /* module identifier */\n  const __vue_module_identifier__ = undefined;\n  /* functional template */\n  const __vue_is_functional_template__ = false;\n  /* style inject */\n  \n  /* style inject SSR */\n  \n  /* style inject shadow dom */\n  \n\n  \n  const __vue_component__ = __vue_normalize__(\n    { render: __vue_render__, staticRenderFns: __vue_staticRenderFns__ },\n    __vue_inject_styles__,\n    __vue_script__,\n    __vue_scope_id__,\n    __vue_is_functional_template__,\n    __vue_module_identifier__,\n    false,\n    undefined,\n    undefined,\n    undefined\n  );\n\nexport default __vue_component__;\nexport { BASE_DROPDOWN_CLASS };\n","const FIXED_WIDTH_CLASS = '!gl-w-31';\nconst DEFAULT_OFFSET = 8;\nconst ARROW_X_MINIMUM = 24;\n\nexport { ARROW_X_MINIMUM, DEFAULT_OFFSET, FIXED_WIDTH_CLASS };\n","import { getSideAxis, getAlignmentAxis, getAxisLength, getSide, getAlignment, evaluate, getPaddingObject, rectToClientRect, min, clamp, placements, getAlignmentSides, getOppositeAlignmentPlacement, getOppositePlacement, getExpandedPlacements, getOppositeAxisPlacements, sides, max, getOppositeAxis } from '@floating-ui/utils';\nexport { rectToClientRect } from '@floating-ui/utils';\n\nfunction computeCoordsFromPlacement(_ref, placement, rtl) {\n  let {\n    reference,\n    floating\n  } = _ref;\n  const sideAxis = getSideAxis(placement);\n  const alignmentAxis = getAlignmentAxis(placement);\n  const alignLength = getAxisLength(alignmentAxis);\n  const side = getSide(placement);\n  const isVertical = sideAxis === 'y';\n  const commonX = reference.x + reference.width / 2 - floating.width / 2;\n  const commonY = reference.y + reference.height / 2 - floating.height / 2;\n  const commonAlign = reference[alignLength] / 2 - floating[alignLength] / 2;\n  let coords;\n  switch (side) {\n    case 'top':\n      coords = {\n        x: commonX,\n        y: reference.y - floating.height\n      };\n      break;\n    case 'bottom':\n      coords = {\n        x: commonX,\n        y: reference.y + reference.height\n      };\n      break;\n    case 'right':\n      coords = {\n        x: reference.x + reference.width,\n        y: commonY\n      };\n      break;\n    case 'left':\n      coords = {\n        x: reference.x - floating.width,\n        y: commonY\n      };\n      break;\n    default:\n      coords = {\n        x: reference.x,\n        y: reference.y\n      };\n  }\n  switch (getAlignment(placement)) {\n    case 'start':\n      coords[alignmentAxis] -= commonAlign * (rtl && isVertical ? -1 : 1);\n      break;\n    case 'end':\n      coords[alignmentAxis] += commonAlign * (rtl && isVertical ? -1 : 1);\n      break;\n  }\n  return coords;\n}\n\n/**\n * Computes the `x` and `y` coordinates that will place the floating element\n * next to a given reference element.\n *\n * This export does not have any `platform` interface logic. You will need to\n * write one for the platform you are using Floating UI with.\n */\nconst computePosition = async (reference, floating, config) => {\n  const {\n    placement = 'bottom',\n    strategy = 'absolute',\n    middleware = [],\n    platform\n  } = config;\n  const validMiddleware = middleware.filter(Boolean);\n  const rtl = await (platform.isRTL == null ? void 0 : platform.isRTL(floating));\n  let rects = await platform.getElementRects({\n    reference,\n    floating,\n    strategy\n  });\n  let {\n    x,\n    y\n  } = computeCoordsFromPlacement(rects, placement, rtl);\n  let statefulPlacement = placement;\n  let middlewareData = {};\n  let resetCount = 0;\n  for (let i = 0; i < validMiddleware.length; i++) {\n    const {\n      name,\n      fn\n    } = validMiddleware[i];\n    const {\n      x: nextX,\n      y: nextY,\n      data,\n      reset\n    } = await fn({\n      x,\n      y,\n      initialPlacement: placement,\n      placement: statefulPlacement,\n      strategy,\n      middlewareData,\n      rects,\n      platform,\n      elements: {\n        reference,\n        floating\n      }\n    });\n    x = nextX != null ? nextX : x;\n    y = nextY != null ? nextY : y;\n    middlewareData = {\n      ...middlewareData,\n      [name]: {\n        ...middlewareData[name],\n        ...data\n      }\n    };\n    if (reset && resetCount <= 50) {\n      resetCount++;\n      if (typeof reset === 'object') {\n        if (reset.placement) {\n          statefulPlacement = reset.placement;\n        }\n        if (reset.rects) {\n          rects = reset.rects === true ? await platform.getElementRects({\n            reference,\n            floating,\n            strategy\n          }) : reset.rects;\n        }\n        ({\n          x,\n          y\n        } = computeCoordsFromPlacement(rects, statefulPlacement, rtl));\n      }\n      i = -1;\n    }\n  }\n  return {\n    x,\n    y,\n    placement: statefulPlacement,\n    strategy,\n    middlewareData\n  };\n};\n\n/**\n * Resolves with an object of overflow side offsets that determine how much the\n * element is overflowing a given clipping boundary on each side.\n * - positive = overflowing the boundary by that number of pixels\n * - negative = how many pixels left before it will overflow\n * - 0 = lies flush with the boundary\n * @see https://floating-ui.com/docs/detectOverflow\n */\nasync function detectOverflow(state, options) {\n  var _await$platform$isEle;\n  if (options === void 0) {\n    options = {};\n  }\n  const {\n    x,\n    y,\n    platform,\n    rects,\n    elements,\n    strategy\n  } = state;\n  const {\n    boundary = 'clippingAncestors',\n    rootBoundary = 'viewport',\n    elementContext = 'floating',\n    altBoundary = false,\n    padding = 0\n  } = evaluate(options, state);\n  const paddingObject = getPaddingObject(padding);\n  const altContext = elementContext === 'floating' ? 'reference' : 'floating';\n  const element = elements[altBoundary ? altContext : elementContext];\n  const clippingClientRect = rectToClientRect(await platform.getClippingRect({\n    element: ((_await$platform$isEle = await (platform.isElement == null ? void 0 : platform.isElement(element))) != null ? _await$platform$isEle : true) ? element : element.contextElement || (await (platform.getDocumentElement == null ? void 0 : platform.getDocumentElement(elements.floating))),\n    boundary,\n    rootBoundary,\n    strategy\n  }));\n  const rect = elementContext === 'floating' ? {\n    x,\n    y,\n    width: rects.floating.width,\n    height: rects.floating.height\n  } : rects.reference;\n  const offsetParent = await (platform.getOffsetParent == null ? void 0 : platform.getOffsetParent(elements.floating));\n  const offsetScale = (await (platform.isElement == null ? void 0 : platform.isElement(offsetParent))) ? (await (platform.getScale == null ? void 0 : platform.getScale(offsetParent))) || {\n    x: 1,\n    y: 1\n  } : {\n    x: 1,\n    y: 1\n  };\n  const elementClientRect = rectToClientRect(platform.convertOffsetParentRelativeRectToViewportRelativeRect ? await platform.convertOffsetParentRelativeRectToViewportRelativeRect({\n    elements,\n    rect,\n    offsetParent,\n    strategy\n  }) : rect);\n  return {\n    top: (clippingClientRect.top - elementClientRect.top + paddingObject.top) / offsetScale.y,\n    bottom: (elementClientRect.bottom - clippingClientRect.bottom + paddingObject.bottom) / offsetScale.y,\n    left: (clippingClientRect.left - elementClientRect.left + paddingObject.left) / offsetScale.x,\n    right: (elementClientRect.right - clippingClientRect.right + paddingObject.right) / offsetScale.x\n  };\n}\n\n/**\n * Provides data to position an inner element of the floating element so that it\n * appears centered to the reference element.\n * @see https://floating-ui.com/docs/arrow\n */\nconst arrow = options => ({\n  name: 'arrow',\n  options,\n  async fn(state) {\n    const {\n      x,\n      y,\n      placement,\n      rects,\n      platform,\n      elements,\n      middlewareData\n    } = state;\n    // Since `element` is required, we don't Partial<> the type.\n    const {\n      element,\n      padding = 0\n    } = evaluate(options, state) || {};\n    if (element == null) {\n      return {};\n    }\n    const paddingObject = getPaddingObject(padding);\n    const coords = {\n      x,\n      y\n    };\n    const axis = getAlignmentAxis(placement);\n    const length = getAxisLength(axis);\n    const arrowDimensions = await platform.getDimensions(element);\n    const isYAxis = axis === 'y';\n    const minProp = isYAxis ? 'top' : 'left';\n    const maxProp = isYAxis ? 'bottom' : 'right';\n    const clientProp = isYAxis ? 'clientHeight' : 'clientWidth';\n    const endDiff = rects.reference[length] + rects.reference[axis] - coords[axis] - rects.floating[length];\n    const startDiff = coords[axis] - rects.reference[axis];\n    const arrowOffsetParent = await (platform.getOffsetParent == null ? void 0 : platform.getOffsetParent(element));\n    let clientSize = arrowOffsetParent ? arrowOffsetParent[clientProp] : 0;\n\n    // DOM platform can return `window` as the `offsetParent`.\n    if (!clientSize || !(await (platform.isElement == null ? void 0 : platform.isElement(arrowOffsetParent)))) {\n      clientSize = elements.floating[clientProp] || rects.floating[length];\n    }\n    const centerToReference = endDiff / 2 - startDiff / 2;\n\n    // If the padding is large enough that it causes the arrow to no longer be\n    // centered, modify the padding so that it is centered.\n    const largestPossiblePadding = clientSize / 2 - arrowDimensions[length] / 2 - 1;\n    const minPadding = min(paddingObject[minProp], largestPossiblePadding);\n    const maxPadding = min(paddingObject[maxProp], largestPossiblePadding);\n\n    // Make sure the arrow doesn't overflow the floating element if the center\n    // point is outside the floating element's bounds.\n    const min$1 = minPadding;\n    const max = clientSize - arrowDimensions[length] - maxPadding;\n    const center = clientSize / 2 - arrowDimensions[length] / 2 + centerToReference;\n    const offset = clamp(min$1, center, max);\n\n    // If the reference is small enough that the arrow's padding causes it to\n    // to point to nothing for an aligned placement, adjust the offset of the\n    // floating element itself. To ensure `shift()` continues to take action,\n    // a single reset is performed when this is true.\n    const shouldAddOffset = !middlewareData.arrow && getAlignment(placement) != null && center !== offset && rects.reference[length] / 2 - (center < min$1 ? minPadding : maxPadding) - arrowDimensions[length] / 2 < 0;\n    const alignmentOffset = shouldAddOffset ? center < min$1 ? center - min$1 : center - max : 0;\n    return {\n      [axis]: coords[axis] + alignmentOffset,\n      data: {\n        [axis]: offset,\n        centerOffset: center - offset - alignmentOffset,\n        ...(shouldAddOffset && {\n          alignmentOffset\n        })\n      },\n      reset: shouldAddOffset\n    };\n  }\n});\n\nfunction getPlacementList(alignment, autoAlignment, allowedPlacements) {\n  const allowedPlacementsSortedByAlignment = alignment ? [...allowedPlacements.filter(placement => getAlignment(placement) === alignment), ...allowedPlacements.filter(placement => getAlignment(placement) !== alignment)] : allowedPlacements.filter(placement => getSide(placement) === placement);\n  return allowedPlacementsSortedByAlignment.filter(placement => {\n    if (alignment) {\n      return getAlignment(placement) === alignment || (autoAlignment ? getOppositeAlignmentPlacement(placement) !== placement : false);\n    }\n    return true;\n  });\n}\n/**\n * Optimizes the visibility of the floating element by choosing the placement\n * that has the most space available automatically, without needing to specify a\n * preferred placement. Alternative to `flip`.\n * @see https://floating-ui.com/docs/autoPlacement\n */\nconst autoPlacement = function (options) {\n  if (options === void 0) {\n    options = {};\n  }\n  return {\n    name: 'autoPlacement',\n    options,\n    async fn(state) {\n      var _middlewareData$autoP, _middlewareData$autoP2, _placementsThatFitOnE;\n      const {\n        rects,\n        middlewareData,\n        placement,\n        platform,\n        elements\n      } = state;\n      const {\n        crossAxis = false,\n        alignment,\n        allowedPlacements = placements,\n        autoAlignment = true,\n        ...detectOverflowOptions\n      } = evaluate(options, state);\n      const placements$1 = alignment !== undefined || allowedPlacements === placements ? getPlacementList(alignment || null, autoAlignment, allowedPlacements) : allowedPlacements;\n      const overflow = await detectOverflow(state, detectOverflowOptions);\n      const currentIndex = ((_middlewareData$autoP = middlewareData.autoPlacement) == null ? void 0 : _middlewareData$autoP.index) || 0;\n      const currentPlacement = placements$1[currentIndex];\n      if (currentPlacement == null) {\n        return {};\n      }\n      const alignmentSides = getAlignmentSides(currentPlacement, rects, await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating)));\n\n      // Make `computeCoords` start from the right place.\n      if (placement !== currentPlacement) {\n        return {\n          reset: {\n            placement: placements$1[0]\n          }\n        };\n      }\n      const currentOverflows = [overflow[getSide(currentPlacement)], overflow[alignmentSides[0]], overflow[alignmentSides[1]]];\n      const allOverflows = [...(((_middlewareData$autoP2 = middlewareData.autoPlacement) == null ? void 0 : _middlewareData$autoP2.overflows) || []), {\n        placement: currentPlacement,\n        overflows: currentOverflows\n      }];\n      const nextPlacement = placements$1[currentIndex + 1];\n\n      // There are more placements to check.\n      if (nextPlacement) {\n        return {\n          data: {\n            index: currentIndex + 1,\n            overflows: allOverflows\n          },\n          reset: {\n            placement: nextPlacement\n          }\n        };\n      }\n      const placementsSortedByMostSpace = allOverflows.map(d => {\n        const alignment = getAlignment(d.placement);\n        return [d.placement, alignment && crossAxis ?\n        // Check along the mainAxis and main crossAxis side.\n        d.overflows.slice(0, 2).reduce((acc, v) => acc + v, 0) :\n        // Check only the mainAxis.\n        d.overflows[0], d.overflows];\n      }).sort((a, b) => a[1] - b[1]);\n      const placementsThatFitOnEachSide = placementsSortedByMostSpace.filter(d => d[2].slice(0,\n      // Aligned placements should not check their opposite crossAxis\n      // side.\n      getAlignment(d[0]) ? 2 : 3).every(v => v <= 0));\n      const resetPlacement = ((_placementsThatFitOnE = placementsThatFitOnEachSide[0]) == null ? void 0 : _placementsThatFitOnE[0]) || placementsSortedByMostSpace[0][0];\n      if (resetPlacement !== placement) {\n        return {\n          data: {\n            index: currentIndex + 1,\n            overflows: allOverflows\n          },\n          reset: {\n            placement: resetPlacement\n          }\n        };\n      }\n      return {};\n    }\n  };\n};\n\n/**\n * Optimizes the visibility of the floating element by flipping the `placement`\n * in order to keep it in view when the preferred placement(s) will overflow the\n * clipping boundary. Alternative to `autoPlacement`.\n * @see https://floating-ui.com/docs/flip\n */\nconst flip = function (options) {\n  if (options === void 0) {\n    options = {};\n  }\n  return {\n    name: 'flip',\n    options,\n    async fn(state) {\n      var _middlewareData$arrow, _middlewareData$flip;\n      const {\n        placement,\n        middlewareData,\n        rects,\n        initialPlacement,\n        platform,\n        elements\n      } = state;\n      const {\n        mainAxis: checkMainAxis = true,\n        crossAxis: checkCrossAxis = true,\n        fallbackPlacements: specifiedFallbackPlacements,\n        fallbackStrategy = 'bestFit',\n        fallbackAxisSideDirection = 'none',\n        flipAlignment = true,\n        ...detectOverflowOptions\n      } = evaluate(options, state);\n\n      // If a reset by the arrow was caused due to an alignment offset being\n      // added, we should skip any logic now since `flip()` has already done its\n      // work.\n      // https://github.com/floating-ui/floating-ui/issues/2549#issuecomment-1719601643\n      if ((_middlewareData$arrow = middlewareData.arrow) != null && _middlewareData$arrow.alignmentOffset) {\n        return {};\n      }\n      const side = getSide(placement);\n      const initialSideAxis = getSideAxis(initialPlacement);\n      const isBasePlacement = getSide(initialPlacement) === initialPlacement;\n      const rtl = await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating));\n      const fallbackPlacements = specifiedFallbackPlacements || (isBasePlacement || !flipAlignment ? [getOppositePlacement(initialPlacement)] : getExpandedPlacements(initialPlacement));\n      const hasFallbackAxisSideDirection = fallbackAxisSideDirection !== 'none';\n      if (!specifiedFallbackPlacements && hasFallbackAxisSideDirection) {\n        fallbackPlacements.push(...getOppositeAxisPlacements(initialPlacement, flipAlignment, fallbackAxisSideDirection, rtl));\n      }\n      const placements = [initialPlacement, ...fallbackPlacements];\n      const overflow = await detectOverflow(state, detectOverflowOptions);\n      const overflows = [];\n      let overflowsData = ((_middlewareData$flip = middlewareData.flip) == null ? void 0 : _middlewareData$flip.overflows) || [];\n      if (checkMainAxis) {\n        overflows.push(overflow[side]);\n      }\n      if (checkCrossAxis) {\n        const sides = getAlignmentSides(placement, rects, rtl);\n        overflows.push(overflow[sides[0]], overflow[sides[1]]);\n      }\n      overflowsData = [...overflowsData, {\n        placement,\n        overflows\n      }];\n\n      // One or more sides is overflowing.\n      if (!overflows.every(side => side <= 0)) {\n        var _middlewareData$flip2, _overflowsData$filter;\n        const nextIndex = (((_middlewareData$flip2 = middlewareData.flip) == null ? void 0 : _middlewareData$flip2.index) || 0) + 1;\n        const nextPlacement = placements[nextIndex];\n        if (nextPlacement) {\n          // Try next placement and re-run the lifecycle.\n          return {\n            data: {\n              index: nextIndex,\n              overflows: overflowsData\n            },\n            reset: {\n              placement: nextPlacement\n            }\n          };\n        }\n\n        // First, find the candidates that fit on the mainAxis side of overflow,\n        // then find the placement that fits the best on the main crossAxis side.\n        let resetPlacement = (_overflowsData$filter = overflowsData.filter(d => d.overflows[0] <= 0).sort((a, b) => a.overflows[1] - b.overflows[1])[0]) == null ? void 0 : _overflowsData$filter.placement;\n\n        // Otherwise fallback.\n        if (!resetPlacement) {\n          switch (fallbackStrategy) {\n            case 'bestFit':\n              {\n                var _overflowsData$filter2;\n                const placement = (_overflowsData$filter2 = overflowsData.filter(d => {\n                  if (hasFallbackAxisSideDirection) {\n                    const currentSideAxis = getSideAxis(d.placement);\n                    return currentSideAxis === initialSideAxis ||\n                    // Create a bias to the `y` side axis due to horizontal\n                    // reading directions favoring greater width.\n                    currentSideAxis === 'y';\n                  }\n                  return true;\n                }).map(d => [d.placement, d.overflows.filter(overflow => overflow > 0).reduce((acc, overflow) => acc + overflow, 0)]).sort((a, b) => a[1] - b[1])[0]) == null ? void 0 : _overflowsData$filter2[0];\n                if (placement) {\n                  resetPlacement = placement;\n                }\n                break;\n              }\n            case 'initialPlacement':\n              resetPlacement = initialPlacement;\n              break;\n          }\n        }\n        if (placement !== resetPlacement) {\n          return {\n            reset: {\n              placement: resetPlacement\n            }\n          };\n        }\n      }\n      return {};\n    }\n  };\n};\n\nfunction getSideOffsets(overflow, rect) {\n  return {\n    top: overflow.top - rect.height,\n    right: overflow.right - rect.width,\n    bottom: overflow.bottom - rect.height,\n    left: overflow.left - rect.width\n  };\n}\nfunction isAnySideFullyClipped(overflow) {\n  return sides.some(side => overflow[side] >= 0);\n}\n/**\n * Provides data to hide the floating element in applicable situations, such as\n * when it is not in the same clipping context as the reference element.\n * @see https://floating-ui.com/docs/hide\n */\nconst hide = function (options) {\n  if (options === void 0) {\n    options = {};\n  }\n  return {\n    name: 'hide',\n    options,\n    async fn(state) {\n      const {\n        rects\n      } = state;\n      const {\n        strategy = 'referenceHidden',\n        ...detectOverflowOptions\n      } = evaluate(options, state);\n      switch (strategy) {\n        case 'referenceHidden':\n          {\n            const overflow = await detectOverflow(state, {\n              ...detectOverflowOptions,\n              elementContext: 'reference'\n            });\n            const offsets = getSideOffsets(overflow, rects.reference);\n            return {\n              data: {\n                referenceHiddenOffsets: offsets,\n                referenceHidden: isAnySideFullyClipped(offsets)\n              }\n            };\n          }\n        case 'escaped':\n          {\n            const overflow = await detectOverflow(state, {\n              ...detectOverflowOptions,\n              altBoundary: true\n            });\n            const offsets = getSideOffsets(overflow, rects.floating);\n            return {\n              data: {\n                escapedOffsets: offsets,\n                escaped: isAnySideFullyClipped(offsets)\n              }\n            };\n          }\n        default:\n          {\n            return {};\n          }\n      }\n    }\n  };\n};\n\nfunction getBoundingRect(rects) {\n  const minX = min(...rects.map(rect => rect.left));\n  const minY = min(...rects.map(rect => rect.top));\n  const maxX = max(...rects.map(rect => rect.right));\n  const maxY = max(...rects.map(rect => rect.bottom));\n  return {\n    x: minX,\n    y: minY,\n    width: maxX - minX,\n    height: maxY - minY\n  };\n}\nfunction getRectsByLine(rects) {\n  const sortedRects = rects.slice().sort((a, b) => a.y - b.y);\n  const groups = [];\n  let prevRect = null;\n  for (let i = 0; i < sortedRects.length; i++) {\n    const rect = sortedRects[i];\n    if (!prevRect || rect.y - prevRect.y > prevRect.height / 2) {\n      groups.push([rect]);\n    } else {\n      groups[groups.length - 1].push(rect);\n    }\n    prevRect = rect;\n  }\n  return groups.map(rect => rectToClientRect(getBoundingRect(rect)));\n}\n/**\n * Provides improved positioning for inline reference elements that can span\n * over multiple lines, such as hyperlinks or range selections.\n * @see https://floating-ui.com/docs/inline\n */\nconst inline = function (options) {\n  if (options === void 0) {\n    options = {};\n  }\n  return {\n    name: 'inline',\n    options,\n    async fn(state) {\n      const {\n        placement,\n        elements,\n        rects,\n        platform,\n        strategy\n      } = state;\n      // A MouseEvent's client{X,Y} coords can be up to 2 pixels off a\n      // ClientRect's bounds, despite the event listener being triggered. A\n      // padding of 2 seems to handle this issue.\n      const {\n        padding = 2,\n        x,\n        y\n      } = evaluate(options, state);\n      const nativeClientRects = Array.from((await (platform.getClientRects == null ? void 0 : platform.getClientRects(elements.reference))) || []);\n      const clientRects = getRectsByLine(nativeClientRects);\n      const fallback = rectToClientRect(getBoundingRect(nativeClientRects));\n      const paddingObject = getPaddingObject(padding);\n      function getBoundingClientRect() {\n        // There are two rects and they are disjoined.\n        if (clientRects.length === 2 && clientRects[0].left > clientRects[1].right && x != null && y != null) {\n          // Find the first rect in which the point is fully inside.\n          return clientRects.find(rect => x > rect.left - paddingObject.left && x < rect.right + paddingObject.right && y > rect.top - paddingObject.top && y < rect.bottom + paddingObject.bottom) || fallback;\n        }\n\n        // There are 2 or more connected rects.\n        if (clientRects.length >= 2) {\n          if (getSideAxis(placement) === 'y') {\n            const firstRect = clientRects[0];\n            const lastRect = clientRects[clientRects.length - 1];\n            const isTop = getSide(placement) === 'top';\n            const top = firstRect.top;\n            const bottom = lastRect.bottom;\n            const left = isTop ? firstRect.left : lastRect.left;\n            const right = isTop ? firstRect.right : lastRect.right;\n            const width = right - left;\n            const height = bottom - top;\n            return {\n              top,\n              bottom,\n              left,\n              right,\n              width,\n              height,\n              x: left,\n              y: top\n            };\n          }\n          const isLeftSide = getSide(placement) === 'left';\n          const maxRight = max(...clientRects.map(rect => rect.right));\n          const minLeft = min(...clientRects.map(rect => rect.left));\n          const measureRects = clientRects.filter(rect => isLeftSide ? rect.left === minLeft : rect.right === maxRight);\n          const top = measureRects[0].top;\n          const bottom = measureRects[measureRects.length - 1].bottom;\n          const left = minLeft;\n          const right = maxRight;\n          const width = right - left;\n          const height = bottom - top;\n          return {\n            top,\n            bottom,\n            left,\n            right,\n            width,\n            height,\n            x: left,\n            y: top\n          };\n        }\n        return fallback;\n      }\n      const resetRects = await platform.getElementRects({\n        reference: {\n          getBoundingClientRect\n        },\n        floating: elements.floating,\n        strategy\n      });\n      if (rects.reference.x !== resetRects.reference.x || rects.reference.y !== resetRects.reference.y || rects.reference.width !== resetRects.reference.width || rects.reference.height !== resetRects.reference.height) {\n        return {\n          reset: {\n            rects: resetRects\n          }\n        };\n      }\n      return {};\n    }\n  };\n};\n\n// For type backwards-compatibility, the `OffsetOptions` type was also\n// Derivable.\n\nasync function convertValueToCoords(state, options) {\n  const {\n    placement,\n    platform,\n    elements\n  } = state;\n  const rtl = await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating));\n  const side = getSide(placement);\n  const alignment = getAlignment(placement);\n  const isVertical = getSideAxis(placement) === 'y';\n  const mainAxisMulti = ['left', 'top'].includes(side) ? -1 : 1;\n  const crossAxisMulti = rtl && isVertical ? -1 : 1;\n  const rawValue = evaluate(options, state);\n\n  // eslint-disable-next-line prefer-const\n  let {\n    mainAxis,\n    crossAxis,\n    alignmentAxis\n  } = typeof rawValue === 'number' ? {\n    mainAxis: rawValue,\n    crossAxis: 0,\n    alignmentAxis: null\n  } : {\n    mainAxis: rawValue.mainAxis || 0,\n    crossAxis: rawValue.crossAxis || 0,\n    alignmentAxis: rawValue.alignmentAxis\n  };\n  if (alignment && typeof alignmentAxis === 'number') {\n    crossAxis = alignment === 'end' ? alignmentAxis * -1 : alignmentAxis;\n  }\n  return isVertical ? {\n    x: crossAxis * crossAxisMulti,\n    y: mainAxis * mainAxisMulti\n  } : {\n    x: mainAxis * mainAxisMulti,\n    y: crossAxis * crossAxisMulti\n  };\n}\n\n/**\n * Modifies the placement by translating the floating element along the\n * specified axes.\n * A number (shorthand for `mainAxis` or distance), or an axes configuration\n * object may be passed.\n * @see https://floating-ui.com/docs/offset\n */\nconst offset = function (options) {\n  if (options === void 0) {\n    options = 0;\n  }\n  return {\n    name: 'offset',\n    options,\n    async fn(state) {\n      var _middlewareData$offse, _middlewareData$arrow;\n      const {\n        x,\n        y,\n        placement,\n        middlewareData\n      } = state;\n      const diffCoords = await convertValueToCoords(state, options);\n\n      // If the placement is the same and the arrow caused an alignment offset\n      // then we don't need to change the positioning coordinates.\n      if (placement === ((_middlewareData$offse = middlewareData.offset) == null ? void 0 : _middlewareData$offse.placement) && (_middlewareData$arrow = middlewareData.arrow) != null && _middlewareData$arrow.alignmentOffset) {\n        return {};\n      }\n      return {\n        x: x + diffCoords.x,\n        y: y + diffCoords.y,\n        data: {\n          ...diffCoords,\n          placement\n        }\n      };\n    }\n  };\n};\n\n/**\n * Optimizes the visibility of the floating element by shifting it in order to\n * keep it in view when it will overflow the clipping boundary.\n * @see https://floating-ui.com/docs/shift\n */\nconst shift = function (options) {\n  if (options === void 0) {\n    options = {};\n  }\n  return {\n    name: 'shift',\n    options,\n    async fn(state) {\n      const {\n        x,\n        y,\n        placement\n      } = state;\n      const {\n        mainAxis: checkMainAxis = true,\n        crossAxis: checkCrossAxis = false,\n        limiter = {\n          fn: _ref => {\n            let {\n              x,\n              y\n            } = _ref;\n            return {\n              x,\n              y\n            };\n          }\n        },\n        ...detectOverflowOptions\n      } = evaluate(options, state);\n      const coords = {\n        x,\n        y\n      };\n      const overflow = await detectOverflow(state, detectOverflowOptions);\n      const crossAxis = getSideAxis(getSide(placement));\n      const mainAxis = getOppositeAxis(crossAxis);\n      let mainAxisCoord = coords[mainAxis];\n      let crossAxisCoord = coords[crossAxis];\n      if (checkMainAxis) {\n        const minSide = mainAxis === 'y' ? 'top' : 'left';\n        const maxSide = mainAxis === 'y' ? 'bottom' : 'right';\n        const min = mainAxisCoord + overflow[minSide];\n        const max = mainAxisCoord - overflow[maxSide];\n        mainAxisCoord = clamp(min, mainAxisCoord, max);\n      }\n      if (checkCrossAxis) {\n        const minSide = crossAxis === 'y' ? 'top' : 'left';\n        const maxSide = crossAxis === 'y' ? 'bottom' : 'right';\n        const min = crossAxisCoord + overflow[minSide];\n        const max = crossAxisCoord - overflow[maxSide];\n        crossAxisCoord = clamp(min, crossAxisCoord, max);\n      }\n      const limitedCoords = limiter.fn({\n        ...state,\n        [mainAxis]: mainAxisCoord,\n        [crossAxis]: crossAxisCoord\n      });\n      return {\n        ...limitedCoords,\n        data: {\n          x: limitedCoords.x - x,\n          y: limitedCoords.y - y,\n          enabled: {\n            [mainAxis]: checkMainAxis,\n            [crossAxis]: checkCrossAxis\n          }\n        }\n      };\n    }\n  };\n};\n/**\n * Built-in `limiter` that will stop `shift()` at a certain point.\n */\nconst limitShift = function (options) {\n  if (options === void 0) {\n    options = {};\n  }\n  return {\n    options,\n    fn(state) {\n      const {\n        x,\n        y,\n        placement,\n        rects,\n        middlewareData\n      } = state;\n      const {\n        offset = 0,\n        mainAxis: checkMainAxis = true,\n        crossAxis: checkCrossAxis = true\n      } = evaluate(options, state);\n      const coords = {\n        x,\n        y\n      };\n      const crossAxis = getSideAxis(placement);\n      const mainAxis = getOppositeAxis(crossAxis);\n      let mainAxisCoord = coords[mainAxis];\n      let crossAxisCoord = coords[crossAxis];\n      const rawOffset = evaluate(offset, state);\n      const computedOffset = typeof rawOffset === 'number' ? {\n        mainAxis: rawOffset,\n        crossAxis: 0\n      } : {\n        mainAxis: 0,\n        crossAxis: 0,\n        ...rawOffset\n      };\n      if (checkMainAxis) {\n        const len = mainAxis === 'y' ? 'height' : 'width';\n        const limitMin = rects.reference[mainAxis] - rects.floating[len] + computedOffset.mainAxis;\n        const limitMax = rects.reference[mainAxis] + rects.reference[len] - computedOffset.mainAxis;\n        if (mainAxisCoord < limitMin) {\n          mainAxisCoord = limitMin;\n        } else if (mainAxisCoord > limitMax) {\n          mainAxisCoord = limitMax;\n        }\n      }\n      if (checkCrossAxis) {\n        var _middlewareData$offse, _middlewareData$offse2;\n        const len = mainAxis === 'y' ? 'width' : 'height';\n        const isOriginSide = ['top', 'left'].includes(getSide(placement));\n        const limitMin = rects.reference[crossAxis] - rects.floating[len] + (isOriginSide ? ((_middlewareData$offse = middlewareData.offset) == null ? void 0 : _middlewareData$offse[crossAxis]) || 0 : 0) + (isOriginSide ? 0 : computedOffset.crossAxis);\n        const limitMax = rects.reference[crossAxis] + rects.reference[len] + (isOriginSide ? 0 : ((_middlewareData$offse2 = middlewareData.offset) == null ? void 0 : _middlewareData$offse2[crossAxis]) || 0) - (isOriginSide ? computedOffset.crossAxis : 0);\n        if (crossAxisCoord < limitMin) {\n          crossAxisCoord = limitMin;\n        } else if (crossAxisCoord > limitMax) {\n          crossAxisCoord = limitMax;\n        }\n      }\n      return {\n        [mainAxis]: mainAxisCoord,\n        [crossAxis]: crossAxisCoord\n      };\n    }\n  };\n};\n\n/**\n * Provides data that allows you to change the size of the floating element —\n * for instance, prevent it from overflowing the clipping boundary or match the\n * width of the reference element.\n * @see https://floating-ui.com/docs/size\n */\nconst size = function (options) {\n  if (options === void 0) {\n    options = {};\n  }\n  return {\n    name: 'size',\n    options,\n    async fn(state) {\n      var _state$middlewareData, _state$middlewareData2;\n      const {\n        placement,\n        rects,\n        platform,\n        elements\n      } = state;\n      const {\n        apply = () => {},\n        ...detectOverflowOptions\n      } = evaluate(options, state);\n      const overflow = await detectOverflow(state, detectOverflowOptions);\n      const side = getSide(placement);\n      const alignment = getAlignment(placement);\n      const isYAxis = getSideAxis(placement) === 'y';\n      const {\n        width,\n        height\n      } = rects.floating;\n      let heightSide;\n      let widthSide;\n      if (side === 'top' || side === 'bottom') {\n        heightSide = side;\n        widthSide = alignment === ((await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating))) ? 'start' : 'end') ? 'left' : 'right';\n      } else {\n        widthSide = side;\n        heightSide = alignment === 'end' ? 'top' : 'bottom';\n      }\n      const maximumClippingHeight = height - overflow.top - overflow.bottom;\n      const maximumClippingWidth = width - overflow.left - overflow.right;\n      const overflowAvailableHeight = min(height - overflow[heightSide], maximumClippingHeight);\n      const overflowAvailableWidth = min(width - overflow[widthSide], maximumClippingWidth);\n      const noShift = !state.middlewareData.shift;\n      let availableHeight = overflowAvailableHeight;\n      let availableWidth = overflowAvailableWidth;\n      if ((_state$middlewareData = state.middlewareData.shift) != null && _state$middlewareData.enabled.x) {\n        availableWidth = maximumClippingWidth;\n      }\n      if ((_state$middlewareData2 = state.middlewareData.shift) != null && _state$middlewareData2.enabled.y) {\n        availableHeight = maximumClippingHeight;\n      }\n      if (noShift && !alignment) {\n        const xMin = max(overflow.left, 0);\n        const xMax = max(overflow.right, 0);\n        const yMin = max(overflow.top, 0);\n        const yMax = max(overflow.bottom, 0);\n        if (isYAxis) {\n          availableWidth = width - 2 * (xMin !== 0 || xMax !== 0 ? xMin + xMax : max(overflow.left, overflow.right));\n        } else {\n          availableHeight = height - 2 * (yMin !== 0 || yMax !== 0 ? yMin + yMax : max(overflow.top, overflow.bottom));\n        }\n      }\n      await apply({\n        ...state,\n        availableWidth,\n        availableHeight\n      });\n      const nextDimensions = await platform.getDimensions(elements.floating);\n      if (width !== nextDimensions.width || height !== nextDimensions.height) {\n        return {\n          reset: {\n            rects: true\n          }\n        };\n      }\n      return {};\n    }\n  };\n};\n\nexport { arrow, autoPlacement, computePosition, detectOverflow, flip, hide, inline, limitShift, offset, shift, size };\n"],"sourceRoot":""}