{"version":3,"sources":["webpack:////home/git/gitlab/node_modules/lodash/clamp.js","webpack:////home/git/gitlab/node_modules/bootstrap-vue/esm/directives/visible/visible.js","webpack:////home/git/gitlab/node_modules/bootstrap-vue/esm/components/form-textarea/form-textarea.js","webpack:////home/git/gitlab/node_modules/@gitlab/ui/dist/components/base/form/form_textarea/form_textarea.js","webpack:////home/git/gitlab/node_modules/lodash/_baseClamp.js","webpack:////home/git/gitlab/node_modules/visibilityjs/index.js","webpack:////home/git/gitlab/node_modules/@gitlab/ui/dist/components/base/form/form.js","webpack:///./graphql_shared/utils.js","webpack:////home/git/gitlab/node_modules/@gitlab/ui/dist/directives/outside/get_event_like_time_stamp.js","webpack:////home/git/gitlab/node_modules/@gitlab/ui/dist/directives/outside/outside.js","webpack:////home/git/gitlab/node_modules/core-js/modules/esnext.async-iterator.every.js","webpack:////home/git/gitlab/node_modules/visibilityjs/lib/visibility.timers.js","webpack:////home/git/gitlab/node_modules/core-js/modules/esnext.iterator.every.js","webpack:////home/git/gitlab/node_modules/bootstrap-vue/esm/components/form/form.js","webpack:///./lib/utils/vue3compat/get_instance_from_directive.js","webpack:///./vue_shared/directives/validation.js","webpack:////home/git/gitlab/node_modules/@gitlab/ui/dist/components/base/new_dropdowns/constants.js","webpack:////home/git/gitlab/node_modules/@floating-ui/dom/dist/floating-ui.dom.esm.js","webpack:////home/git/gitlab/node_modules/@floating-ui/utils/dist/floating-ui.utils.esm.js","webpack:////home/git/gitlab/node_modules/@gitlab/ui/dist/components/utilities/intersection_observer/intersection_observer.js","webpack:////home/git/gitlab/node_modules/visibilityjs/lib/visibility.core.js","webpack:////home/git/gitlab/node_modules/@gitlab/ui/dist/components/base/new_dropdowns/base_dropdown/base_dropdown.js","webpack:////home/git/gitlab/node_modules/@gitlab/ui/dist/components/base/new_dropdowns/base_dropdown/constants.js","webpack:////home/git/gitlab/node_modules/@floating-ui/core/dist/floating-ui.core.esm.js"],"names":["baseClamp","toNumber","module","exports","number","lower","upper","undefined","_defineProperties","target","props","i","length","descriptor","enumerable","configurable","writable","Object","defineProperty","key","OBSERVER_PROP_NAME","VisibilityObserver","el","options","instance","Constructor","TypeError","_classCallCheck","this","callback","margin","once","observer","visible","doneOnce","createObserver","protoProps","staticProps","value","_this","stop","IntersectionObserver","handler","bind","root","rootMargin","threshold","_unused","observe","entries","entry","isIntersecting","Boolean","intersectionRatio","disconnect","prototype","destroy","_ref","modifiers","forEach","mod","test","concat","toLowerCase","_prevModifiers","VBVisible","componentUpdated","_ref2","vnode","oldValue","unbind","ownKeys","object","enumerableOnly","keys","getOwnPropertySymbols","symbols","filter","sym","getOwnPropertyDescriptor","push","apply","_objectSpread","arguments","source","_defineProperty","getOwnPropertyDescriptors","defineProperties","obj","id","maxRows","noAutoShrink","noResize","rows","wrap","BFormTextarea","name","directives","mixins","listeners","data","heightInPx","computed","type","computedStyle","styles","resize","computedRows","height","overflowY","computedMinRows","math","computedMaxRows","computedAttrs","disabled","required","safeId","form","placeholder","autocomplete","readonly","plaintext","computedAriaInvalid","computedListeners","bvListeners","input","onInput","change","onChange","blur","onBlur","watch","localValue","setHeight","mounted","methods","visibleCallback","$nextTick","computeHeight","$isServer","$el","lineHeight","border","borderTopWidth","borderBottomWidth","padding","paddingTop","paddingBottom","offset","minHeight","oldHeight","scrollHeight","contentRows","render","h","class","computedClass","style","attrs","domProps","on","ref","model","prop","event","__vue_script__","components","inheritAttrs","String","default","submitOnEnter","$listeners","_len","args","Array","_key","$emit","update","_len2","_key2","e","keyCode","metaKey","ctrlKey","__vue_component__","_vm","_h","$createElement","_self","_c","_g","_b","staticClass","nativeOn","_d","keypressEvent","$event","handleKeyPress","$attrs","staticRenderFns","BForm","_t","isGid","startsWith","parseGid","gid","replace","split","getIdFromGraphQLId","rawId","parseInt","Number","isInteger","mutationOperationMode","append","remove","convertToGraphQLId","includes","convertNodeIdsFromGraphQLIds","nodes","_isArray","map","node","toggleQueryPollingByVisibility","queryRef","interval","stopStartQuery","query","Visibility","hidden","stopPolling","startPolling","etagQueryHeaders","featureCorrelation","etagResource","fetchOptions","method","headers","performance","window","getEventLikeTimeStamp","now","Date","document","createEvent","timeStamp","callbacks","Map","listening","lastMousedown","globalListener","element","bindTimeStamp","originalEvent","contains","onMousedown","OutsideDirective","arg","Error","has","addEventListener","capture","set","delete","size","removeEventListener","$","$every","every","proto","real","predicate","lastTimer","install","hiddenInterval","_time","_timers","_run","isSupported","_listen","_stop","_timed","_wasHidden","_stopRun","runNow","timer","runner","last","call","delay","setTimeout","setInterval","clearInterval","clearTimeout","isHidden","wasHidden","iterate","aCallable","anObject","getIteratorDirect","record","counter","IS_RECORD","INTERRUPTED","stopped","inline","novalidate","validated","functional","children","getInstanceFromDirective","binding","context","defaultFeedbackMap","valueMissing","isInvalid","_el$validity","validity","message","__","urlTypeMismatch","_el$validity2","typeMismatch","focusFirstInvalidInput","formEl","invalidInput","querySelector","focus","getInputElement","createValidator","feedbackMap","reportInvalidInput","formField","fields","isValid","checkValidity","state","feedback","field","values","find","f","elMessage","getAttribute","validationMessage","getFeedbackForElement","isEveryFieldValid","initValidation","customFeedbackMap","elDataMap","WeakMap","inserted","showGlobalValidation","validate","elData","isTouched","isBlurred","markAsTouched","markAsBlurred","get","showValidationFeedback","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","isHTMLElement","HTMLElement","isElement","Element","isShadowRoot","ShadowRoot","isOverflowElement","overflow","overflowX","display","isTableElement","isContainingBlock","safari","isSafari","css","transform","perspective","containerType","backdropFilter","some","willChange","contain","CSS","supports","isLastTraversableNode","min","Math","max","round","floor","createEmptyCoords","v","x","y","getCssDimensions","width","parseFloat","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","getDocumentElement","documentElement","getNodeScroll","scrollLeft","scrollTop","pageXOffset","pageYOffset","getWindowScrollBarX","getParentNode","result","assignedSlot","parentNode","host","getOverflowAncestors","list","scrollableAncestor","getNearestOverflowAncestor","body","isBody","getClientRectFromClippingAncestor","clippingAncestor","strategy","html","clientWidth","clientHeight","visualViewportBased","getViewportRect","scroll","scrollWidth","direction","getDocumentRect","getInnerBoundingClientRect","hasFixedPositionAncestor","stopNode","position","getTrueOffsetParent","polyfill","getOffsetParent","currentNode","getContainingBlock","getRectRelativeToOffsetParent","isOffsetParentAnElement","offsets","offsetRect","platform","getClippingRect","boundary","rootBoundary","clippingAncestors","cache","cachedResult","currentContainingBlockComputedStyle","elementIsFixed","currentNodeIsContaining","ancestor","getClippingElementAncestors","firstClippingAncestor","clippingRect","reduce","accRect","right","bottom","convertOffsetParentRelativeRectToViewportRelativeRect","getDimensions","reference","floating","getOffsetParentFn","getDimensionsFn","getClientRects","from","isRTL","autoUpdate","ancestorScroll","ancestorResize","elementResize","ResizeObserver","layoutShift","animationFrame","referenceEl","ancestors","passive","cleanupIo","onMove","timeoutId","io","cleanup","refresh","skip","isFirstUpdate","handleObserve","ratio","observeMove","frameId","reobserveFrame","resizeObserver","firstEntry","unobserve","cancelAnimationFrame","requestAnimationFrame","prevRefRect","frameLoop","nextRefRect","computePosition","mergedOptions","platformWithCache","sides","alignments","placements","acc","side","oppositeSideMap","oppositeAlignmentMap","start","end","clamp","evaluate","param","getSide","placement","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","expandPaddingObject","rectToClientRect","getObserver","$_gl_intersectionHandler","$_gl_intersectionObserver","global","lastId","self","onVisible","support","listener","_callbacks","afterPrerendering","_doc","webkitHidden","visibilityState","webkitVisibilityState","_change","_init","attachEvent","BASE_DROPDOWN_CLASS","GlButton","GlIcon","Outside","toggleText","textSrOnly","block","category","primary","validator","variant","icon","loading","toggleClass","noCaret","ariaHaspopup","toggleId","ariaLabelledby","mainAxis","fluidWidth","positioningStrategy","openedYet","baseDropdownId","_this$toggleText","hasNoVisibleToggleText","toggleLabelledBy","isIconOnly","isCaretOnly","$scopedSlots","toggle","isDefaultToggle","is","buttonTextClasses","toggleButtonTextClasses","toggleButtonClasses","ariaAttributes","keydown","onKeydown","click","toggleOptions","attributes","_this$$refs$toggle","$refs","firstElementChild","middleware","allowedPlacements","_this$nonScrollableCo","availableHeight","elements","contentsEl","contentsAvailableHeight","nonScrollableContentHeight","assign","maxHeight","deep","toggleElement","setAttribute","checkToggleFocusable","stopFloating","calculateNonScrollableAreaHeight","MutationObserver","content","childList","subtree","stopAutoUpdate","async","floatingUIConfig","_this$observer","_this$stopAutoUpdate","prevented","startFloating","hasToggled","activeElement","focusToggle","code","tagName","toggleOnEnter","toggleOnSpace","_this$$refs$content","scrollableArea","floatingElementBoundingBox","scrollableAreaBoundingBox","rawName","expression","$options","toggleComponent","tag","toggleAttributes","toggleListeners","_v","_s","_e","panelClasses","indexOf","_k","stopPropagation","preventDefault","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","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","arrow","alignmentOffset","isBasePlacement","overflowsData","_middlewareData$flip2","_overflowsData$filter","nextIndex","_overflowsData$map$so","_middlewareData$offse","diffCoords","mainAxisMulti","crossAxisMulti","rawValue","convertValueToCoords","shift","limiter","mainAxisCoord","crossAxisCoord","maxSide","limitedCoords","isYAxis","heightSide","widthSide","overflowAvailableHeight","overflowAvailableWidth","noShift","availableWidth","maximumClippingWidth","maximumClippingHeight","xMin","xMax","yMin","yMax","nextDimensions"],"mappings":"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","file":"commons-pages.projects.blob.show-pages.projects.forks.new-pages.projects.show-pages.projects.tree.show.7bcc6ec5.chunk.js","sourcesContent":["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","function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nfunction _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }\n\nfunction _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, \"prototype\", { writable: false }); return Constructor; }\n\n// v-b-visible\n// Private visibility check directive\n// Based on IntersectionObserver\n//\n// Usage:\n//  v-b-visibility.<margin>.<once>=\"<callback>\"\n//\n//  Value:\n//  <callback>: method to be called when visibility state changes, receives one arg:\n//     true:  element is visible\n//     false: element is not visible\n//     null:  IntersectionObserver not supported\n//\n//  Modifiers:\n//    <margin>: a positive decimal value of pixels away from viewport edge\n//              before being considered \"visible\". default is 0\n//    <once>:   keyword 'once', meaning when the element becomes visible and\n//              callback is called observation/notification will stop.\n//\n// When used in a render function:\n// export default {\n//   directives: { 'b-visible': VBVisible },\n//   render(h) {\n//     h(\n//       'div',\n//       {\n//         directives: [\n//           { name: 'b-visible', value=this.callback, modifiers: { '123':true, 'once':true } }\n//         ]\n//       }\n//     )\n//   }\nimport { RX_DIGITS } from '../../constants/regex';\nimport { requestAF } from '../../utils/dom';\nimport { isFunction } from '../../utils/inspect';\nimport { looseEqual } from '../../utils/loose-equal';\nimport { clone, keys } from '../../utils/object';\nimport { nextTick } from '../../vue';\nvar OBSERVER_PROP_NAME = '__bv__visibility_observer';\n\nvar VisibilityObserver = /*#__PURE__*/function () {\n  function VisibilityObserver(el, options) {\n    _classCallCheck(this, VisibilityObserver);\n\n    this.el = el;\n    this.callback = options.callback;\n    this.margin = options.margin || 0;\n    this.once = options.once || false;\n    this.observer = null;\n    this.visible = undefined;\n    this.doneOnce = false; // Create the observer instance (if possible)\n\n    this.createObserver();\n  }\n\n  _createClass(VisibilityObserver, [{\n    key: \"createObserver\",\n    value: function createObserver() {\n      var _this = this;\n\n      // Remove any previous observer\n      if (this.observer) {\n        /* istanbul ignore next */\n        this.stop();\n      } // Should only be called once and `callback` prop should be a function\n\n\n      if (this.doneOnce || !isFunction(this.callback)) {\n        /* istanbul ignore next */\n        return;\n      } // Create the observer instance\n\n\n      try {\n        // Future: Possibly add in other modifiers for left/right/top/bottom\n        // offsets, root element reference, and thresholds\n        this.observer = new IntersectionObserver(this.handler.bind(this), {\n          // `null` = 'viewport'\n          root: null,\n          // Pixels away from view port to consider \"visible\"\n          rootMargin: this.margin,\n          // Intersection ratio of el and root (as a value from 0 to 1)\n          threshold: 0\n        });\n      } catch (_unused) {\n        // No IntersectionObserver support, so just stop trying to observe\n        this.doneOnce = true;\n        this.observer = undefined;\n        this.callback(null);\n        return;\n      } // Start observing in a `$nextTick()` (to allow DOM to complete rendering)\n\n      /* istanbul ignore next: IntersectionObserver not supported in JSDOM */\n\n\n      nextTick(function () {\n        requestAF(function () {\n          // Placed in an `if` just in case we were destroyed before\n          // this `requestAnimationFrame` runs\n          if (_this.observer) {\n            _this.observer.observe(_this.el);\n          }\n        });\n      });\n    }\n    /* istanbul ignore next */\n\n  }, {\n    key: \"handler\",\n    value: function handler(entries) {\n      var entry = entries ? entries[0] : {};\n      var isIntersecting = Boolean(entry.isIntersecting || entry.intersectionRatio > 0.0);\n\n      if (isIntersecting !== this.visible) {\n        this.visible = isIntersecting;\n        this.callback(isIntersecting);\n\n        if (this.once && this.visible) {\n          this.doneOnce = true;\n          this.stop();\n        }\n      }\n    }\n  }, {\n    key: \"stop\",\n    value: function stop() {\n      /* istanbul ignore next */\n      this.observer && this.observer.disconnect();\n      this.observer = null;\n    }\n  }]);\n\n  return VisibilityObserver;\n}();\n\nvar destroy = function destroy(el) {\n  var observer = el[OBSERVER_PROP_NAME];\n\n  if (observer && observer.stop) {\n    observer.stop();\n  }\n\n  delete el[OBSERVER_PROP_NAME];\n};\n\nvar bind = function bind(el, _ref) {\n  var value = _ref.value,\n      modifiers = _ref.modifiers;\n  // `value` is the callback function\n  var options = {\n    margin: '0px',\n    once: false,\n    callback: value\n  }; // Parse modifiers\n\n  keys(modifiers).forEach(function (mod) {\n    /* istanbul ignore else: Until <b-img-lazy> is switched to use this directive */\n    if (RX_DIGITS.test(mod)) {\n      options.margin = \"\".concat(mod, \"px\");\n    } else if (mod.toLowerCase() === 'once') {\n      options.once = true;\n    }\n  }); // Destroy any previous observer\n\n  destroy(el); // Create new observer\n\n  el[OBSERVER_PROP_NAME] = new VisibilityObserver(el, options); // Store the current modifiers on the object (cloned)\n\n  el[OBSERVER_PROP_NAME]._prevModifiers = clone(modifiers);\n}; // When the directive options may have been updated (or element)\n\n\nvar componentUpdated = function componentUpdated(el, _ref2, vnode) {\n  var value = _ref2.value,\n      oldValue = _ref2.oldValue,\n      modifiers = _ref2.modifiers;\n  // Compare value/oldValue and modifiers to see if anything has changed\n  // and if so, destroy old observer and create new observer\n\n  /* istanbul ignore next */\n  modifiers = clone(modifiers);\n  /* istanbul ignore next */\n\n  if (el && (value !== oldValue || !el[OBSERVER_PROP_NAME] || !looseEqual(modifiers, el[OBSERVER_PROP_NAME]._prevModifiers))) {\n    // Re-bind on element\n    bind(el, {\n      value: value,\n      modifiers: modifiers\n    }, vnode);\n  }\n}; // When directive un-binds from element\n\n\nvar unbind = function unbind(el) {\n  // Remove the observer\n  destroy(el);\n}; // Export the directive\n\n\nexport var VBVisible = {\n  bind: bind,\n  componentUpdated: componentUpdated,\n  unbind: unbind\n};","function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }\n\nfunction _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }\n\nfunction _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }\n\nimport { extend } from '../../vue';\nimport { NAME_FORM_TEXTAREA } from '../../constants/components';\nimport { PROP_TYPE_BOOLEAN, PROP_TYPE_NUMBER_STRING, PROP_TYPE_STRING } from '../../constants/props';\nimport { getCS, getStyle, isVisible, requestAF, setStyle } from '../../utils/dom';\nimport { isNull } from '../../utils/inspect';\nimport { mathCeil, mathMax, mathMin } from '../../utils/math';\nimport { toInteger, toFloat } from '../../utils/number';\nimport { sortKeys } from '../../utils/object';\nimport { makeProp, makePropsConfigurable } from '../../utils/props';\nimport { formControlMixin, props as formControlProps } from '../../mixins/form-control';\nimport { formSelectionMixin } from '../../mixins/form-selection';\nimport { formSizeMixin, props as formSizeProps } from '../../mixins/form-size';\nimport { formStateMixin, props as formStateProps } from '../../mixins/form-state';\nimport { formTextMixin, props as formTextProps } from '../../mixins/form-text';\nimport { formValidityMixin } from '../../mixins/form-validity';\nimport { idMixin, props as idProps } from '../../mixins/id';\nimport { listenOnRootMixin } from '../../mixins/listen-on-root';\nimport { listenersMixin } from '../../mixins/listeners';\nimport { VBVisible } from '../../directives/visible/visible'; // --- Props ---\n\nexport var props = makePropsConfigurable(sortKeys(_objectSpread(_objectSpread(_objectSpread(_objectSpread(_objectSpread(_objectSpread({}, idProps), formControlProps), formSizeProps), formStateProps), formTextProps), {}, {\n  maxRows: makeProp(PROP_TYPE_NUMBER_STRING),\n  // When in auto resize mode, disable shrinking to content height\n  noAutoShrink: makeProp(PROP_TYPE_BOOLEAN, false),\n  // Disable the resize handle of textarea\n  noResize: makeProp(PROP_TYPE_BOOLEAN, false),\n  rows: makeProp(PROP_TYPE_NUMBER_STRING, 2),\n  // 'soft', 'hard' or 'off'\n  // Browser default is 'soft'\n  wrap: makeProp(PROP_TYPE_STRING, 'soft')\n})), NAME_FORM_TEXTAREA); // --- Main component ---\n// @vue/component\n\nexport var BFormTextarea = /*#__PURE__*/extend({\n  name: NAME_FORM_TEXTAREA,\n  directives: {\n    'b-visible': VBVisible\n  },\n  // Mixin order is important!\n  mixins: [listenersMixin, idMixin, listenOnRootMixin, formControlMixin, formSizeMixin, formStateMixin, formTextMixin, formSelectionMixin, formValidityMixin],\n  props: props,\n  data: function data() {\n    return {\n      heightInPx: null\n    };\n  },\n  computed: {\n    type: function type() {\n      return null;\n    },\n    computedStyle: function computedStyle() {\n      var styles = {\n        // Setting `noResize` to true will disable the ability for the user to\n        // manually resize the textarea. We also disable when in auto height mode\n        resize: !this.computedRows || this.noResize ? 'none' : null\n      };\n\n      if (!this.computedRows) {\n        // Conditionally set the computed CSS height when auto rows/height is enabled\n        // We avoid setting the style to `null`, which can override user manual resize handle\n        styles.height = this.heightInPx; // We always add a vertical scrollbar to the textarea when auto-height is\n        // enabled so that the computed height calculation returns a stable value\n\n        styles.overflowY = 'scroll';\n      }\n\n      return styles;\n    },\n    computedMinRows: function computedMinRows() {\n      // Ensure rows is at least 2 and positive (2 is the native textarea value)\n      // A value of 1 can cause issues in some browsers, and most browsers\n      // only support 2 as the smallest value\n      return mathMax(toInteger(this.rows, 2), 2);\n    },\n    computedMaxRows: function computedMaxRows() {\n      return mathMax(this.computedMinRows, toInteger(this.maxRows, 0));\n    },\n    computedRows: function computedRows() {\n      // This is used to set the attribute 'rows' on the textarea\n      // If auto-height is enabled, then we return `null` as we use CSS to control height\n      return this.computedMinRows === this.computedMaxRows ? this.computedMinRows : null;\n    },\n    computedAttrs: function computedAttrs() {\n      var disabled = this.disabled,\n          required = this.required;\n      return {\n        id: this.safeId(),\n        name: this.name || null,\n        form: this.form || null,\n        disabled: disabled,\n        placeholder: this.placeholder || null,\n        required: required,\n        autocomplete: this.autocomplete || null,\n        readonly: this.readonly || this.plaintext,\n        rows: this.computedRows,\n        wrap: this.wrap || null,\n        'aria-required': this.required ? 'true' : null,\n        'aria-invalid': this.computedAriaInvalid\n      };\n    },\n    computedListeners: function computedListeners() {\n      return _objectSpread(_objectSpread({}, this.bvListeners), {}, {\n        input: this.onInput,\n        change: this.onChange,\n        blur: this.onBlur\n      });\n    }\n  },\n  watch: {\n    localValue: function localValue() {\n      this.setHeight();\n    }\n  },\n  mounted: function mounted() {\n    this.setHeight();\n  },\n  methods: {\n    // Called by intersection observer directive\n\n    /* istanbul ignore next */\n    visibleCallback: function visibleCallback(visible) {\n      if (visible) {\n        // We use a `$nextTick()` here just to make sure any\n        // transitions or portalling have completed\n        this.$nextTick(this.setHeight);\n      }\n    },\n    setHeight: function setHeight() {\n      var _this = this;\n\n      this.$nextTick(function () {\n        requestAF(function () {\n          _this.heightInPx = _this.computeHeight();\n        });\n      });\n    },\n\n    /* istanbul ignore next: can't test getComputedStyle in JSDOM */\n    computeHeight: function computeHeight() {\n      if (this.$isServer || !isNull(this.computedRows)) {\n        return null;\n      }\n\n      var el = this.$el; // Element must be visible (not hidden) and in document\n      // Must be checked after above checks\n\n      if (!isVisible(el)) {\n        return null;\n      } // Get current computed styles\n\n\n      var computedStyle = getCS(el); // Height of one line of text in px\n\n      var lineHeight = toFloat(computedStyle.lineHeight, 1); // Calculate height of border and padding\n\n      var border = toFloat(computedStyle.borderTopWidth, 0) + toFloat(computedStyle.borderBottomWidth, 0);\n      var padding = toFloat(computedStyle.paddingTop, 0) + toFloat(computedStyle.paddingBottom, 0); // Calculate offset\n\n      var offset = border + padding; // Minimum height for min rows (which must be 2 rows or greater for cross-browser support)\n\n      var minHeight = lineHeight * this.computedMinRows + offset; // Get the current style height (with `px` units)\n\n      var oldHeight = getStyle(el, 'height') || computedStyle.height; // Probe scrollHeight by temporarily changing the height to `auto`\n\n      setStyle(el, 'height', 'auto');\n      var scrollHeight = el.scrollHeight; // Place the original old height back on the element, just in case `computedProp`\n      // returns the same value as before\n\n      setStyle(el, 'height', oldHeight); // Calculate content height in 'rows' (scrollHeight includes padding but not border)\n\n      var contentRows = mathMax((scrollHeight - padding) / lineHeight, 2); // Calculate number of rows to display (limited within min/max rows)\n\n      var rows = mathMin(mathMax(contentRows, this.computedMinRows), this.computedMaxRows); // Calculate the required height of the textarea including border and padding (in pixels)\n\n      var height = mathMax(mathCeil(rows * lineHeight + offset), minHeight); // Computed height remains the larger of `oldHeight` and new `height`,\n      // when height is in `sticky` mode (prop `no-auto-shrink` is true)\n\n      if (this.noAutoShrink && toFloat(oldHeight, 0) > height) {\n        return oldHeight;\n      } // Return the new computed CSS height in px units\n\n\n      return \"\".concat(height, \"px\");\n    }\n  },\n  render: function render(h) {\n    return h('textarea', {\n      class: this.computedClass,\n      style: this.computedStyle,\n      directives: [{\n        name: 'b-visible',\n        value: this.visibleCallback,\n        // If textarea is within 640px of viewport, consider it visible\n        modifiers: {\n          '640': true\n        }\n      }],\n      attrs: this.computedAttrs,\n      domProps: {\n        value: this.localValue\n      },\n      on: this.computedListeners,\n      ref: 'input'\n    });\n  }\n});","import { BFormTextarea } from 'bootstrap-vue/esm/index.js';\nimport __vue_normalize__ from 'vue-runtime-helpers/dist/normalize-component.js';\n\nconst model = {\n  prop: 'value',\n  event: 'input'\n};\nvar script = {\n  name: 'GlFormTextarea',\n  components: {\n    BFormTextarea\n  },\n  inheritAttrs: false,\n  model,\n  props: {\n    // This prop is needed to map the v-model correctly\n    // https://alligator.io/vuejs/add-v-model-support/\n    value: {\n      type: String,\n      required: false,\n      default: ''\n    },\n    noResize: {\n      type: Boolean,\n      required: false,\n      default: true\n    },\n    submitOnEnter: {\n      type: Boolean,\n      required: false,\n      default: false\n    }\n  },\n  computed: {\n    listeners() {\n      var _this = this;\n      return {\n        ...this.$listeners,\n        // Swap purpose of input and update events from underlying BFormTextarea.\n        // See https://gitlab.com/gitlab-org/gitlab-ui/-/issues/631.\n        input: function () {\n          for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n            args[_key] = arguments[_key];\n          }\n          /**\n           * Emitted to update the v-model\n           */\n          _this.$emit('update', ...args);\n        },\n        update: function () {\n          for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {\n            args[_key2] = arguments[_key2];\n          }\n          /**\n           * Triggered by user interaction.\n           * Emitted after any formatting (not including 'trim' or 'number' props).\n           * Useful for getting the currently entered value when the 'debounce' or 'lazy' props are set.\n           */\n          _this.$emit(model.event, ...args);\n        }\n      };\n    },\n    keypressEvent() {\n      return this.submitOnEnter ? 'keyup' : null;\n    }\n  },\n  methods: {\n    handleKeyPress(e) {\n      if (e.keyCode === 13 && (e.metaKey || e.ctrlKey)) {\n        this.$emit('submit');\n      }\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('b-form-textarea',_vm._g(_vm._b({staticClass:\"gl-form-input gl-form-textarea\",attrs:{\"no-resize\":_vm.noResize,\"value\":_vm.value},nativeOn:_vm._d({},[_vm.keypressEvent,function($event){return _vm.handleKeyPress.apply(null, arguments)}])},'b-form-textarea',_vm.$attrs,false),_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","/**\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 { BForm } from 'bootstrap-vue/esm/components/form';\nimport __vue_normalize__ from 'vue-runtime-helpers/dist/normalize-component.js';\n\n//\nvar script = {\n  name: 'GlForm',\n  components: {\n    BForm\n  },\n  inheritAttrs: false\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('b-form',_vm._g(_vm._b({},'b-form',_vm.$attrs,false),_vm.$listeners),[_vm._t(\"default\")],2)};\nvar __vue_staticRenderFns__ = [];\n\n  /* style */\n  const __vue_inject_styles__ = undefined;\n  /* scoped */\n  const __vue_scope_id__ = undefined;\n  /* module identifier */\n  const __vue_module_identifier__ = undefined;\n  /* functional template */\n  const __vue_is_functional_template__ = false;\n  /* style inject */\n  \n  /* style inject SSR */\n  \n  /* style inject shadow dom */\n  \n\n  \n  const __vue_component__ = __vue_normalize__(\n    { render: __vue_render__, staticRenderFns: __vue_staticRenderFns__ },\n    __vue_inject_styles__,\n    __vue_script__,\n    __vue_scope_id__,\n    __vue_is_functional_template__,\n    __vue_module_identifier__,\n    false,\n    undefined,\n    undefined,\n    undefined\n  );\n\nexport default __vue_component__;\n","import { isArray } from 'lodash';\nimport Visibility from 'visibilityjs';\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\nconst 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","/**\n * This file is based on Vue's scheduler code:\n * https://github.com/vuejs/vue/blob/v2.6.12/src/core/observer/scheduler.js#L44-L66\n *\n * See the LICENSE file in this directory.\n */\n\nconst {\n  performance\n} = window;\n\n/**\n * Get a current timestamp that can be meaningfully compared to an event's\n * `timeStamp` property.\n *\n * Event timestamps can be a DOMHighResTimeStamp (if supported), otherwise\n * a DOMTimeStamp (used by jsdom and older browsers).\n *\n * This function will return a current timestamp of the same type used by the\n * underlying environment when it creates DOM events.\n *\n * See https://developer.mozilla.org/en-US/docs/Web/API/Event/timeStamp for\n * more details.\n *\n * @returns {number}\n */\nconst getEventLikeTimeStamp =\n// If the event timestamp, although evaluated AFTER the Date.now(), is\n// smaller, it means the event is using a hi-res timestamp, and we need to\n// use the hi-res version for event listener timestamps as well.\ntypeof (performance === null || performance === void 0 ? void 0 : performance.now) === 'function' && Date.now() > document.createEvent('Event').timeStamp ? () => performance.now() : () => Date.now();\n\nexport { getEventLikeTimeStamp };\n","import { getEventLikeTimeStamp } from './get_event_like_time_stamp';\n\n/**\n * Map<HTMLElement, { bindTimeStamp: number, callback: Function }>\n */\nconst callbacks = new Map();\n\n/**\n * Is a global listener already set up?\n */\nlet listening = false;\nlet lastMousedown = null;\nconst globalListener = event => {\n  callbacks.forEach((_ref, element) => {\n    let {\n      bindTimeStamp,\n      callback\n    } = _ref;\n    const originalEvent = lastMousedown || event;\n    if (\n    // Ignore events that aren't targeted outside the element\n    element.contains(originalEvent.target) ||\n    // Only consider events triggered after the directive was bound\n    event.timeStamp <= bindTimeStamp) {\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  lastMousedown = null;\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 = () => {\n  if (listening) {\n    return;\n  }\n  document.addEventListener('mousedown', onMousedown);\n  document.addEventListener('click', globalListener, {\n    capture: true\n  });\n  listening = true;\n  lastMousedown = null;\n};\nconst stopListening = () => {\n  if (!listening) {\n    return;\n  }\n  document.removeEventListener('mousedown', onMousedown);\n  document.removeEventListener('click', globalListener);\n  listening = false;\n};\nconst bind = (el, _ref2) => {\n  let {\n    value,\n    arg = 'click'\n  } = _ref2;\n  if (typeof value !== 'function') {\n    throw new Error(`[GlOutsideDirective] Value must be a function; got ${typeof value}!`);\n  }\n  if (arg !== 'click') {\n    throw new Error(`[GlOutsideDirective] Cannot bind ${arg} events; only click events are currently supported!`);\n  }\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  if (!listening) {\n    startListening();\n  }\n  callbacks.set(el, {\n    bindTimeStamp: getEventLikeTimeStamp(),\n    callback: value\n  });\n};\nconst unbind = el => {\n  callbacks.delete(el);\n  if (callbacks.size === 0) {\n    stopListening();\n  }\n};\nconst OutsideDirective = {\n  bind,\n  unbind\n};\n\nexport { OutsideDirective };\n","'use strict';\nvar $ = require('../internals/export');\nvar $every = require('../internals/async-iterator-iteration').every;\n\n// `AsyncIterator.prototype.every` method\n// https://github.com/tc39/proposal-async-iterator-helpers\n$({ target: 'AsyncIterator', proto: true, real: true }, {\n  every: function every(predicate) {\n    return $every(this, predicate);\n  }\n});\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","'use strict';\nvar $ = require('../internals/export');\nvar iterate = require('../internals/iterate');\nvar aCallable = require('../internals/a-callable');\nvar anObject = require('../internals/an-object');\nvar getIteratorDirect = require('../internals/get-iterator-direct');\n\n// `Iterator.prototype.every` method\n// https://github.com/tc39/proposal-iterator-helpers\n$({ target: 'Iterator', proto: true, real: true }, {\n  every: function every(predicate) {\n    anObject(this);\n    aCallable(predicate);\n    var record = getIteratorDirect(this);\n    var counter = 0;\n    return !iterate(record, function (value, stop) {\n      if (!predicate(value, counter++)) return stop();\n    }, { IS_RECORD: true, INTERRUPTED: true }).stopped;\n  }\n});\n","import { extend, mergeData } from '../../vue';\nimport { NAME_FORM } from '../../constants/components';\nimport { PROP_TYPE_BOOLEAN, PROP_TYPE_STRING } from '../../constants/props';\nimport { makeProp, makePropsConfigurable } from '../../utils/props'; // --- Props ---\n\nexport var props = makePropsConfigurable({\n  id: makeProp(PROP_TYPE_STRING),\n  inline: makeProp(PROP_TYPE_BOOLEAN, false),\n  novalidate: makeProp(PROP_TYPE_BOOLEAN, false),\n  validated: makeProp(PROP_TYPE_BOOLEAN, false)\n}, NAME_FORM); // --- Main component ---\n// @vue/component\n\nexport var BForm = /*#__PURE__*/extend({\n  name: NAME_FORM,\n  functional: true,\n  props: props,\n  render: function render(h, _ref) {\n    var props = _ref.props,\n        data = _ref.data,\n        children = _ref.children;\n    return h('form', mergeData(data, {\n      class: {\n        'form-inline': props.inline,\n        'was-validated': props.validated\n      },\n      attrs: {\n        id: props.id,\n        novalidate: props.novalidate\n      }\n    }), children);\n  }\n});","// See https://v3-migration.vuejs.org/breaking-changes/custom-directives.html#edge-case-accessing-the-component-instance\nexport function getInstanceFromDirective({ binding, vnode }) {\n  if (binding.instance) {\n    // this is Vue.js 3, even in compat mode\n    return binding.instance;\n  }\n\n  return vnode.context;\n}\n","import { __ } from '~/locale';\nimport { getInstanceFromDirective } from '~/lib/utils/vue3compat/get_instance_from_directive';\n\n/**\n * Validation messages will take priority based on the property order.\n *\n * For example:\n * { valueMissing: {...}, urlTypeMismatch: {...} }\n *\n * `valueMissing` will be displayed the user has entered a value\n *  after that, if the input is not a valid URL then `urlTypeMismatch` will show\n */\nconst defaultFeedbackMap = {\n  valueMissing: {\n    isInvalid: (el) => el.validity?.valueMissing,\n    message: __('Please fill out this field.'),\n  },\n  urlTypeMismatch: {\n    isInvalid: (el) => el.type === 'url' && el.validity?.typeMismatch,\n    message: __('Please enter a valid URL format, ex: http://www.example.com/home'),\n  },\n};\n\nconst getFeedbackForElement = (feedbackMap, el) => {\n  const field = Object.values(feedbackMap).find((f) => f.isInvalid(el));\n  let elMessage = null;\n  if (field) {\n    elMessage = el.getAttribute('validation-message');\n  }\n\n  return field?.message || elMessage || el.validationMessage;\n};\n\nconst focusFirstInvalidInput = (e) => {\n  const { target: formEl } = e;\n  const invalidInput = formEl.querySelector('input:invalid');\n\n  if (invalidInput) {\n    invalidInput.focus();\n  }\n};\n\nconst getInputElement = (el) => {\n  return el.querySelector('input') || el;\n};\n\nconst isEveryFieldValid = (form) => Object.values(form.fields).every(({ state }) => state === true);\n\nconst createValidator = (feedbackMap) => ({ el, form, reportInvalidInput = false }) => {\n  const { name } = el;\n\n  if (!name) {\n    if (process.env.NODE_ENV === 'development') {\n      // eslint-disable-next-line no-console\n      console.warn(\n        '[gitlab] the validation directive requires the given input to have \"name\" attribute',\n      );\n    }\n    return;\n  }\n\n  const formField = form.fields[name];\n  const isValid = el.checkValidity();\n\n  // This makes sure we always report valid fields - this can be useful for cases where the consuming\n  // component's logic depends on certain fields being in a valid state.\n  // Invalid input, on the other hand, should only be reported once we want to display feedback to the user.\n  // (eg.: After a field has been touched and moved away from, a submit-button has been clicked, ...)\n  formField.state = reportInvalidInput ? isValid : isValid || null;\n  formField.feedback = reportInvalidInput ? getFeedbackForElement(feedbackMap, el) : '';\n\n  // eslint-disable-next-line no-param-reassign\n  form.state = isEveryFieldValid(form);\n};\n\n/**\n * Takes an object that allows to add or change custom feedback messages.\n * See possibilities here: https://developer.mozilla.org/en-US/docs/Web/API/ValidityState\n *\n * The passed in object will be merged with the built-in feedback\n * so it is possible to override a built-in message.\n *\n * @example\n * validate({\n *   tooLong: {\n *     isInvalid: el => el.validity.tooLong === true,\n *     message: 'Your custom feedback'\n *   }\n * })\n *\n * @example\n *   validate({\n *     valueMissing: {\n *       message: 'Your custom feedback'\n *     }\n *   })\n *\n * @param {Object<string, { message: string, isValid: ?function}>} customFeedbackMap\n * @returns {{ inserted: function, update: function }} validateDirective\n */\nexport default function initValidation(customFeedbackMap = {}) {\n  const feedbackMap = { ...defaultFeedbackMap, ...customFeedbackMap };\n  const elDataMap = new WeakMap();\n\n  return {\n    inserted(element, binding, vnode) {\n      const { arg: showGlobalValidation } = binding;\n      const el = getInputElement(element);\n      const { form: formEl } = el;\n      const instance = getInstanceFromDirective({ binding, vnode });\n\n      const validate = createValidator(feedbackMap);\n      const elData = { validate, isTouched: false, isBlurred: false };\n\n      elDataMap.set(el, elData);\n\n      el.addEventListener('input', function markAsTouched() {\n        elData.isTouched = true;\n        // once the element has been marked as touched we can stop listening on the 'input' event\n        el.removeEventListener('input', markAsTouched);\n      });\n\n      el.addEventListener('blur', function markAsBlurred({ target }) {\n        if (elData.isTouched) {\n          elData.isBlurred = true;\n          validate({ el: target, form: instance.form, reportInvalidInput: true });\n          // this event handler can be removed, since the live-feedback in `update` takes over\n          el.removeEventListener('blur', markAsBlurred);\n        }\n      });\n\n      if (formEl) {\n        formEl.addEventListener('submit', focusFirstInvalidInput);\n      }\n\n      validate({ el, form: instance.form, reportInvalidInput: showGlobalValidation });\n    },\n    update(element, binding, vnode) {\n      const el = getInputElement(element);\n      const { arg: showGlobalValidation } = binding;\n      const { validate, isTouched, isBlurred } = elDataMap.get(el);\n      const showValidationFeedback = showGlobalValidation || (isTouched && isBlurred);\n\n      const instance = getInstanceFromDirective({ binding, vnode });\n      validate({ el, form: instance.form, reportInvalidInput: showValidationFeedback });\n    },\n  };\n}\n\n/**\n * This is a helper that initialize the form fields structure to be used in initForm\n * @param {*} fieldValues\n * @returns formObject\n */\nconst initFormField = ({ value, required = true, skipValidation = false }) => ({\n  value,\n  required,\n  state: skipValidation ? true : null,\n  feedback: null,\n});\n\n/**\n * This is a helper that initialize the form structure that is compliant to be used with the validation directive\n *\n * @example\n * const form initForm = initForm({\n *   fields: {\n *     name: {\n *       value: 'lorem'\n *     },\n *     description: {\n *       value: 'ipsum',\n *       required: false,\n *       skipValidation: true\n *     }\n *   }\n * })\n *\n * @example\n * const form initForm = initForm({\n *   state: true,   // to override\n *   foo: {         // something custom\n *     bar: 'lorem'\n *   },\n *   fields: {...}\n * })\n *\n * @param {*} formObject\n * @returns form\n */\nexport const initForm = ({ fields = {}, ...rest } = {}) => {\n  const initFields = Object.fromEntries(\n    Object.entries(fields).map(([fieldName, fieldValues]) => {\n      return [fieldName, initFormField(fieldValues)];\n    }),\n  );\n\n  return {\n    state: false,\n    showValidation: false,\n    ...rest,\n    fields: initFields,\n  };\n};\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  return {\n    ...rect,\n    top: rect.y,\n    left: rect.x,\n    right: rect.x + rect.width,\n    bottom: rect.y + rect.height\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 memoize from 'lodash/memoize';\nimport __vue_normalize__ from 'vue-runtime-helpers/dist/normalize-component.js';\n\nconst getObserver = memoize(options => new IntersectionObserver(entries => {\n  entries.forEach(entry => {\n    entry.target.$_gl_intersectionHandler(entry);\n  });\n}, options || {}));\nvar script = {\n  name: 'GlIntersectionObserver',\n  props: {\n    /**\n     * Extra options to pass directly to the intersection observer API.\n     */\n    options: {\n      type: Object,\n      required: false,\n      default: null\n    }\n  },\n  mounted() {\n    const observer = getObserver(this.options);\n    this.$el.$_gl_intersectionHandler = entry => {\n      /**\n       * Emitted when the element's visibility changes\n       */\n      this.$emit('update', entry);\n      if (entry.isIntersecting) {\n        /**\n         * Emitted when the element appears on the page\n         */\n        this.$emit('appear');\n      } else {\n        /**\n         * Emitted when the element disappears from the page\n         */\n        this.$emit('disappear');\n      }\n    };\n    this.$el.$_gl_intersectionObserver = observer;\n    observer.observe(this.$el);\n  },\n  destroyed() {\n    this.$el.$_gl_intersectionObserver.unobserve(this.$el);\n    delete this.$el.$_gl_intersectionHandler;\n    delete this.$el.$_gl_intersectionObserver;\n  },\n  // Expose getObserver method for tests\n  getObserver\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',[_vm._t(\"default\")],2)};\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, 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 { isElementFocusable, isElementTabbable, logWarning } from '../../../../utils/utils';\nimport GlButton from '../../button/button';\nimport GlIcon from '../../icon/icon';\nimport { OutsideDirective } from '../../../../directives/outside/outside';\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: 'left',\n      validator: value => Object.keys(dropdownPlacements).includes(value)\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    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        'gl-new-dropdown-icon-only btn-icon': this.isIconOnly,\n        'gl-new-dropdown-toggle-no-caret': this.noCaret,\n        'gl-new-dropdown-caret-only': 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-display-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        }), 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 hasToggled = await this.toggle(event);\n      if (!this.$el.contains(document.activeElement)) {\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\",value:(_vm.close),expression:\"close\"}],class:[_vm.$options.BASE_DROPDOWN_CLASS, { 'gl-display-block!': _vm.block }]},[_c(_vm.toggleComponent,_vm._g(_vm._b({ref:\"toggle\",tag:\"component\",attrs:{\"id\":_vm.toggleId,\"data-testid\":\"base-dropdown-toggle\"}},'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      continue;\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    ...rects.floating,\n    x,\n    y\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    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 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      if (!specifiedFallbackPlacements && fallbackAxisSideDirection !== 'none') {\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$map$so;\n                const placement = (_overflowsData$map$so = overflowsData.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$map$so[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: 0,\n    crossAxis: 0,\n    alignmentAxis: null,\n    ...rawValue\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        }\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      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 overflowAvailableHeight = height - overflow[heightSide];\n      const overflowAvailableWidth = width - overflow[widthSide];\n      const noShift = !state.middlewareData.shift;\n      let availableHeight = overflowAvailableHeight;\n      let availableWidth = overflowAvailableWidth;\n      if (isYAxis) {\n        const maximumClippingWidth = width - overflow.left - overflow.right;\n        availableWidth = alignment || noShift ? min(overflowAvailableWidth, maximumClippingWidth) : maximumClippingWidth;\n      } else {\n        const maximumClippingHeight = height - overflow.top - overflow.bottom;\n        availableHeight = alignment || noShift ? min(overflowAvailableHeight, maximumClippingHeight) : 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":""}