{"version":3,"sources":["webpack:///./super_sidebar/components/super_sidebar_toggle.vue","webpack:///./super_sidebar/components/super_sidebar_toggle.vue?918d","webpack:///super_sidebar/components/super_sidebar_toggle.vue","webpack:///./super_sidebar/components/super_sidebar_toggle.vue?074e","webpack:////build/source/node_modules/@gitlab/ui/dist/components/shared_components/clear_icon_button/clear_icon_button.js","webpack:////build/source/node_modules/lodash/clamp.js","webpack:///./graphql_shared/constants.js","webpack:////build/source/node_modules/lodash/_baseClamp.js","webpack:////build/source/node_modules/visibilityjs/index.js","webpack:///./graphql_shared/utils.js","webpack:////build/source/node_modules/@gitlab/ui/dist/directives/outside/outside.js","webpack:////build/source/node_modules/visibilityjs/lib/visibility.timers.js","webpack:////build/source/node_modules/@gitlab/ui/dist/components/base/new_dropdowns/constants.js","webpack:////build/source/node_modules/@floating-ui/dom/dist/floating-ui.dom.esm.js","webpack:////build/source/node_modules/@floating-ui/utils/dist/floating-ui.utils.esm.js","webpack:///./super_sidebar/super_sidebar_collapsed_state_manager.js","webpack:////build/source/node_modules/@gitlab/ui/dist/components/base/search_box_by_type/search_box_by_type.js","webpack:////build/source/node_modules/visibilityjs/lib/visibility.core.js","webpack:////build/source/node_modules/@gitlab/ui/dist/components/base/new_dropdowns/base_dropdown/base_dropdown.js","webpack:////build/source/node_modules/@gitlab/ui/dist/components/base/new_dropdowns/base_dropdown/constants.js","webpack:////build/source/node_modules/@floating-ui/core/dist/floating-ui.core.esm.js"],"names":["components","GlButton","directives","GlTooltip","GlTooltipDirective","mixins","Tracking","mixin","props","type","String","required","default","i18n","primaryNavigationSidebar","__","tooltipCollapse","placement","container","title","tooltipExpand","data","sidebarState","computed","isTypeCollapse","isTypeExpand","tooltip","$options","ariaExpanded","mounted","$root","$on","onTooltipShow","beforeUnmount","$off","methods","toggle","track","label","property","toggleSuperSidebarCollapsed","focusOtherToggle","_this","$nextTick","document","querySelector","JS_TOGGLE_EXPAND_CLASS","focus","bvEvent","target","$el","isCollapsed","isPeek","isHoverPeek","preventDefault","component","_c","this","_self","name","rawName","value","expression","attrs","on","__vue_script__","tooltipContainer","validator","HTMLElement","__vue_component__","render","_h","$createElement","_g","modifiers","staticClass","$listeners","staticRenderFns","undefined","baseClamp","toNumber","module","exports","number","lower","upper","MINIMUM_SEARCH_LENGTH","TYPENAME_BOARD","TYPENAME_CI_BUILD","TYPENAME_CI_RUNNER","TYPENAME_CI_PIPELINE","TYPENAME_CI_STAGE","TYPENAME_CI_TRIGGER","TYPENAME_CI_VARIABLE","TYPENAME_COMMIT_STATUS","TYPENAME_CONTAINER_REPOSITORY","TYPENAME_CRM_CONTACT","TYPENAME_CRM_ORGANIZATION","TYPENAME_DESIGN_VERSION","TYPENAME_DISCUSSION","TYPENAME_DISCUSSION_NOTE","TYPENAME_EPIC","TYPENAME_EPIC_BOARD","TYPENAME_FEATURE_FLAG","TYPENAME_GROUP","TYPENAME_ISSUE","TYPENAME_ITERATION","TYPENAME_ITERATIONS_CADENCE","TYPENAME_LABEL","TYPENAME_MEMBER_ROLE","TYPENAME_MERGE_REQUEST","TYPENAME_MILESTONE","TYPENAME_NOTE","TYPENAME_PACKAGES_PACKAGE","TYPENAME_PROJECT","TYPENAME_SCANNER_PROFILE","TYPENAME_SITE_PROFILE","TYPENAME_TODO","TYPENAME_USER","TYPENAME_VULNERABILITY","TYPENAME_WORK_ITEM","TYPENAME_WORK_ITEM_RELATED_BRANCH","TYPE_ORGANIZATION","TYPE_USERS_SAVED_REPLY","TYPE_WORKSPACE","TYPE_COMPLIANCE_FRAMEWORK","QUERY_PARAM_START_CURSOR","QUERY_PARAM_END_CURSOR","isGid","id","startsWith","parseGid","gid","replace","split","getIdFromGraphQLId","rawId","parseInt","Number","isInteger","getTypeFromGraphQLId","mutationOperationMode","append","remove","convertToGraphQLId","TypeError","includes","convertToGraphQLIds","ids","map","convertNodeIdsFromGraphQLIds","nodes","_isArray","node","getNodesOrDefault","queryData","nodesField","_queryData$nodesField","toggleQueryPollingByVisibility","queryRef","interval","stopStartQuery","query","Visibility","hidden","stopPolling","startPolling","change","bind","etagQueryHeaders","featureCorrelation","etagResource","fetchOptions","method","headers","calculateGraphQLPaginationQueryParams","startCursor","endCursor","routeQuery","start_cursor","end_cursor","callbacks","Map","activeEventTypes","Set","lastMousedown","globalListener","event","forEach","_ref","element","callback","eventTypes","originalEvent","contains","e","onMousedown","OutsideDirective","el","bindings","_ref3","arg","modifiersList","Object","keys","length","parseBinding","has","set","eventType","addEventListener","capture","add","startListening","unbind","entry","get","eventTypesToUnbind","delete","values","every","_ref2","removeEventListener","window","lastTimer","install","hiddenInterval","_time","_timers","visible","_run","isSupported","_listen","stop","_stop","_timed","_wasHidden","_stopRun","runNow","timer","runner","last","Date","call","delay","setTimeout","setInterval","clearInterval","clearTimeout","isHidden","wasHidden","i","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$ownerDocument","ownerDocument","defaultView","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","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","disconnect","refresh","skip","threshold","rootMargin","isFirstUpdate","handleObserve","entries","ratio","intersectionRatio","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","getAlignment","getOppositeAxis","axis","getAxisLength","getSideAxis","getAlignmentAxis","getAlignmentSides","rects","rtl","alignment","alignmentAxis","mainAlignmentSide","getOppositePlacement","getExpandedPlacements","oppositePlacement","getOppositeAlignmentPlacement","getOppositeAxisPlacements","flipAlignment","isStart","lr","rl","tb","bt","getSideList","getPaddingObject","padding","expandPaddingObject","rectToClientRect","findPage","classList","isDesktopBreakpoint","bp","windowWidth","breakpoints","xl","collapsed","saveCookie","isPeekable","hasPeeked","wasHoverPeek","setCookie","expires","initSuperSidebarCollapsedState","forceDesktopExpandedSidebar","getCookie","bindSuperSidebarCollapsedEvents","previousWindowWidth","innerWidth","_debounce","newWindowWidth","collapsedBeforeResize","collapsedAfterResize","GlClearIconButton","GlIcon","GlFormInput","GlLoadingIcon","inheritAttrs","model","prop","borderless","Boolean","clearButtonTitle","disabled","isLoading","attributes","placeholder","$attrs","input","onInput","focusin","onFocusin","focusout","onFocusout","hasValue","_this$$refs$input","_this$$refs$clearButt","$refs","clearButton","focusInput","$emit","relatedTarget","isInputOrClearButton","_vm","_v","_b","ref","class","inputAttributes","inputListeners","showClearButton","_e","$event","stopPropagation","clearInput","apply","arguments","global","lastId","self","onVisible","support","listener","state","_callbacks","afterPrerendering","_doc","webkitHidden","visibilityState","webkitVisibilityState","_change","_init","attachEvent","BASE_DROPDOWN_CLASS","Outside","toggleText","textSrOnly","block","category","primary","variant","size","icon","loading","toggleClass","noCaret","ariaHaspopup","toggleId","ariaLabelledby","offset","mainAxis","fluidWidth","positioningStrategy","openedYet","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","_this$nonScrollableCo","availableHeight","elements","contentsEl","contentsAvailableHeight","nonScrollableContentHeight","assign","style","maxHeight","watch","deep","key","toggleElement","setAttribute","checkToggleFocusable","stopFloating","calculateNonScrollableAreaHeight","observer","MutationObserver","content","childList","subtree","stopAutoUpdate","async","floatingUIConfig","_this$observer","_this$stopAutoUpdate","prevented","startFloating","hadFocusWithin","activeElement","hasToggled","focusToggle","code","tagName","toggleOnEnter","toggleOnSpace","_this$$refs$content","scrollableArea","floatingElementBoundingBox","scrollableAreaBoundingBox","toggleComponent","tag","indexOf","_k","keyCode","close","toggleAttributes","toggleListeners","_t","_s","panelClasses","closeAndFocus","computeCoordsFromPlacement","sideAxis","alignLength","isVertical","commonX","commonY","commonAlign","coords","config","validMiddleware","getElementRects","statefulPlacement","middlewareData","resetCount","fn","nextX","nextY","reset","initialPlacement","detectOverflow","_await$platform$isEle","elementContext","altBoundary","paddingObject","clippingClientRect","offsetScale","elementClientRect","arrow","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-44c6c18e.ddad2718.chunk.js","sourcesContent":["var render = function render(){var _vm=this,_c=_vm._self._c;return _c('gl-button',{directives:[{name:\"gl-tooltip\",rawName:\"v-gl-tooltip\",value:(_vm.tooltip),expression:\"tooltip\"}],attrs:{\"aria-controls\":\"super-sidebar\",\"aria-expanded\":_vm.ariaExpanded,\"aria-label\":_vm.$options.i18n.primaryNavigationSidebar,\"icon\":\"sidebar\",\"category\":\"tertiary\"},on:{\"click\":_vm.toggle}})\n}\nvar staticRenderFns = []\n\nexport { render, staticRenderFns }","import mod from \"-!../../../../../node_modules/thread-loader/dist/cjs.js??ref--13-0!../../../../../node_modules/babel-loader/lib/index.js??ref--13-1!../../../../../node_modules/vue-loader/lib/index.js??vue-loader-options!./super_sidebar_toggle.vue?vue&type=script&lang=js\"; export default mod; export * from \"-!../../../../../node_modules/thread-loader/dist/cjs.js??ref--13-0!../../../../../node_modules/babel-loader/lib/index.js??ref--13-1!../../../../../node_modules/vue-loader/lib/index.js??vue-loader-options!./super_sidebar_toggle.vue?vue&type=script&lang=js\"","<script>\nimport { GlButton, GlTooltipDirective } from '@gitlab/ui';\nimport { __ } from '~/locale';\nimport Tracking from '~/tracking';\nimport { JS_TOGGLE_EXPAND_CLASS, sidebarState } from '../constants';\nimport { toggleSuperSidebarCollapsed } from '../super_sidebar_collapsed_state_manager';\n\nexport default {\n  components: {\n    GlButton,\n  },\n  directives: {\n    GlTooltip: GlTooltipDirective,\n  },\n  mixins: [Tracking.mixin()],\n  props: {\n    type: {\n      type: String,\n      required: false,\n      default: 'expand',\n    },\n  },\n  i18n: {\n    primaryNavigationSidebar: __('Primary navigation sidebar'),\n  },\n  tooltipCollapse: {\n    placement: 'bottom',\n    container: 'super-sidebar',\n    title: __('Hide sidebar'),\n  },\n  tooltipExpand: {\n    placement: 'right',\n    title: __('Keep sidebar visible'),\n  },\n  data() {\n    return sidebarState;\n  },\n  computed: {\n    isTypeCollapse() {\n      return this.type === 'collapse';\n    },\n    isTypeExpand() {\n      return this.type === 'expand';\n    },\n    tooltip() {\n      return this.isTypeExpand ? this.$options.tooltipExpand : this.$options.tooltipCollapse;\n    },\n    ariaExpanded() {\n      return String(this.isTypeCollapse);\n    },\n  },\n  mounted() {\n    this.$root.$on('bv::tooltip::show', this.onTooltipShow);\n  },\n  beforeUnmount() {\n    this.$root.$off('bv::tooltip::show', this.onTooltipShow);\n  },\n  methods: {\n    toggle() {\n      this.track(this.isTypeExpand ? 'nav_show' : 'nav_hide', {\n        label: 'nav_toggle',\n        property: 'nav_sidebar',\n      });\n      toggleSuperSidebarCollapsed(!this.isTypeExpand, true);\n      this.focusOtherToggle();\n    },\n    focusOtherToggle() {\n      this.$nextTick(() => {\n        if (!this.isTypeExpand) {\n          document.querySelector(`.${JS_TOGGLE_EXPAND_CLASS}`).focus();\n        }\n      });\n    },\n    onTooltipShow(bvEvent) {\n      if (\n        bvEvent.target !== this.$el ||\n        (this.isTypeCollapse && !this.isCollapsed) ||\n        (this.isTypeExpand && this.isCollapsed) ||\n        this.isPeek ||\n        this.isHoverPeek\n      )\n        return;\n\n      bvEvent.preventDefault();\n    },\n  },\n};\n</script>\n\n<template>\n  <gl-button\n    v-gl-tooltip=\"tooltip\"\n    aria-controls=\"super-sidebar\"\n    :aria-expanded=\"ariaExpanded\"\n    :aria-label=\"$options.i18n.primaryNavigationSidebar\"\n    icon=\"sidebar\"\n    category=\"tertiary\"\n    @click=\"toggle\"\n  />\n</template>\n","import { render, staticRenderFns } from \"./super_sidebar_toggle.vue?vue&type=template&id=34f472e6\"\nimport script from \"./super_sidebar_toggle.vue?vue&type=script&lang=js\"\nexport * from \"./super_sidebar_toggle.vue?vue&type=script&lang=js\"\n\n\n/* normalize component */\nimport normalizer from \"!../../../../../node_modules/vue-loader/lib/runtime/componentNormalizer.js\"\nvar component = normalizer(\n  script,\n  render,\n  staticRenderFns,\n  false,\n  null,\n  null,\n  null\n  \n)\n\nexport default component.exports","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","export const MINIMUM_SEARCH_LENGTH = 3;\n\nexport const TYPENAME_BOARD = 'Board';\nexport const TYPENAME_CI_BUILD = 'Ci::Build';\nexport const TYPENAME_CI_RUNNER = 'Ci::Runner';\nexport const TYPENAME_CI_PIPELINE = 'Ci::Pipeline';\nexport const TYPENAME_CI_STAGE = 'Ci::Stage';\nexport const TYPENAME_CI_TRIGGER = 'Ci::Trigger';\nexport const TYPENAME_CI_VARIABLE = 'Ci::Variable';\nexport const TYPENAME_COMMIT_STATUS = 'CommitStatus';\nexport const TYPENAME_CONTAINER_REPOSITORY = 'ContainerRepository';\nexport const TYPENAME_CRM_CONTACT = 'CustomerRelations::Contact';\nexport const TYPENAME_CRM_ORGANIZATION = 'CustomerRelations::Organization';\nexport const TYPENAME_DESIGN_VERSION = 'DesignManagement::Version';\nexport const TYPENAME_DISCUSSION = 'Discussion';\nexport const TYPENAME_DISCUSSION_NOTE = 'DiscussionNote';\nexport const TYPENAME_EPIC = 'Epic';\nexport const TYPENAME_EPIC_BOARD = 'Boards::EpicBoard';\nexport const TYPENAME_FEATURE_FLAG = 'FeatureFlag';\nexport const TYPENAME_GROUP = 'Group';\nexport const TYPENAME_ISSUE = 'Issue';\nexport const TYPENAME_ITERATION = 'Iteration';\nexport const TYPENAME_ITERATIONS_CADENCE = 'Iterations::Cadence';\nexport const TYPENAME_LABEL = 'Label';\nexport const TYPENAME_MEMBER_ROLE = 'MemberRole';\nexport const TYPENAME_MERGE_REQUEST = 'MergeRequest';\nexport const TYPENAME_MILESTONE = 'Milestone';\nexport const TYPENAME_NOTE = 'Note';\nexport const TYPENAME_PACKAGES_PACKAGE = 'Packages::Package';\nexport const TYPENAME_PROJECT = 'Project';\nexport const TYPENAME_SCANNER_PROFILE = 'DastScannerProfile';\nexport const TYPENAME_SITE_PROFILE = 'DastSiteProfile';\nexport const TYPENAME_TODO = 'Todo';\nexport const TYPENAME_USER = 'User';\nexport const TYPENAME_VULNERABILITY = 'Vulnerability';\nexport const TYPENAME_WORK_ITEM = 'WorkItem';\nexport const TYPENAME_WORK_ITEM_RELATED_BRANCH = 'WorkItemRelatedBranch';\nexport const TYPE_ORGANIZATION = 'Organizations::Organization';\nexport const TYPE_USERS_SAVED_REPLY = 'Users::SavedReply';\nexport const TYPE_WORKSPACE = 'RemoteDevelopment::Workspace';\nexport const TYPE_COMPLIANCE_FRAMEWORK = 'ComplianceManagement::Framework';\n\nexport const QUERY_PARAM_START_CURSOR = 'start_cursor';\nexport const QUERY_PARAM_END_CURSOR = 'end_cursor';\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","module.exports = require('./lib/visibility.timers.js')\n","import { isArray } from 'lodash';\nimport Visibility from 'visibilityjs';\nimport { QUERY_PARAM_START_CURSOR, QUERY_PARAM_END_CURSOR } from './constants';\n\n/**\n * Ids generated by GraphQL endpoints are usually in the format\n * gid://gitlab/Environments/123. This method checks if the passed id follows that format\n *\n * @param {String|Number} id The id value\n * @returns {Boolean}\n */\nexport const isGid = (id) => {\n  if (typeof id === 'string' && id.startsWith('gid://gitlab/')) {\n    return true;\n  }\n\n  return false;\n};\n\nexport const parseGid = (gid) => {\n  const [type, id] = `${gid}`.replace(/gid:\\/\\/gitlab\\//g, '').split('/');\n  return { type, id };\n};\n\n/**\n * Ids generated by GraphQL endpoints are usually in the format\n * gid://gitlab/Environments/123. This method extracts Id number\n * from the Id path\n *\n * @param {String} gid GraphQL global ID\n * @returns {Number}\n */\nexport const getIdFromGraphQLId = (gid = '') => {\n  const rawId = isGid(gid) ? parseGid(gid).id : gid;\n  const id = parseInt(rawId, 10);\n  return Number.isInteger(id) ? id : null;\n};\n\n/**\n * Ids generated by GraphQL endpoints are usually in the format\n * gid://gitlab/Environments/123. This method extracts Type string\n * from the Id path\n *\n * @param {String} gid GraphQL global ID\n * @returns {String}\n */\nexport const getTypeFromGraphQLId = (gid = '') => {\n  if (!isGid(gid)) return null;\n\n  const { type } = parseGid(gid);\n  return type || null;\n};\n\nexport const mutationOperationMode = {\n  append: 'APPEND',\n  remove: 'REMOVE',\n  replace: 'REPLACE',\n};\n\n/**\n * Ids generated by GraphQL endpoints are usually in the format\n * gid://gitlab/Groups/123. This method takes a type and an id\n * and interpolates the 2 values into the expected GraphQL ID format.\n *\n * @param {String} type The entity type\n * @param {String|Number} id The id value\n * @returns {String}\n */\nexport const convertToGraphQLId = (type, id) => {\n  if (typeof type !== 'string') {\n    throw new TypeError(`type must be a string; got ${typeof type}`);\n  }\n\n  if (!['number', 'string'].includes(typeof id)) {\n    throw new TypeError(`id must be a number or string; got ${typeof id}`);\n  }\n\n  if (isGid(id)) {\n    return id;\n  }\n\n  return `gid://gitlab/${type}/${id}`;\n};\n\n/**\n * Ids generated by GraphQL endpoints are usually in the format\n * gid://gitlab/Groups/123. This method takes a type and an\n * array of ids and tranforms the array values into the expected\n * GraphQL ID format.\n *\n * @param {String} type The entity type\n * @param {Array} ids An array of id values\n * @returns {Array}\n */\nexport const convertToGraphQLIds = (type, ids) => ids.map((id) => convertToGraphQLId(type, id));\n\n/**\n * Ids generated by GraphQL endpoints are usually in the format\n * gid://gitlab/Groups/123. This method takes an array of\n * GraphQL Ids and converts them to a number.\n *\n * @param {Array} ids An array of GraphQL IDs\n * @returns {Array}\n */\nexport const convertFromGraphQLIds = (ids) => {\n  if (!isArray(ids)) {\n    throw new TypeError(`ids must be an array; got ${typeof ids}`);\n  }\n\n  return ids.map((id) => getIdFromGraphQLId(id));\n};\n\n/**\n * Ids generated by GraphQL endpoints are usually in the format\n * gid://gitlab/Groups/123. This method takes an array of nodes\n * and converts the `id` properties from a GraphQL Id to a number.\n *\n * @param {Array} nodes An array of nodes with an `id` property\n * @returns {Array}\n */\nexport const convertNodeIdsFromGraphQLIds = (nodes) => {\n  if (!isArray(nodes)) {\n    throw new TypeError(`nodes must be an array; got ${typeof nodes}`);\n  }\n\n  return nodes.map((node) => (node.id ? { ...node, id: getIdFromGraphQLId(node.id) } : node));\n};\n\n/**\n * This function takes a GraphQL query data as a required argument and\n * the field name to resolve as an optional argument\n * and returns resolved field's data or an empty array\n * @param {Object} queryData\n * @param {String} nodesField (in most cases it will be 'nodes')\n * @returns {Array}\n */\nexport const getNodesOrDefault = (queryData, nodesField = 'nodes') => {\n  return queryData?.[nodesField] ?? [];\n};\n\nexport const toggleQueryPollingByVisibility = (queryRef, interval = 10000) => {\n  const stopStartQuery = (query) => {\n    if (!Visibility.hidden()) {\n      query.startPolling(interval);\n    } else {\n      query.stopPolling();\n    }\n  };\n\n  stopStartQuery(queryRef);\n  Visibility.change(stopStartQuery.bind(null, queryRef));\n};\n\nexport const etagQueryHeaders = (featureCorrelation, etagResource = '') => {\n  return {\n    fetchOptions: {\n      method: 'GET',\n    },\n    headers: {\n      'X-GITLAB-GRAPHQL-FEATURE-CORRELATION': featureCorrelation,\n      'X-GITLAB-GRAPHQL-RESOURCE-ETAG': etagResource,\n      'X-Requested-With': 'XMLHttpRequest',\n    },\n  };\n};\n\nexport const calculateGraphQLPaginationQueryParams = ({\n  startCursor,\n  endCursor,\n  routeQuery: { start_cursor, end_cursor, ...routeQuery },\n}) => {\n  if (startCursor) {\n    return {\n      ...routeQuery,\n      [QUERY_PARAM_START_CURSOR]: startCursor,\n    };\n  }\n\n  if (endCursor) {\n    return {\n      ...routeQuery,\n      [QUERY_PARAM_END_CURSOR]: endCursor,\n    };\n  }\n\n  return routeQuery;\n};\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",";(function (window) {\n    \"use strict\";\n\n    var lastTimer = -1;\n\n    var install = function (Visibility) {\n\n        // Run callback every `interval` milliseconds if page is visible and\n        // every `hiddenInterval` milliseconds if page is hidden.\n        //\n        //   Visibility.every(60 * 1000, 5 * 60 * 1000, function () {\n        //       checkNewMails();\n        //   });\n        //\n        // You can skip `hiddenInterval` and callback will be called only if\n        // page is visible.\n        //\n        //   Visibility.every(1000, function () {\n        //       updateCountdown();\n        //   });\n        //\n        // It is analog of `setInterval(callback, interval)` but use visibility\n        // state.\n        //\n        // It return timer ID, that you can use in `Visibility.stop(id)` to stop\n        // timer (`clearInterval` analog).\n        // Warning: timer ID is different from interval ID from `setInterval`,\n        // so don’t use it in `clearInterval`.\n        //\n        // On change state from hidden to visible timers will be execute.\n        Visibility.every = function (interval, hiddenInterval, callback) {\n            Visibility._time();\n\n            if ( !callback ) {\n                callback = hiddenInterval;\n                hiddenInterval = null;\n            }\n\n            lastTimer += 1;\n            var number = lastTimer;\n\n            Visibility._timers[number] = {\n                visible:  interval,\n                hidden:   hiddenInterval,\n                callback: callback\n            };\n            Visibility._run(number, false);\n\n            if ( Visibility.isSupported() ) {\n                Visibility._listen();\n            }\n            return number;\n        };\n\n        // Stop timer from `every` method by it ID (`every` method return it).\n        //\n        //   slideshow = Visibility.every(5 * 1000, function () {\n        //       changeSlide();\n        //   });\n        //   $('.stopSlideshow').click(function () {\n        //       Visibility.stop(slideshow);\n        //   });\n        Visibility.stop = function(id) {\n            if ( !Visibility._timers[id] ) {\n                return false;\n            }\n            Visibility._stop(id);\n            delete Visibility._timers[id];\n            return true;\n        };\n\n        // Callbacks and intervals added by `every` method.\n        Visibility._timers = { };\n\n        // Initialize variables on page loading.\n        Visibility._time = function () {\n            if ( Visibility._timed ) {\n                return;\n            }\n            Visibility._timed     = true;\n            Visibility._wasHidden = Visibility.hidden();\n\n            Visibility.change(function () {\n                Visibility._stopRun();\n                Visibility._wasHidden = Visibility.hidden();\n            });\n        };\n\n        // Try to run timer from every method by it’s ID. It will be use\n        // `interval` or `hiddenInterval` depending on visibility state.\n        // If page is hidden and `hiddenInterval` is null,\n        // it will not run timer.\n        //\n        // Argument `runNow` say, that timers must be execute now too.\n        Visibility._run = function (id, runNow) {\n            var interval,\n                timer = Visibility._timers[id];\n\n            if ( Visibility.hidden() ) {\n                if ( null === timer.hidden ) {\n                    return;\n                }\n                interval = timer.hidden;\n            } else {\n                interval = timer.visible;\n            }\n\n            var runner = function () {\n                timer.last = new Date();\n                timer.callback.call(window);\n            }\n\n            if ( runNow ) {\n                var now  = new Date();\n                var last = now - timer.last ;\n\n                if ( interval > last ) {\n                    timer.delay = setTimeout(function () {\n                        timer.id = setInterval(runner, interval);\n                        runner();\n                    }, interval - last);\n                } else {\n                    timer.id = setInterval(runner, interval);\n                    runner();\n                }\n\n            } else {\n              timer.id = setInterval(runner, interval);\n            }\n        };\n\n        // Stop timer from `every` method by it’s ID.\n        Visibility._stop = function (id) {\n            var timer = Visibility._timers[id];\n            clearInterval(timer.id);\n            clearTimeout(timer.delay);\n            delete timer.id;\n            delete timer.delay;\n        };\n\n        // Listener for `visibilitychange` event.\n        Visibility._stopRun = function (event) {\n            var isHidden  = Visibility.hidden(),\n                wasHidden = Visibility._wasHidden;\n\n            if ( (isHidden && !wasHidden) || (!isHidden && wasHidden) ) {\n                for ( var i in Visibility._timers ) {\n                    Visibility._stop(i);\n                    Visibility._run(i, !isHidden);\n                }\n            }\n        };\n\n        return Visibility;\n    }\n\n    if ( typeof(module) != 'undefined' && module.exports ) {\n        module.exports = install(require('./visibility.core'));\n    } else {\n        install(window.Visibility)\n    }\n\n})(window);\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",";(function (global) {\n    \"use strict\";\n\n    var lastId = -1;\n\n    // Visibility.js allow you to know, that your web page is in the background\n    // tab and thus not visible to the user. This library is wrap under\n    // Page Visibility API. It fix problems with different vendor prefixes and\n    // add high-level useful functions.\n    var self = {\n\n        // Call callback only when page become to visible for user or\n        // call it now if page is visible now or Page Visibility API\n        // doesn’t supported.\n        //\n        // Return false if API isn’t supported, true if page is already visible\n        // or listener ID (you can use it in `unbind` method) if page isn’t\n        // visible now.\n        //\n        //   Visibility.onVisible(function () {\n        //       startIntroAnimation();\n        //   });\n        onVisible: function (callback) {\n            var support = self.isSupported();\n            if ( !support || !self.hidden() ) {\n                callback();\n                return support;\n            }\n\n            var listener = self.change(function (e, state) {\n                if ( !self.hidden() ) {\n                    self.unbind(listener);\n                    callback();\n                }\n            });\n            return listener;\n        },\n\n        // Call callback when visibility will be changed. First argument for\n        // callback will be original event object, second will be visibility\n        // state name.\n        //\n        // Return listener ID to unbind listener by `unbind` method.\n        //\n        // If Page Visibility API doesn’t supported method will be return false\n        // and callback never will be called.\n        //\n        //   Visibility.change(function(e, state) {\n        //       Statistics.visibilityChange(state);\n        //   });\n        //\n        // It is just proxy to `visibilitychange` event, but use vendor prefix.\n        change: function (callback) {\n            if ( !self.isSupported() ) {\n                return false;\n            }\n            lastId += 1;\n            var number = lastId;\n            self._callbacks[number] = callback;\n            self._listen();\n            return number;\n        },\n\n        // Remove `change` listener by it ID.\n        //\n        //   var id = Visibility.change(function(e, state) {\n        //       firstChangeCallback();\n        //       Visibility.unbind(id);\n        //   });\n        unbind: function (id) {\n            delete self._callbacks[id];\n        },\n\n        // Call `callback` in any state, expect “prerender”. If current state\n        // is “prerender” it will wait until state will be changed.\n        // If Page Visibility API doesn’t supported, it will call `callback`\n        // immediately.\n        //\n        // Return false if API isn’t supported, true if page is already after\n        // prerendering or listener ID (you can use it in `unbind` method)\n        // if page is prerended now.\n        //\n        //   Visibility.afterPrerendering(function () {\n        //       Statistics.countVisitor();\n        //   });\n        afterPrerendering: function (callback) {\n            var support   = self.isSupported();\n            var prerender = 'prerender';\n\n            if ( !support || prerender != self.state() ) {\n                callback();\n                return support;\n            }\n\n            var listener = self.change(function (e, state) {\n                if ( prerender != state ) {\n                    self.unbind(listener);\n                    callback();\n                }\n            });\n            return listener;\n        },\n\n        // Return true if page now isn’t visible to user.\n        //\n        //   if ( !Visibility.hidden() ) {\n        //       VideoPlayer.play();\n        //   }\n        //\n        // It is just proxy to `document.hidden`, but use vendor prefix.\n        hidden: function () {\n            return !!(self._doc.hidden || self._doc.webkitHidden);\n        },\n\n        // Return visibility state: 'visible', 'hidden' or 'prerender'.\n        //\n        //   if ( 'prerender' == Visibility.state() ) {\n        //       Statistics.pageIsPrerendering();\n        //   }\n        //\n        // Don’t use `Visibility.state()` to detect, is page visible, because\n        // visibility states can extend in next API versions.\n        // Use more simpler and general `Visibility.hidden()` for this cases.\n        //\n        // It is just proxy to `document.visibilityState`, but use\n        // vendor prefix.\n        state: function () {\n            return self._doc.visibilityState       ||\n                   self._doc.webkitVisibilityState ||\n                   'visible';\n        },\n\n        // Return true if browser support Page Visibility API.\n        //\n        //   if ( Visibility.isSupported() ) {\n        //       Statistics.startTrackingVisibility();\n        //       Visibility.change(function(e, state)) {\n        //           Statistics.trackVisibility(state);\n        //       });\n        //   }\n        isSupported: function () {\n            return !!(self._doc.visibilityState ||\n                      self._doc.webkitVisibilityState);\n        },\n\n        // Link to document object to change it in tests.\n        _doc: document || {},\n\n        // Callbacks from `change` method, that wait visibility changes.\n        _callbacks: { },\n\n        // Listener for `visibilitychange` event.\n        _change: function(event) {\n            var state = self.state();\n\n            for ( var i in self._callbacks ) {\n                self._callbacks[i].call(self._doc, event, state);\n            }\n        },\n\n        // Set listener for `visibilitychange` event.\n        _listen: function () {\n            if ( self._init ) {\n                return;\n            }\n\n            var event = 'visibilitychange';\n            if ( self._doc.webkitVisibilityState ) {\n                event = 'webkit' + event;\n            }\n\n            var listener = function () {\n                self._change.apply(self, arguments);\n            };\n            if ( self._doc.addEventListener ) {\n                self._doc.addEventListener(event, listener);\n            } else {\n                self._doc.attachEvent(event, listener);\n            }\n            self._init = true;\n        }\n\n    };\n\n    if ( typeof(module) != 'undefined' && module.exports ) {\n        module.exports = self;\n    } else {\n        global.Visibility = self;\n    }\n\n})(this);\n","import uniqueId from 'lodash/uniqueId';\nimport { offset, autoPlacement, shift, 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 } 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(), 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) {\n              return;\n            }\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    async startFloating() {\n      this.calculateNonScrollableAreaHeight();\n      this.observer = new MutationObserver(this.calculateNonScrollableAreaHeight);\n      this.observer.observe(this.$refs.content, {\n        attributes: false,\n        childList: true,\n        subtree: true\n      });\n      this.stopAutoUpdate = autoUpdate(this.toggleElement, this.$refs.content, async () => {\n        const {\n          x,\n          y\n        } = 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        Object.assign(this.$refs.content.style, {\n          left: `${x}px`,\n          top: `${y}px`\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',{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 = 4;\n\nexport { 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":""}