{"version":3,"sources":["webpack:///./src/views/components/JavascriptComponents/Tooltips.vue?9866","webpack:///./node_modules/bootstrap-vue/esm/utils/get-scope-id.js","webpack:///./node_modules/bootstrap-vue/esm/mixins/scoped-style-attrs.js","webpack:///./node_modules/bootstrap-vue/esm/utils/safe-types.js","webpack:///./node_modules/bootstrap-vue/esm/utils/bv-transition.js","webpack:///./node_modules/bootstrap-vue/esm/components/tooltip/helpers/bv-popper.js","webpack:///./node_modules/bootstrap-vue/esm/components/tooltip/helpers/bv-tooltip-template.js","webpack:///./node_modules/bootstrap-vue/esm/directives/popover/popover.js","webpack:///src/views/components/JavascriptComponents/Tooltips.vue","webpack:///./src/views/components/JavascriptComponents/Tooltips.vue?d718","webpack:///./src/views/components/JavascriptComponents/Tooltips.vue","webpack:///./node_modules/popper.js/dist/esm/popper.js"],"names":["_vm","this","_h","$createElement","_c","_self","staticClass","_v","directives","name","rawName","modifiers","attrs","value","expression","staticRenderFns","getScopeId","vm","defaultValue","arguments","length","undefined","$options","_scopeId","_defineProperty","obj","key","Object","defineProperty","enumerable","configurable","writable","computed","scopedStyleAttrs","scopeId","$parent","w","window","HTMLElement","ownKeys","object","enumerableOnly","keys","getOwnPropertySymbols","symbols","filter","sym","getOwnPropertyDescriptor","push","apply","_objectSpread","target","i","source","forEach","getOwnPropertyDescriptors","defineProperties","NO_FADE_PROPS","enterClass","enterActiveClass","enterToClass","leaveClass","leaveActiveClass","leaveToClass","FADE_PROPS","BVTransition","extend","functional","props","noFade","type","Boolean","default","appear","mode","String","transProps","render","h","_ref","children","data","listeners","appearClass","appearActiveClass","appearToClass","css","AttachmentMap","AUTO","TOP","RIGHT","BOTTOM","LEFT","TOPLEFT","TOPRIGHT","RIGHTTOP","RIGHTBOTTOM","BOTTOMLEFT","BOTTOMRIGHT","LEFTTOP","LEFTBOTTOM","OffsetMap","BVPopper","placement","fallbackPlacement","Array","offset","Number","boundary","boundaryPadding","arrowPadding","localShow","attachment","getAttachment","templateType","popperConfig","_this","getOffset","flip","behavior","arrow","element","preventOverflow","padding","boundariesElement","onCreate","originalPlacement","popperPlacementChange","onUpdate","created","_this2","$_popper","$on","el","popperCreate","$nextTick","$destroy","$once","beforeMount","mounted","updated","popperUpdate","beforeDestroy","popperDestroy","destroyed","$el","parentNode","removeChild","methods","hide","toUpperCase","$refs","arrowOffset","parseFloat","width","concat","destroy","scheduleUpdate","renderTemplate","_this3","on","beforeEnter","$emit","afterEnter","beforeLeave","afterLeave","BTooltip","BPopover","component","isBrowser","document","longerTimeoutBrowsers","timeoutDuration","navigator","userAgent","indexOf","microtaskDebounce","fn","called","Promise","resolve","then","taskDebounce","scheduled","setTimeout","supportsMicroTasks","debounce","isFunction","functionToCheck","getType","toString","call","getStyleComputedProperty","property","nodeType","ownerDocument","defaultView","getComputedStyle","getParentNode","nodeName","host","getScrollParent","body","_getStyleComputedProp","overflow","overflowX","overflowY","test","isIE11","MSInputMethodContext","documentMode","isIE10","isIE","version","getOffsetParent","documentElement","noOffsetParent","offsetParent","nextElementSibling","isOffsetContainer","firstElementChild","getRoot","node","findCommonOffsetParent","element1","element2","order","compareDocumentPosition","Node","DOCUMENT_POSITION_FOLLOWING","start","end","range","createRange","setStart","setEnd","commonAncestorContainer","contains","element1root","getScroll","side","upperSide","html","scrollingElement","includeScroll","rect","subtract","scrollTop","scrollLeft","modifier","top","bottom","left","right","getBordersSize","styles","axis","sideA","sideB","getSize","computedStyle","Math","max","parseInt","getWindowSizes","height","classCallCheck","instance","Constructor","TypeError","createClass","descriptor","protoProps","staticProps","prototype","_extends","assign","hasOwnProperty","getClientRect","offsets","getBoundingClientRect","e","result","sizes","clientWidth","clientHeight","horizScrollbar","offsetWidth","vertScrollbar","offsetHeight","getOffsetRectRelativeToArbitraryNode","parent","fixedPosition","isHTML","childrenRect","parentRect","scrollParent","borderTopWidth","borderLeftWidth","marginTop","marginLeft","getViewportOffsetRectRelativeToArtbitraryNode","excludeScroll","relativeOffset","innerWidth","innerHeight","isFixed","getFixedPositionOffsetParent","parentElement","getBoundaries","popper","reference","boundaries","boundariesNode","_getWindowSizes","isPaddingNumber","getArea","computeAutoPlacement","refRect","rects","sortedAreas","map","area","sort","a","b","filteredAreas","_ref2","computedPlacement","variation","split","getReferenceOffsets","state","commonOffsetParent","getOuterSizes","x","marginBottom","y","marginRight","getOppositePlacement","hash","replace","matched","getPopperOffsets","referenceOffsets","popperRect","popperOffsets","isHoriz","mainSide","secondarySide","measurement","secondaryMeasurement","find","arr","check","findIndex","prop","cur","match","runModifiers","ends","modifiersToRun","slice","console","warn","enabled","update","isDestroyed","arrowStyles","attributes","flipped","options","positionFixed","position","isCreated","isModifierEnabled","modifierName","some","getSupportedPropertyName","prefixes","upperProp","charAt","prefix","toCheck","style","removeAttribute","willChange","disableEventListeners","removeOnDestroy","getWindow","attachToScrollParents","event","callback","scrollParents","isBody","addEventListener","passive","setupEventListeners","updateBound","scrollElement","eventsEnabled","enableEventListeners","removeEventListeners","removeEventListener","cancelAnimationFrame","isNumeric","n","isNaN","isFinite","setStyles","unit","setAttributes","setAttribute","applyStyle","arrowElement","applyStyleOnLoad","modifierOptions","getRoundedOffsets","shouldRound","_data$offsets","round","floor","noRound","v","referenceWidth","popperWidth","isVertical","isVariation","sameWidthParity","bothOddWidth","horizontalToInteger","verticalToInteger","isFirefox","computeStyle","legacyGpuAccelerationOption","gpuAcceleration","offsetParentRect","devicePixelRatio","prefixedProperty","invertTop","invertLeft","isModifierRequired","requestingName","requestedName","requesting","isRequired","_requesting","requested","_data$offsets$arrow","querySelector","len","sideCapitalized","toLowerCase","altSide","opSide","arrowElementSize","center","popperMarginSide","popperBorderSide","sideValue","min","getOppositeVariation","placements","validPlacements","clockwise","counter","index","reverse","BEHAVIORS","FLIP","CLOCKWISE","COUNTERCLOCKWISE","placementOpposite","flipOrder","step","refOffsets","overlapsRef","overflowsLeft","overflowsRight","overflowsTop","overflowsBottom","overflowsBoundaries","flippedVariationByRef","flipVariations","flippedVariationByContent","flipVariationsByContent","flippedVariation","keepTogether","toValue","str","size","parseOffset","basePlacement","useHeight","fragments","frag","trim","divider","search","splitRegex","ops","op","mergeWithPrevious","reduce","index2","transformProp","popperStyles","transform","priority","primary","escapeWithReference","secondary","shift","shiftvariation","shiftOffsets","bound","inner","subtractLength","onLoad","Defaults","Popper","requestAnimationFrame","bind","jquery","Utils","global","PopperUtils"],"mappings":"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","file":"js/chunk-52e4de86.8c0af6d1.js","sourcesContent":["var render = function () {var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;return _c('div',{staticClass:\"row\"},[_c('div',{staticClass:\"col-lg-6\"},[_c('small',{staticClass:\"d-block text-uppercase font-weight-bold mb-3\"},[_vm._v(\"Tooltips\")]),_c('base-button',{directives:[{name:\"b-tooltip\",rawName:\"v-b-tooltip.hover.left\",modifiers:{\"hover\":true,\"left\":true}}],staticClass:\"btn-tooltip\",attrs:{\"size\":\"sm\",\"type\":\"primary\",\"title\":\"Tooltip on left\"}},[_vm._v(\"On left\\n        \")]),_c('base-button',{directives:[{name:\"b-tooltip\",rawName:\"v-b-tooltip.hover.top\",modifiers:{\"hover\":true,\"top\":true}}],staticClass:\"btn-tooltip\",attrs:{\"size\":\"sm\",\"type\":\"primary\",\"title\":\"Tooltip on top\"}},[_vm._v(\"On top\\n        \")]),_c('base-button',{directives:[{name:\"b-tooltip\",rawName:\"v-b-tooltip.hover.bottom\",modifiers:{\"hover\":true,\"bottom\":true}}],staticClass:\"btn-tooltip\",attrs:{\"size\":\"sm\",\"type\":\"primary\",\"title\":\"Tooltip on bottom\"}},[_vm._v(\"On bottom\\n        \")]),_c('base-button',{directives:[{name:\"b-tooltip\",rawName:\"v-b-tooltip.hover.right\",modifiers:{\"hover\":true,\"right\":true}}],staticClass:\"btn-tooltip\",attrs:{\"size\":\"sm\",\"type\":\"primary\",\"title\":\"Tooltip on right\"}},[_vm._v(\"On right\\n        \")])],1),_c('div',{staticClass:\"col-lg-6 mt-4 mt-lg-0\"},[_c('small',{staticClass:\"d-block text-uppercase font-weight-bold mb-3\"},[_vm._v(\"Popovers\")]),_c('base-button',{directives:[{name:\"b-popover\",rawName:\"v-b-popover.hover.left\",value:('Vivamus sagittis lacus vel augue laoreet rutrum faucibus.'),expression:\"'Vivamus sagittis lacus vel augue laoreet rutrum faucibus.'\",modifiers:{\"hover\":true,\"left\":true}}],attrs:{\"size\":\"sm\",\"type\":\"default\",\"title\":\"Popover On Left\"}},[_vm._v(\"On left\\n        \")]),_c('base-button',{directives:[{name:\"b-popover\",rawName:\"v-b-popover.hover.left\",value:('Vivamus sagittis lacus vel augue laoreet rutrum faucibus.'),expression:\"'Vivamus sagittis lacus vel augue laoreet rutrum faucibus.'\",modifiers:{\"hover\":true,\"left\":true}}],attrs:{\"size\":\"sm\",\"type\":\"default\",\"title\":\"Popover On Left\"}},[_vm._v(\"On left\\n        \")]),_c('base-button',{directives:[{name:\"b-popover\",rawName:\"v-b-popover.hover.top\",value:('Vivamus sagittis lacus vel augue laoreet rutrum faucibus.'),expression:\"'Vivamus sagittis lacus vel augue laoreet rutrum faucibus.'\",modifiers:{\"hover\":true,\"top\":true}}],attrs:{\"size\":\"sm\",\"type\":\"default\",\"title\":\"Popover On Top\"}},[_vm._v(\"On top\\n        \")]),_c('base-button',{directives:[{name:\"b-popover\",rawName:\"v-b-popover.hover.right\",value:('Vivamus sagittis lacus vel augue laoreet rutrum faucibus.'),expression:\"'Vivamus sagittis lacus vel augue laoreet rutrum faucibus.'\",modifiers:{\"hover\":true,\"right\":true}}],attrs:{\"size\":\"sm\",\"type\":\"default\",\"title\":\"Popover On right\"}},[_vm._v(\"On right\\n        \")]),_c('base-button',{directives:[{name:\"b-popover\",rawName:\"v-b-popover.hover.bottom\",value:('Vivamus sagittis lacus vel augue laoreet rutrum faucibus.'),expression:\"'Vivamus sagittis lacus vel augue laoreet rutrum faucibus.'\",modifiers:{\"hover\":true,\"bottom\":true}}],attrs:{\"size\":\"sm\",\"type\":\"default\",\"title\":\"Popover On bottom\"}},[_vm._v(\"On bottom\\n        \")])],1)])}\nvar staticRenderFns = []\n\nexport { render, staticRenderFns }","// This method returns a component's scoped style attribute name: `data-v-xxxxxxx`\n// The `_scopeId` options property is added by vue-loader when using scoped styles\n// and will be `undefined` if no scoped styles are in use\nvar getScopeId = function getScopeId(vm) {\n  var defaultValue = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;\n  return vm ? vm.$options._scopeId || defaultValue : defaultValue;\n};\n\nexport default getScopeId;","function _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 getScopeId from '../utils/get-scope-id';\nexport default {\n  computed: {\n    scopedStyleAttrs: function scopedStyleAttrs() {\n      var scopeId = getScopeId(this.$parent);\n      return scopeId ? _defineProperty({}, scopeId, '') : {};\n    }\n  }\n};","/**\n * SSR safe types\n */\nimport { hasWindowSupport } from './env';\nvar w = hasWindowSupport ? window : {};\nexport var HTMLElement = w.HTMLElement || Object;","function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (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 = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(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\n// Generic Bootstrap v4 fade (no-fade) transition component\n//\n// Assumes that `show` class is not required when\n// the transition has finished the enter transition\n// (show and fade classes are only applied during transition)\nimport Vue from './vue';\nimport { mergeData } from 'vue-functional-data-merge';\nimport { isPlainObject } from './inspect';\nvar NO_FADE_PROPS = {\n  name: '',\n  enterClass: '',\n  enterActiveClass: '',\n  enterToClass: 'show',\n  leaveClass: 'show',\n  leaveActiveClass: '',\n  leaveToClass: ''\n};\n\nvar FADE_PROPS = _objectSpread({}, NO_FADE_PROPS, {\n  enterActiveClass: 'fade',\n  leaveActiveClass: 'fade'\n});\n\nexport var BVTransition =\n/*#__PURE__*/\nVue.extend({\n  name: 'BVTransition',\n  functional: true,\n  props: {\n    noFade: {\n      // Only applicable to the built in transition\n      // Has no effect if `trans-props` provided\n      type: Boolean,\n      default: false\n    },\n    appear: {\n      // Has no effect if `trans-props` provided\n      type: Boolean,\n      default: false\n    },\n    mode: {\n      // Can be overridden by user supplied trans-props\n      type: String // default: undefined\n\n    },\n    // For user supplied transitions (if needed)\n    transProps: {\n      type: Object,\n      default: null\n    }\n  },\n  render: function render(h, _ref) {\n    var children = _ref.children,\n        data = _ref.data,\n        listeners = _ref.listeners,\n        props = _ref.props;\n    var transProps = props.transProps;\n\n    if (!isPlainObject(transProps)) {\n      transProps = props.noFade ? NO_FADE_PROPS : FADE_PROPS;\n\n      if (props.appear) {\n        // Default the appear classes to equal the enter classes\n        transProps = _objectSpread({}, transProps, {\n          appear: true,\n          appearClass: transProps.enterClass,\n          appearActiveClass: transProps.enterActiveClass,\n          appearToClass: transProps.enterToClass\n        });\n      }\n    }\n\n    transProps = _objectSpread({\n      mode: props.mode\n    }, transProps, {\n      // We always need `css` true\n      css: true\n    });\n    return h('transition', // Any transition event listeners will get merged here\n    mergeData(data, {\n      props: transProps\n    }), children);\n  }\n});\nexport default BVTransition;","// Base on-demand component for tooltip / popover templates\n//\n// Currently:\n//   Responsible for positioning and transitioning the template\n//   Templates are only instantiated when shown, and destroyed when hidden\n//\nimport Vue from '../../../utils/vue';\nimport Popper from 'popper.js';\nimport { getCS, select } from '../../../utils/dom';\nimport { HTMLElement } from '../../../utils/safe-types';\nimport { BVTransition } from '../../../utils/bv-transition';\nvar NAME = 'BVPopper';\nvar AttachmentMap = {\n  AUTO: 'auto',\n  TOP: 'top',\n  RIGHT: 'right',\n  BOTTOM: 'bottom',\n  LEFT: 'left',\n  TOPLEFT: 'top',\n  TOPRIGHT: 'top',\n  RIGHTTOP: 'right',\n  RIGHTBOTTOM: 'right',\n  BOTTOMLEFT: 'bottom',\n  BOTTOMRIGHT: 'bottom',\n  LEFTTOP: 'left',\n  LEFTBOTTOM: 'left'\n};\nvar OffsetMap = {\n  AUTO: 0,\n  TOPLEFT: -1,\n  TOP: 0,\n  TOPRIGHT: +1,\n  RIGHTTOP: -1,\n  RIGHT: 0,\n  RIGHTBOTTOM: +1,\n  BOTTOMLEFT: -1,\n  BOTTOM: 0,\n  BOTTOMRIGHT: +1,\n  LEFTTOP: -1,\n  LEFT: 0,\n  LEFTBOTTOM: +1 // @vue/component\n\n};\nexport var BVPopper =\n/*#__PURE__*/\nVue.extend({\n  name: NAME,\n  props: {\n    target: {\n      // Element that the tooltip/popover is positioned relative to\n      type: HTMLElement,\n      default: null\n    },\n    placement: {\n      type: String,\n      default: 'top'\n    },\n    fallbackPlacement: {\n      type: [String, Array],\n      default: 'flip'\n    },\n    offset: {\n      type: Number,\n      default: 0\n    },\n    boundary: {\n      // 'scrollParent', 'viewport', 'window', or Element\n      type: [String, HTMLElement],\n      default: 'scrollParent'\n    },\n    boundaryPadding: {\n      // Tooltip/popover will try and stay away from\n      // boundary edge by this many pixels\n      type: Number,\n      default: 5\n    },\n    arrowPadding: {\n      // The minimum distance (in `px`) from the edge of the\n      // tooltip/popover that the arrow can be positioned\n      type: Number,\n      default: 6\n    }\n  },\n  data: function data() {\n    return {\n      // reactive props set by parent\n      noFade: false,\n      // State related data\n      localShow: true,\n      attachment: this.getAttachment(this.placement)\n    };\n  },\n  computed: {\n    templateType: function templateType()\n    /* istanbul ignore next */\n    {\n      // Overridden by template component\n      return 'unknown';\n    },\n    popperConfig: function popperConfig() {\n      var _this = this;\n\n      var placement = this.placement;\n      return {\n        placement: this.getAttachment(placement),\n        modifiers: {\n          offset: {\n            offset: this.getOffset(placement)\n          },\n          flip: {\n            behavior: this.fallbackPlacement\n          },\n          // `arrow.element` can also be a reference to an HTML Element\n          // maybe we should make this a `$ref` in the templates?\n          arrow: {\n            element: '.arrow'\n          },\n          preventOverflow: {\n            padding: this.boundaryPadding,\n            boundariesElement: this.boundary\n          }\n        },\n        onCreate: function onCreate(data) {\n          // Handle flipping arrow classes\n          if (data.originalPlacement !== data.placement) {\n            /* istanbul ignore next: can't test in JSDOM */\n            _this.popperPlacementChange(data);\n          }\n        },\n        onUpdate: function onUpdate(data) {\n          // Handle flipping arrow classes\n          _this.popperPlacementChange(data);\n        }\n      };\n    }\n  },\n  created: function created() {\n    var _this2 = this;\n\n    // Note: We are created on-demand, and should be guaranteed that\n    // DOM is rendered/ready by the time the created hook runs\n    this.$_popper = null; // Ensure we show as we mount\n\n    this.localShow = true; // Create popper instance before shown\n\n    this.$on('show', function (el) {\n      _this2.popperCreate(el);\n    }); // Self destruct once hidden\n\n    this.$on('hidden', function () {\n      _this2.$nextTick(_this2.$destroy);\n    }); // If parent is destroyed, ensure we are destroyed\n\n    this.$parent.$once('hook:destroyed', this.$destroy);\n  },\n  beforeMount: function beforeMount() {\n    // Ensure that the attachment position is correct before mounting\n    // as our propsData is added after `new Template({...})`\n    this.attachment = this.getAttachment(this.placement);\n  },\n  mounted: function mounted() {// TBD\n  },\n  updated: function updated() {\n    // Update popper if needed\n    // TODO: Should this be a watcher on `this.popperConfig` instead?\n    this.popperUpdate();\n  },\n  beforeDestroy: function beforeDestroy() {\n    this.popperDestroy();\n  },\n  destroyed: function destroyed() {\n    // Make sure template is removed from DOM\n    var el = this.$el;\n    el && el.parentNode && el.parentNode.removeChild(el);\n  },\n  methods: {\n    // \"Public\" method to trigger hide template\n    hide: function hide() {\n      this.localShow = false;\n    },\n    // Private\n    getAttachment: function getAttachment(placement) {\n      return AttachmentMap[String(placement).toUpperCase()] || 'auto';\n    },\n    getOffset: function getOffset(placement) {\n      if (!this.offset) {\n        // Could set a ref for the arrow element\n        var arrow = this.$refs.arrow || select('.arrow', this.$el);\n        var arrowOffset = (parseFloat(getCS(arrow).width) || 0) + (parseFloat(this.arrowPadding) || 0);\n\n        switch (OffsetMap[String(placement).toUpperCase()] || 0) {\n          case +1:\n            /* istanbul ignore next: can't test in JSDOM */\n            return \"+50%p - \".concat(arrowOffset, \"px\");\n\n          case -1:\n            /* istanbul ignore next: can't test in JSDOM */\n            return \"-50%p + \".concat(arrowOffset, \"px\");\n\n          default:\n            return 0;\n        }\n      }\n      /* istanbul ignore next */\n\n\n      return this.offset;\n    },\n    popperCreate: function popperCreate(el) {\n      this.popperDestroy(); // We use `el` rather than `this.$el` just in case the original\n      // mountpoint root element type was changed by the template\n\n      this.$_popper = new Popper(this.target, el, this.popperConfig);\n    },\n    popperDestroy: function popperDestroy() {\n      this.$_popper && this.$_popper.destroy();\n      this.$_popper = null;\n    },\n    popperUpdate: function popperUpdate() {\n      this.$_popper && this.$_popper.scheduleUpdate();\n    },\n    popperPlacementChange: function popperPlacementChange(data) {\n      // Callback used by popper to adjust the arrow placement\n      this.attachment = this.getAttachment(data.placement);\n    },\n    renderTemplate: function renderTemplate(h)\n    /* istanbul ignore next */\n    {\n      // Will be overridden by templates\n      return h('div');\n    }\n  },\n  render: function render(h) {\n    var _this3 = this;\n\n    // Note: `show` and 'fade' classes are only appled during transition\n    return h(BVTransition, {\n      // Transitions as soon as mounted\n      props: {\n        appear: true,\n        noFade: this.noFade\n      },\n      on: {\n        // Events used by parent component/instance\n        beforeEnter: function beforeEnter(el) {\n          return _this3.$emit('show', el);\n        },\n        afterEnter: function afterEnter(el) {\n          return _this3.$emit('shown', el);\n        },\n        beforeLeave: function beforeLeave(el) {\n          return _this3.$emit('hide', el);\n        },\n        afterLeave: function afterLeave(el) {\n          return _this3.$emit('hidden', el);\n        }\n      }\n    }, [this.localShow ? this.renderTemplate(h) : h()]);\n  }\n});","function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (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 = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(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 Vue from '../../../utils/vue';\nimport scopedStyleAttrsMixin from '../../../mixins/scoped-style-attrs';\nimport { isFunction, isUndefinedOrNull } from '../../../utils/inspect';\nimport { BVPopper } from './bv-popper';\nvar NAME = 'BVTooltipTemplate'; // @vue/component\n\nexport var BVTooltipTemplate =\n/*#__PURE__*/\nVue.extend({\n  name: NAME,\n  extends: BVPopper,\n  mixins: [scopedStyleAttrsMixin],\n  props: {\n    // Other non-reactive (while open) props are pulled in from BVPopper\n    id: {\n      type: String,\n      default: null\n    },\n    html: {\n      // Used only by the directive versions\n      type: Boolean,\n      default: false\n    }\n  },\n  data: function data() {\n    // We use data, rather than props to ensure reactivity\n    // Parent component will directly set this data\n    return {\n      title: '',\n      content: '',\n      variant: null,\n      customClass: null\n    };\n  },\n  computed: {\n    templateType: function templateType() {\n      return 'tooltip';\n    },\n    templateClasses: function templateClasses() {\n      var _ref;\n\n      return [(_ref = {}, _defineProperty(_ref, \"b-\".concat(this.templateType, \"-\").concat(this.variant), this.variant), _defineProperty(_ref, \"bs-\".concat(this.templateType, \"-\").concat(this.attachment), this.attachment), _ref), this.customClass];\n    },\n    templateAttributes: function templateAttributes() {\n      return _objectSpread({\n        id: this.id,\n        role: 'tooltip',\n        tabindex: '-1'\n      }, this.scopedStyleAttrs);\n    },\n    templateListeners: function templateListeners() {\n      var _this = this;\n\n      // Used for hover/focus trigger listeners\n      return {\n        mouseenter: function mouseenter(evt) {\n          /* istanbul ignore next: difficult to test in JSDOM */\n          _this.$emit('mouseenter', evt);\n        },\n        mouseleave: function mouseleave(evt) {\n          /* istanbul ignore next: difficult to test in JSDOM */\n          _this.$emit('mouseleave', evt);\n        },\n        focusin: function focusin(evt) {\n          /* istanbul ignore next: difficult to test in JSDOM */\n          _this.$emit('focusin', evt);\n        },\n        focusout: function focusout(evt) {\n          /* istanbul ignore next: difficult to test in JSDOM */\n          _this.$emit('focusout', evt);\n        }\n      };\n    }\n  },\n  methods: {\n    renderTemplate: function renderTemplate(h) {\n      // Title can be a scoped slot function\n      var $title = isFunction(this.title) ? this.title({}) : isUndefinedOrNull(this.title) ? h() : this.title; // Directive versions only\n\n      var domProps = this.html && !isFunction(this.title) ? {\n        innerHTML: this.title\n      } : {};\n      return h('div', {\n        staticClass: 'tooltip b-tooltip',\n        class: this.templateClasses,\n        attrs: this.templateAttributes,\n        on: this.templateListeners\n      }, [h('div', {\n        ref: 'arrow',\n        staticClass: 'arrow'\n      }), h('div', {\n        staticClass: 'tooltip-inner',\n        domProps: domProps\n      }, [$title])]);\n    }\n  }\n});","function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (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 = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(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 getScopId from '../../utils/get-scope-id';\nimport looseEqual from '../../utils/loose-equal';\nimport { concat } from '../../utils/array';\nimport { getComponentConfig } from '../../utils/config';\nimport { isBrowser } from '../../utils/env';\nimport { isFunction, isObject, isString, isUndefined } from '../../utils/inspect';\nimport { keys } from '../../utils/object';\nimport { BVPopover } from '../../components/popover/helpers/bv-popover'; // Key which we use to store tooltip object on element\n\nvar BV_POPOVER = '__BV_Popover__'; // Default trigger\n\nvar DefaultTrigger = 'click'; // Valid event triggers\n\nvar validTriggers = {\n  focus: true,\n  hover: true,\n  click: true,\n  blur: true,\n  manual: true // Directive modifier test regular expressions. Pre-compile for performance\n\n};\nvar htmlRE = /^html$/i;\nvar noFadeRE = /^nofade$/i;\nvar placementRE = /^(auto|top(left|right)?|bottom(left|right)?|left(top|bottom)?|right(top|bottom)?)$/i;\nvar boundaryRE = /^(window|viewport|scrollParent)$/i;\nvar delayRE = /^d\\d+$/i;\nvar delayShowRE = /^ds\\d+$/i;\nvar delayHideRE = /^dh\\d+$/i;\nvar offsetRE = /^o-?\\d+$/i;\nvar variantRE = /^v-.+$/i; // Build a Popover config based on bindings (if any)\n// Arguments and modifiers take precedence over passed value config object\n\nvar parseBindings = function parseBindings(bindings, vnode)\n/* istanbul ignore next: not easy to test */\n{\n  // We start out with a basic config\n  var NAME = 'BPopover';\n  var config = {\n    title: undefined,\n    content: undefined,\n    trigger: '',\n    // Default set below if needed\n    placement: 'right',\n    fallbackPlacement: 'flip',\n    container: false,\n    // Default of body\n    animation: true,\n    offset: 0,\n    id: null,\n    html: false,\n    delay: getComponentConfig(NAME, 'delay'),\n    boundary: String(getComponentConfig(NAME, 'boundary')),\n    boundaryPadding: parseInt(getComponentConfig(NAME, 'boundaryPadding'), 10) || 0,\n    variant: getComponentConfig(NAME, 'variant'),\n    customClass: getComponentConfig(NAME, 'customClass') // Process `bindings.value`\n\n  };\n\n  if (isString(bindings.value)) {\n    // Value is popover content (html optionally supported)\n    config.content = bindings.value;\n  } else if (isFunction(bindings.value)) {\n    // Content generator function\n    config.content = bindings.value;\n  } else if (isObject(bindings.value)) {\n    // Value is config object, so merge\n    config = _objectSpread({}, config, {}, bindings.value);\n  } // If argument, assume element ID of container element\n\n\n  if (bindings.arg) {\n    // Element ID specified as arg\n    // We must prepend '#' to become a CSS selector\n    config.container = \"#\".concat(bindings.arg);\n  } // If title is not provided, try title attribute\n\n\n  if (isUndefined(config.title)) {\n    // Try attribute\n    var data = vnode.data || {};\n    config.title = data.attrs && data.attrs.title ? data.attrs.title : undefined;\n  } // Normalize delay\n\n\n  if (!isObject(config.delay)) {\n    config.delay = {\n      show: config.delay,\n      hide: config.delay\n    };\n  } // Process modifiers\n\n\n  keys(bindings.modifiers).forEach(function (mod) {\n    if (htmlRE.test(mod)) {\n      // Title/content allows HTML\n      config.html = true;\n    } else if (noFadeRE.test(mod)) {\n      // No animation\n      config.animation = false;\n    } else if (placementRE.test(mod)) {\n      // Placement of popover\n      config.placement = mod;\n    } else if (boundaryRE.test(mod)) {\n      // Boundary of popover\n      mod = mod === 'scrollparent' ? 'scrollParent' : mod;\n      config.boundary = mod;\n    } else if (delayRE.test(mod)) {\n      // Delay value\n      var delay = parseInt(mod.slice(1), 10) || 0;\n      config.delay.show = delay;\n      config.delay.hide = delay;\n    } else if (delayShowRE.test(mod)) {\n      // Delay show value\n      config.delay.show = parseInt(mod.slice(2), 10) || 0;\n    } else if (delayHideRE.test(mod)) {\n      // Delay hide value\n      config.delay.hide = parseInt(mod.slice(2), 10) || 0;\n    } else if (offsetRE.test(mod)) {\n      // Offset value, negative allowed\n      config.offset = parseInt(mod.slice(1), 10) || 0;\n    } else if (variantRE.test(mod)) {\n      // Variant\n      config.variant = mod.slice(2) || null;\n    }\n  }); // Special handling of event trigger modifiers trigger is\n  // a space separated list\n\n  var selectedTriggers = {}; // Parse current config object trigger\n\n  concat(config.trigger || '').filter(Boolean).join(' ').trim().toLowerCase().split(/\\s+/).forEach(function (trigger) {\n    if (validTriggers[trigger]) {\n      selectedTriggers[trigger] = true;\n    }\n  }); // Parse modifiers for triggers\n\n  keys(bindings.modifiers).forEach(function (mod) {\n    mod = mod.toLowerCase();\n\n    if (validTriggers[mod]) {\n      // If modifier is a valid trigger\n      selectedTriggers[mod] = true;\n    }\n  }); // Sanitize triggers\n\n  config.trigger = keys(selectedTriggers).join(' ');\n\n  if (config.trigger === 'blur') {\n    // Blur by itself is useless, so convert it to 'focus'\n    config.trigger = 'focus';\n  }\n\n  if (!config.trigger) {\n    // Use default trigger\n    config.trigger = DefaultTrigger;\n  }\n\n  return config;\n}; // Add or update Popover on our element\n\n\nvar applyPopover = function applyPopover(el, bindings, vnode) {\n  if (!isBrowser) {\n    /* istanbul ignore next */\n    return;\n  }\n\n  var config = parseBindings(bindings, vnode);\n\n  if (!el[BV_POPOVER]) {\n    var $parent = vnode.context;\n    el[BV_POPOVER] = new BVPopover({\n      parent: $parent,\n      // Add the parent's scoped style attribute data\n      _scopeId: getScopId($parent, undefined)\n    });\n    el[BV_POPOVER].__bv_prev_data__ = {};\n    el[BV_POPOVER].$on('show', function ()\n    /* istanbul ignore next: for now */\n    {\n      // Before showing the popover, we update the title\n      // and content if they are functions\n      var data = {};\n\n      if (isFunction(config.title)) {\n        data.title = config.title();\n      }\n\n      if (isFunction(config.content)) {\n        data.content = config.content();\n      }\n\n      if (keys(data).length > 0) {\n        el[BV_POPOVER].updateData(data);\n      }\n    });\n  }\n\n  var data = {\n    title: config.title,\n    content: config.content,\n    triggers: config.trigger,\n    placement: config.placement,\n    fallbackPlacement: config.fallbackPlacement,\n    variant: config.variant,\n    customClass: config.customClass,\n    container: config.container,\n    boundary: config.boundary,\n    delay: config.delay,\n    offset: config.offset,\n    noFade: !config.animation,\n    id: config.id,\n    html: config.html\n  };\n  var oldData = el[BV_POPOVER].__bv_prev_data__;\n  el[BV_POPOVER].__bv_prev_data__ = data;\n\n  if (!looseEqual(data, oldData)) {\n    // We only update the instance if data has changed\n    var newData = {\n      target: el\n    };\n    keys(data).forEach(function (prop) {\n      // We only pass data properties that have changed\n      if (data[prop] !== oldData[prop]) {\n        // If title/content is a function, we execute it here\n        newData[prop] = (prop === 'title' || prop === 'content') && isFunction(data[prop]) ? data[prop]() : data[prop];\n      }\n    });\n    el[BV_POPOVER].updateData(newData);\n  }\n}; // Remove Popover from our element\n\n\nvar removePopover = function removePopover(el) {\n  if (el[BV_POPOVER]) {\n    el[BV_POPOVER].$destroy();\n    el[BV_POPOVER] = null;\n  }\n\n  delete el[BV_POPOVER];\n}; // Export our directive\n\n\nexport var VBPopover = {\n  bind: function bind(el, bindings, vnode) {\n    applyPopover(el, bindings, vnode);\n  },\n  // We use `componentUpdated` here instead of `update`, as the former\n  // waits until the containing component and children have finished updating\n  componentUpdated: function componentUpdated(el, bindings, vnode) {\n    // Performed in a `$nextTick()` to prevent endless render/update loops\n    vnode.context.$nextTick(function () {\n      applyPopover(el, bindings, vnode);\n    });\n  },\n  unbind: function unbind(el) {\n    removePopover(el);\n  }\n};","<template>\n    <div class=\"row\">\n        <div class=\"col-lg-6\">\n            <small class=\"d-block text-uppercase font-weight-bold mb-3\">Tooltips</small>\n            <base-button size=\"sm\" type=\"primary\" class=\"btn-tooltip\"\n                         v-b-tooltip.hover.left title=\"Tooltip on left\">On left\n            </base-button>\n            <base-button size=\"sm\" type=\"primary\" class=\"btn-tooltip\"\n                         v-b-tooltip.hover.top title=\"Tooltip on top\">On top\n            </base-button>\n            <base-button size=\"sm\" type=\"primary\" class=\"btn-tooltip\"\n                         v-b-tooltip.hover.bottom title=\"Tooltip on bottom\">On bottom\n            </base-button>\n            <base-button size=\"sm\" type=\"primary\" class=\"btn-tooltip\"\n                         v-b-tooltip.hover.right title=\"Tooltip on right\">On right\n            </base-button>\n        </div>\n        <div class=\"col-lg-6 mt-4 mt-lg-0\">\n            <small class=\"d-block text-uppercase font-weight-bold mb-3\">Popovers</small>\n            <base-button size=\"sm\" type=\"default\"\n                         v-b-popover.hover.left=\"'Vivamus sagittis lacus vel augue laoreet rutrum faucibus.'\"\n                         title=\"Popover On Left\">On left\n            </base-button>\n\n            <base-button size=\"sm\" type=\"default\"\n                         v-b-popover.hover.left=\"'Vivamus sagittis lacus vel augue laoreet rutrum faucibus.'\"\n                         title=\"Popover On Left\">On left\n            </base-button>\n\n            <base-button size=\"sm\" type=\"default\"\n                         v-b-popover.hover.top=\"'Vivamus sagittis lacus vel augue laoreet rutrum faucibus.'\"\n                         title=\"Popover On Top\">On top\n            </base-button>\n            <base-button size=\"sm\" type=\"default\"\n                         v-b-popover.hover.right=\"'Vivamus sagittis lacus vel augue laoreet rutrum faucibus.'\"\n                         title=\"Popover On right\">On right\n            </base-button>\n            <base-button size=\"sm\" type=\"default\"\n                         v-b-popover.hover.bottom=\"'Vivamus sagittis lacus vel augue laoreet rutrum faucibus.'\"\n                         title=\"Popover On bottom\">On bottom\n            </base-button>\n        </div>\n    </div>\n</template>\n<script>\nimport BTooltip from \"bootstrap-vue/esm/directives/tooltip/tooltip\";\nimport BPopover from \"bootstrap-vue/esm/directives/popover/popover\";\n\nexport default {\n  directives: {\n    BTooltip,\n    BPopover\n  }\n};\n</script>\n","import mod from \"-!../../../../node_modules/cache-loader/dist/cjs.js??ref--12-0!../../../../node_modules/thread-loader/dist/cjs.js!../../../../node_modules/babel-loader/lib/index.js!../../../../node_modules/cache-loader/dist/cjs.js??ref--0-0!../../../../node_modules/vue-loader/lib/index.js??vue-loader-options!./Tooltips.vue?vue&type=script&lang=js&\"; export default mod; export * from \"-!../../../../node_modules/cache-loader/dist/cjs.js??ref--12-0!../../../../node_modules/thread-loader/dist/cjs.js!../../../../node_modules/babel-loader/lib/index.js!../../../../node_modules/cache-loader/dist/cjs.js??ref--0-0!../../../../node_modules/vue-loader/lib/index.js??vue-loader-options!./Tooltips.vue?vue&type=script&lang=js&\"","import { render, staticRenderFns } from \"./Tooltips.vue?vue&type=template&id=0e8ae30d&\"\nimport script from \"./Tooltips.vue?vue&type=script&lang=js&\"\nexport * from \"./Tooltips.vue?vue&type=script&lang=js&\"\n\n\n/* normalize component */\nimport normalizer from \"!../../../../node_modules/vue-loader/lib/runtime/componentNormalizer.js\"\nvar component = normalizer(\n  script,\n  render,\n  staticRenderFns,\n  false,\n  null,\n  null,\n  null\n  \n)\n\nexport default component.exports","/**!\n * @fileOverview Kickass library to create and place poppers near their reference elements.\n * @version 1.15.0\n * @license\n * Copyright (c) 2016 Federico Zivolo and contributors\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in all\n * copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n */\nvar isBrowser = typeof window !== 'undefined' && typeof document !== 'undefined';\n\nvar longerTimeoutBrowsers = ['Edge', 'Trident', 'Firefox'];\nvar timeoutDuration = 0;\nfor (var i = 0; i < longerTimeoutBrowsers.length; i += 1) {\n  if (isBrowser && navigator.userAgent.indexOf(longerTimeoutBrowsers[i]) >= 0) {\n    timeoutDuration = 1;\n    break;\n  }\n}\n\nfunction microtaskDebounce(fn) {\n  var called = false;\n  return function () {\n    if (called) {\n      return;\n    }\n    called = true;\n    window.Promise.resolve().then(function () {\n      called = false;\n      fn();\n    });\n  };\n}\n\nfunction taskDebounce(fn) {\n  var scheduled = false;\n  return function () {\n    if (!scheduled) {\n      scheduled = true;\n      setTimeout(function () {\n        scheduled = false;\n        fn();\n      }, timeoutDuration);\n    }\n  };\n}\n\nvar supportsMicroTasks = isBrowser && window.Promise;\n\n/**\n* Create a debounced version of a method, that's asynchronously deferred\n* but called in the minimum time possible.\n*\n* @method\n* @memberof Popper.Utils\n* @argument {Function} fn\n* @returns {Function}\n*/\nvar debounce = supportsMicroTasks ? microtaskDebounce : taskDebounce;\n\n/**\n * Check if the given variable is a function\n * @method\n * @memberof Popper.Utils\n * @argument {Any} functionToCheck - variable to check\n * @returns {Boolean} answer to: is a function?\n */\nfunction isFunction(functionToCheck) {\n  var getType = {};\n  return functionToCheck && getType.toString.call(functionToCheck) === '[object Function]';\n}\n\n/**\n * Get CSS computed property of the given element\n * @method\n * @memberof Popper.Utils\n * @argument {Eement} element\n * @argument {String} property\n */\nfunction getStyleComputedProperty(element, property) {\n  if (element.nodeType !== 1) {\n    return [];\n  }\n  // NOTE: 1 DOM access here\n  var window = element.ownerDocument.defaultView;\n  var css = window.getComputedStyle(element, null);\n  return property ? css[property] : css;\n}\n\n/**\n * Returns the parentNode or the host of the element\n * @method\n * @memberof Popper.Utils\n * @argument {Element} element\n * @returns {Element} parent\n */\nfunction getParentNode(element) {\n  if (element.nodeName === 'HTML') {\n    return element;\n  }\n  return element.parentNode || element.host;\n}\n\n/**\n * Returns the scrolling parent of the given element\n * @method\n * @memberof Popper.Utils\n * @argument {Element} element\n * @returns {Element} scroll parent\n */\nfunction getScrollParent(element) {\n  // Return body, `getScroll` will take care to get the correct `scrollTop` from it\n  if (!element) {\n    return document.body;\n  }\n\n  switch (element.nodeName) {\n    case 'HTML':\n    case 'BODY':\n      return element.ownerDocument.body;\n    case '#document':\n      return element.body;\n  }\n\n  // Firefox want us to check `-x` and `-y` variations as well\n\n  var _getStyleComputedProp = getStyleComputedProperty(element),\n      overflow = _getStyleComputedProp.overflow,\n      overflowX = _getStyleComputedProp.overflowX,\n      overflowY = _getStyleComputedProp.overflowY;\n\n  if (/(auto|scroll|overlay)/.test(overflow + overflowY + overflowX)) {\n    return element;\n  }\n\n  return getScrollParent(getParentNode(element));\n}\n\nvar isIE11 = isBrowser && !!(window.MSInputMethodContext && document.documentMode);\nvar isIE10 = isBrowser && /MSIE 10/.test(navigator.userAgent);\n\n/**\n * Determines if the browser is Internet Explorer\n * @method\n * @memberof Popper.Utils\n * @param {Number} version to check\n * @returns {Boolean} isIE\n */\nfunction isIE(version) {\n  if (version === 11) {\n    return isIE11;\n  }\n  if (version === 10) {\n    return isIE10;\n  }\n  return isIE11 || isIE10;\n}\n\n/**\n * Returns the offset parent of the given element\n * @method\n * @memberof Popper.Utils\n * @argument {Element} element\n * @returns {Element} offset parent\n */\nfunction getOffsetParent(element) {\n  if (!element) {\n    return document.documentElement;\n  }\n\n  var noOffsetParent = isIE(10) ? document.body : null;\n\n  // NOTE: 1 DOM access here\n  var offsetParent = element.offsetParent || null;\n  // Skip hidden elements which don't have an offsetParent\n  while (offsetParent === noOffsetParent && element.nextElementSibling) {\n    offsetParent = (element = element.nextElementSibling).offsetParent;\n  }\n\n  var nodeName = offsetParent && offsetParent.nodeName;\n\n  if (!nodeName || nodeName === 'BODY' || nodeName === 'HTML') {\n    return element ? element.ownerDocument.documentElement : document.documentElement;\n  }\n\n  // .offsetParent will return the closest TH, TD or TABLE in case\n  // no offsetParent is present, I hate this job...\n  if (['TH', 'TD', 'TABLE'].indexOf(offsetParent.nodeName) !== -1 && getStyleComputedProperty(offsetParent, 'position') === 'static') {\n    return getOffsetParent(offsetParent);\n  }\n\n  return offsetParent;\n}\n\nfunction isOffsetContainer(element) {\n  var nodeName = element.nodeName;\n\n  if (nodeName === 'BODY') {\n    return false;\n  }\n  return nodeName === 'HTML' || getOffsetParent(element.firstElementChild) === element;\n}\n\n/**\n * Finds the root node (document, shadowDOM root) of the given element\n * @method\n * @memberof Popper.Utils\n * @argument {Element} node\n * @returns {Element} root node\n */\nfunction getRoot(node) {\n  if (node.parentNode !== null) {\n    return getRoot(node.parentNode);\n  }\n\n  return node;\n}\n\n/**\n * Finds the offset parent common to the two provided nodes\n * @method\n * @memberof Popper.Utils\n * @argument {Element} element1\n * @argument {Element} element2\n * @returns {Element} common offset parent\n */\nfunction findCommonOffsetParent(element1, element2) {\n  // This check is needed to avoid errors in case one of the elements isn't defined for any reason\n  if (!element1 || !element1.nodeType || !element2 || !element2.nodeType) {\n    return document.documentElement;\n  }\n\n  // Here we make sure to give as \"start\" the element that comes first in the DOM\n  var order = element1.compareDocumentPosition(element2) & Node.DOCUMENT_POSITION_FOLLOWING;\n  var start = order ? element1 : element2;\n  var end = order ? element2 : element1;\n\n  // Get common ancestor container\n  var range = document.createRange();\n  range.setStart(start, 0);\n  range.setEnd(end, 0);\n  var commonAncestorContainer = range.commonAncestorContainer;\n\n  // Both nodes are inside #document\n\n  if (element1 !== commonAncestorContainer && element2 !== commonAncestorContainer || start.contains(end)) {\n    if (isOffsetContainer(commonAncestorContainer)) {\n      return commonAncestorContainer;\n    }\n\n    return getOffsetParent(commonAncestorContainer);\n  }\n\n  // one of the nodes is inside shadowDOM, find which one\n  var element1root = getRoot(element1);\n  if (element1root.host) {\n    return findCommonOffsetParent(element1root.host, element2);\n  } else {\n    return findCommonOffsetParent(element1, getRoot(element2).host);\n  }\n}\n\n/**\n * Gets the scroll value of the given element in the given side (top and left)\n * @method\n * @memberof Popper.Utils\n * @argument {Element} element\n * @argument {String} side `top` or `left`\n * @returns {number} amount of scrolled pixels\n */\nfunction getScroll(element) {\n  var side = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'top';\n\n  var upperSide = side === 'top' ? 'scrollTop' : 'scrollLeft';\n  var nodeName = element.nodeName;\n\n  if (nodeName === 'BODY' || nodeName === 'HTML') {\n    var html = element.ownerDocument.documentElement;\n    var scrollingElement = element.ownerDocument.scrollingElement || html;\n    return scrollingElement[upperSide];\n  }\n\n  return element[upperSide];\n}\n\n/*\n * Sum or subtract the element scroll values (left and top) from a given rect object\n * @method\n * @memberof Popper.Utils\n * @param {Object} rect - Rect object you want to change\n * @param {HTMLElement} element - The element from the function reads the scroll values\n * @param {Boolean} subtract - set to true if you want to subtract the scroll values\n * @return {Object} rect - The modifier rect object\n */\nfunction includeScroll(rect, element) {\n  var subtract = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;\n\n  var scrollTop = getScroll(element, 'top');\n  var scrollLeft = getScroll(element, 'left');\n  var modifier = subtract ? -1 : 1;\n  rect.top += scrollTop * modifier;\n  rect.bottom += scrollTop * modifier;\n  rect.left += scrollLeft * modifier;\n  rect.right += scrollLeft * modifier;\n  return rect;\n}\n\n/*\n * Helper to detect borders of a given element\n * @method\n * @memberof Popper.Utils\n * @param {CSSStyleDeclaration} styles\n * Result of `getStyleComputedProperty` on the given element\n * @param {String} axis - `x` or `y`\n * @return {number} borders - The borders size of the given axis\n */\n\nfunction getBordersSize(styles, axis) {\n  var sideA = axis === 'x' ? 'Left' : 'Top';\n  var sideB = sideA === 'Left' ? 'Right' : 'Bottom';\n\n  return parseFloat(styles['border' + sideA + 'Width'], 10) + parseFloat(styles['border' + sideB + 'Width'], 10);\n}\n\nfunction getSize(axis, body, html, computedStyle) {\n  return Math.max(body['offset' + axis], body['scroll' + axis], html['client' + axis], html['offset' + axis], html['scroll' + axis], isIE(10) ? parseInt(html['offset' + axis]) + parseInt(computedStyle['margin' + (axis === 'Height' ? 'Top' : 'Left')]) + parseInt(computedStyle['margin' + (axis === 'Height' ? 'Bottom' : 'Right')]) : 0);\n}\n\nfunction getWindowSizes(document) {\n  var body = document.body;\n  var html = document.documentElement;\n  var computedStyle = isIE(10) && getComputedStyle(html);\n\n  return {\n    height: getSize('Height', body, html, computedStyle),\n    width: getSize('Width', body, html, computedStyle)\n  };\n}\n\nvar classCallCheck = function (instance, Constructor) {\n  if (!(instance instanceof Constructor)) {\n    throw new TypeError(\"Cannot call a class as a function\");\n  }\n};\n\nvar createClass = function () {\n  function defineProperties(target, props) {\n    for (var i = 0; i < props.length; i++) {\n      var descriptor = props[i];\n      descriptor.enumerable = descriptor.enumerable || false;\n      descriptor.configurable = true;\n      if (\"value\" in descriptor) descriptor.writable = true;\n      Object.defineProperty(target, descriptor.key, descriptor);\n    }\n  }\n\n  return function (Constructor, protoProps, staticProps) {\n    if (protoProps) defineProperties(Constructor.prototype, protoProps);\n    if (staticProps) defineProperties(Constructor, staticProps);\n    return Constructor;\n  };\n}();\n\n\n\n\n\nvar defineProperty = function (obj, key, value) {\n  if (key in obj) {\n    Object.defineProperty(obj, key, {\n      value: value,\n      enumerable: true,\n      configurable: true,\n      writable: true\n    });\n  } else {\n    obj[key] = value;\n  }\n\n  return obj;\n};\n\nvar _extends = Object.assign || function (target) {\n  for (var i = 1; i < arguments.length; i++) {\n    var source = arguments[i];\n\n    for (var key in source) {\n      if (Object.prototype.hasOwnProperty.call(source, key)) {\n        target[key] = source[key];\n      }\n    }\n  }\n\n  return target;\n};\n\n/**\n * Given element offsets, generate an output similar to getBoundingClientRect\n * @method\n * @memberof Popper.Utils\n * @argument {Object} offsets\n * @returns {Object} ClientRect like output\n */\nfunction getClientRect(offsets) {\n  return _extends({}, offsets, {\n    right: offsets.left + offsets.width,\n    bottom: offsets.top + offsets.height\n  });\n}\n\n/**\n * Get bounding client rect of given element\n * @method\n * @memberof Popper.Utils\n * @param {HTMLElement} element\n * @return {Object} client rect\n */\nfunction getBoundingClientRect(element) {\n  var rect = {};\n\n  // IE10 10 FIX: Please, don't ask, the element isn't\n  // considered in DOM in some circumstances...\n  // This isn't reproducible in IE10 compatibility mode of IE11\n  try {\n    if (isIE(10)) {\n      rect = element.getBoundingClientRect();\n      var scrollTop = getScroll(element, 'top');\n      var scrollLeft = getScroll(element, 'left');\n      rect.top += scrollTop;\n      rect.left += scrollLeft;\n      rect.bottom += scrollTop;\n      rect.right += scrollLeft;\n    } else {\n      rect = element.getBoundingClientRect();\n    }\n  } catch (e) {}\n\n  var result = {\n    left: rect.left,\n    top: rect.top,\n    width: rect.right - rect.left,\n    height: rect.bottom - rect.top\n  };\n\n  // subtract scrollbar size from sizes\n  var sizes = element.nodeName === 'HTML' ? getWindowSizes(element.ownerDocument) : {};\n  var width = sizes.width || element.clientWidth || result.right - result.left;\n  var height = sizes.height || element.clientHeight || result.bottom - result.top;\n\n  var horizScrollbar = element.offsetWidth - width;\n  var vertScrollbar = element.offsetHeight - height;\n\n  // if an hypothetical scrollbar is detected, we must be sure it's not a `border`\n  // we make this check conditional for performance reasons\n  if (horizScrollbar || vertScrollbar) {\n    var styles = getStyleComputedProperty(element);\n    horizScrollbar -= getBordersSize(styles, 'x');\n    vertScrollbar -= getBordersSize(styles, 'y');\n\n    result.width -= horizScrollbar;\n    result.height -= vertScrollbar;\n  }\n\n  return getClientRect(result);\n}\n\nfunction getOffsetRectRelativeToArbitraryNode(children, parent) {\n  var fixedPosition = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;\n\n  var isIE10 = isIE(10);\n  var isHTML = parent.nodeName === 'HTML';\n  var childrenRect = getBoundingClientRect(children);\n  var parentRect = getBoundingClientRect(parent);\n  var scrollParent = getScrollParent(children);\n\n  var styles = getStyleComputedProperty(parent);\n  var borderTopWidth = parseFloat(styles.borderTopWidth, 10);\n  var borderLeftWidth = parseFloat(styles.borderLeftWidth, 10);\n\n  // In cases where the parent is fixed, we must ignore negative scroll in offset calc\n  if (fixedPosition && isHTML) {\n    parentRect.top = Math.max(parentRect.top, 0);\n    parentRect.left = Math.max(parentRect.left, 0);\n  }\n  var offsets = getClientRect({\n    top: childrenRect.top - parentRect.top - borderTopWidth,\n    left: childrenRect.left - parentRect.left - borderLeftWidth,\n    width: childrenRect.width,\n    height: childrenRect.height\n  });\n  offsets.marginTop = 0;\n  offsets.marginLeft = 0;\n\n  // Subtract margins of documentElement in case it's being used as parent\n  // we do this only on HTML because it's the only element that behaves\n  // differently when margins are applied to it. The margins are included in\n  // the box of the documentElement, in the other cases not.\n  if (!isIE10 && isHTML) {\n    var marginTop = parseFloat(styles.marginTop, 10);\n    var marginLeft = parseFloat(styles.marginLeft, 10);\n\n    offsets.top -= borderTopWidth - marginTop;\n    offsets.bottom -= borderTopWidth - marginTop;\n    offsets.left -= borderLeftWidth - marginLeft;\n    offsets.right -= borderLeftWidth - marginLeft;\n\n    // Attach marginTop and marginLeft because in some circumstances we may need them\n    offsets.marginTop = marginTop;\n    offsets.marginLeft = marginLeft;\n  }\n\n  if (isIE10 && !fixedPosition ? parent.contains(scrollParent) : parent === scrollParent && scrollParent.nodeName !== 'BODY') {\n    offsets = includeScroll(offsets, parent);\n  }\n\n  return offsets;\n}\n\nfunction getViewportOffsetRectRelativeToArtbitraryNode(element) {\n  var excludeScroll = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;\n\n  var html = element.ownerDocument.documentElement;\n  var relativeOffset = getOffsetRectRelativeToArbitraryNode(element, html);\n  var width = Math.max(html.clientWidth, window.innerWidth || 0);\n  var height = Math.max(html.clientHeight, window.innerHeight || 0);\n\n  var scrollTop = !excludeScroll ? getScroll(html) : 0;\n  var scrollLeft = !excludeScroll ? getScroll(html, 'left') : 0;\n\n  var offset = {\n    top: scrollTop - relativeOffset.top + relativeOffset.marginTop,\n    left: scrollLeft - relativeOffset.left + relativeOffset.marginLeft,\n    width: width,\n    height: height\n  };\n\n  return getClientRect(offset);\n}\n\n/**\n * Check if the given element is fixed or is inside a fixed parent\n * @method\n * @memberof Popper.Utils\n * @argument {Element} element\n * @argument {Element} customContainer\n * @returns {Boolean} answer to \"isFixed?\"\n */\nfunction isFixed(element) {\n  var nodeName = element.nodeName;\n  if (nodeName === 'BODY' || nodeName === 'HTML') {\n    return false;\n  }\n  if (getStyleComputedProperty(element, 'position') === 'fixed') {\n    return true;\n  }\n  var parentNode = getParentNode(element);\n  if (!parentNode) {\n    return false;\n  }\n  return isFixed(parentNode);\n}\n\n/**\n * Finds the first parent of an element that has a transformed property defined\n * @method\n * @memberof Popper.Utils\n * @argument {Element} element\n * @returns {Element} first transformed parent or documentElement\n */\n\nfunction getFixedPositionOffsetParent(element) {\n  // This check is needed to avoid errors in case one of the elements isn't defined for any reason\n  if (!element || !element.parentElement || isIE()) {\n    return document.documentElement;\n  }\n  var el = element.parentElement;\n  while (el && getStyleComputedProperty(el, 'transform') === 'none') {\n    el = el.parentElement;\n  }\n  return el || document.documentElement;\n}\n\n/**\n * Computed the boundaries limits and return them\n * @method\n * @memberof Popper.Utils\n * @param {HTMLElement} popper\n * @param {HTMLElement} reference\n * @param {number} padding\n * @param {HTMLElement} boundariesElement - Element used to define the boundaries\n * @param {Boolean} fixedPosition - Is in fixed position mode\n * @returns {Object} Coordinates of the boundaries\n */\nfunction getBoundaries(popper, reference, padding, boundariesElement) {\n  var fixedPosition = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;\n\n  // NOTE: 1 DOM access here\n\n  var boundaries = { top: 0, left: 0 };\n  var offsetParent = fixedPosition ? getFixedPositionOffsetParent(popper) : findCommonOffsetParent(popper, reference);\n\n  // Handle viewport case\n  if (boundariesElement === 'viewport') {\n    boundaries = getViewportOffsetRectRelativeToArtbitraryNode(offsetParent, fixedPosition);\n  } else {\n    // Handle other cases based on DOM element used as boundaries\n    var boundariesNode = void 0;\n    if (boundariesElement === 'scrollParent') {\n      boundariesNode = getScrollParent(getParentNode(reference));\n      if (boundariesNode.nodeName === 'BODY') {\n        boundariesNode = popper.ownerDocument.documentElement;\n      }\n    } else if (boundariesElement === 'window') {\n      boundariesNode = popper.ownerDocument.documentElement;\n    } else {\n      boundariesNode = boundariesElement;\n    }\n\n    var offsets = getOffsetRectRelativeToArbitraryNode(boundariesNode, offsetParent, fixedPosition);\n\n    // In case of HTML, we need a different computation\n    if (boundariesNode.nodeName === 'HTML' && !isFixed(offsetParent)) {\n      var _getWindowSizes = getWindowSizes(popper.ownerDocument),\n          height = _getWindowSizes.height,\n          width = _getWindowSizes.width;\n\n      boundaries.top += offsets.top - offsets.marginTop;\n      boundaries.bottom = height + offsets.top;\n      boundaries.left += offsets.left - offsets.marginLeft;\n      boundaries.right = width + offsets.left;\n    } else {\n      // for all the other DOM elements, this one is good\n      boundaries = offsets;\n    }\n  }\n\n  // Add paddings\n  padding = padding || 0;\n  var isPaddingNumber = typeof padding === 'number';\n  boundaries.left += isPaddingNumber ? padding : padding.left || 0;\n  boundaries.top += isPaddingNumber ? padding : padding.top || 0;\n  boundaries.right -= isPaddingNumber ? padding : padding.right || 0;\n  boundaries.bottom -= isPaddingNumber ? padding : padding.bottom || 0;\n\n  return boundaries;\n}\n\nfunction getArea(_ref) {\n  var width = _ref.width,\n      height = _ref.height;\n\n  return width * height;\n}\n\n/**\n * Utility used to transform the `auto` placement to the placement with more\n * available space.\n * @method\n * @memberof Popper.Utils\n * @argument {Object} data - The data object generated by update method\n * @argument {Object} options - Modifiers configuration and options\n * @returns {Object} The data object, properly modified\n */\nfunction computeAutoPlacement(placement, refRect, popper, reference, boundariesElement) {\n  var padding = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : 0;\n\n  if (placement.indexOf('auto') === -1) {\n    return placement;\n  }\n\n  var boundaries = getBoundaries(popper, reference, padding, boundariesElement);\n\n  var rects = {\n    top: {\n      width: boundaries.width,\n      height: refRect.top - boundaries.top\n    },\n    right: {\n      width: boundaries.right - refRect.right,\n      height: boundaries.height\n    },\n    bottom: {\n      width: boundaries.width,\n      height: boundaries.bottom - refRect.bottom\n    },\n    left: {\n      width: refRect.left - boundaries.left,\n      height: boundaries.height\n    }\n  };\n\n  var sortedAreas = Object.keys(rects).map(function (key) {\n    return _extends({\n      key: key\n    }, rects[key], {\n      area: getArea(rects[key])\n    });\n  }).sort(function (a, b) {\n    return b.area - a.area;\n  });\n\n  var filteredAreas = sortedAreas.filter(function (_ref2) {\n    var width = _ref2.width,\n        height = _ref2.height;\n    return width >= popper.clientWidth && height >= popper.clientHeight;\n  });\n\n  var computedPlacement = filteredAreas.length > 0 ? filteredAreas[0].key : sortedAreas[0].key;\n\n  var variation = placement.split('-')[1];\n\n  return computedPlacement + (variation ? '-' + variation : '');\n}\n\n/**\n * Get offsets to the reference element\n * @method\n * @memberof Popper.Utils\n * @param {Object} state\n * @param {Element} popper - the popper element\n * @param {Element} reference - the reference element (the popper will be relative to this)\n * @param {Element} fixedPosition - is in fixed position mode\n * @returns {Object} An object containing the offsets which will be applied to the popper\n */\nfunction getReferenceOffsets(state, popper, reference) {\n  var fixedPosition = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;\n\n  var commonOffsetParent = fixedPosition ? getFixedPositionOffsetParent(popper) : findCommonOffsetParent(popper, reference);\n  return getOffsetRectRelativeToArbitraryNode(reference, commonOffsetParent, fixedPosition);\n}\n\n/**\n * Get the outer sizes of the given element (offset size + margins)\n * @method\n * @memberof Popper.Utils\n * @argument {Element} element\n * @returns {Object} object containing width and height properties\n */\nfunction getOuterSizes(element) {\n  var window = element.ownerDocument.defaultView;\n  var styles = window.getComputedStyle(element);\n  var x = parseFloat(styles.marginTop || 0) + parseFloat(styles.marginBottom || 0);\n  var y = parseFloat(styles.marginLeft || 0) + parseFloat(styles.marginRight || 0);\n  var result = {\n    width: element.offsetWidth + y,\n    height: element.offsetHeight + x\n  };\n  return result;\n}\n\n/**\n * Get the opposite placement of the given one\n * @method\n * @memberof Popper.Utils\n * @argument {String} placement\n * @returns {String} flipped placement\n */\nfunction getOppositePlacement(placement) {\n  var hash = { left: 'right', right: 'left', bottom: 'top', top: 'bottom' };\n  return placement.replace(/left|right|bottom|top/g, function (matched) {\n    return hash[matched];\n  });\n}\n\n/**\n * Get offsets to the popper\n * @method\n * @memberof Popper.Utils\n * @param {Object} position - CSS position the Popper will get applied\n * @param {HTMLElement} popper - the popper element\n * @param {Object} referenceOffsets - the reference offsets (the popper will be relative to this)\n * @param {String} placement - one of the valid placement options\n * @returns {Object} popperOffsets - An object containing the offsets which will be applied to the popper\n */\nfunction getPopperOffsets(popper, referenceOffsets, placement) {\n  placement = placement.split('-')[0];\n\n  // Get popper node sizes\n  var popperRect = getOuterSizes(popper);\n\n  // Add position, width and height to our offsets object\n  var popperOffsets = {\n    width: popperRect.width,\n    height: popperRect.height\n  };\n\n  // depending by the popper placement we have to compute its offsets slightly differently\n  var isHoriz = ['right', 'left'].indexOf(placement) !== -1;\n  var mainSide = isHoriz ? 'top' : 'left';\n  var secondarySide = isHoriz ? 'left' : 'top';\n  var measurement = isHoriz ? 'height' : 'width';\n  var secondaryMeasurement = !isHoriz ? 'height' : 'width';\n\n  popperOffsets[mainSide] = referenceOffsets[mainSide] + referenceOffsets[measurement] / 2 - popperRect[measurement] / 2;\n  if (placement === secondarySide) {\n    popperOffsets[secondarySide] = referenceOffsets[secondarySide] - popperRect[secondaryMeasurement];\n  } else {\n    popperOffsets[secondarySide] = referenceOffsets[getOppositePlacement(secondarySide)];\n  }\n\n  return popperOffsets;\n}\n\n/**\n * Mimics the `find` method of Array\n * @method\n * @memberof Popper.Utils\n * @argument {Array} arr\n * @argument prop\n * @argument value\n * @returns index or -1\n */\nfunction find(arr, check) {\n  // use native find if supported\n  if (Array.prototype.find) {\n    return arr.find(check);\n  }\n\n  // use `filter` to obtain the same behavior of `find`\n  return arr.filter(check)[0];\n}\n\n/**\n * Return the index of the matching object\n * @method\n * @memberof Popper.Utils\n * @argument {Array} arr\n * @argument prop\n * @argument value\n * @returns index or -1\n */\nfunction findIndex(arr, prop, value) {\n  // use native findIndex if supported\n  if (Array.prototype.findIndex) {\n    return arr.findIndex(function (cur) {\n      return cur[prop] === value;\n    });\n  }\n\n  // use `find` + `indexOf` if `findIndex` isn't supported\n  var match = find(arr, function (obj) {\n    return obj[prop] === value;\n  });\n  return arr.indexOf(match);\n}\n\n/**\n * Loop trough the list of modifiers and run them in order,\n * each of them will then edit the data object.\n * @method\n * @memberof Popper.Utils\n * @param {dataObject} data\n * @param {Array} modifiers\n * @param {String} ends - Optional modifier name used as stopper\n * @returns {dataObject}\n */\nfunction runModifiers(modifiers, data, ends) {\n  var modifiersToRun = ends === undefined ? modifiers : modifiers.slice(0, findIndex(modifiers, 'name', ends));\n\n  modifiersToRun.forEach(function (modifier) {\n    if (modifier['function']) {\n      // eslint-disable-line dot-notation\n      console.warn('`modifier.function` is deprecated, use `modifier.fn`!');\n    }\n    var fn = modifier['function'] || modifier.fn; // eslint-disable-line dot-notation\n    if (modifier.enabled && isFunction(fn)) {\n      // Add properties to offsets to make them a complete clientRect object\n      // we do this before each modifier to make sure the previous one doesn't\n      // mess with these values\n      data.offsets.popper = getClientRect(data.offsets.popper);\n      data.offsets.reference = getClientRect(data.offsets.reference);\n\n      data = fn(data, modifier);\n    }\n  });\n\n  return data;\n}\n\n/**\n * Updates the position of the popper, computing the new offsets and applying\n * the new style.<br />\n * Prefer `scheduleUpdate` over `update` because of performance reasons.\n * @method\n * @memberof Popper\n */\nfunction update() {\n  // if popper is destroyed, don't perform any further update\n  if (this.state.isDestroyed) {\n    return;\n  }\n\n  var data = {\n    instance: this,\n    styles: {},\n    arrowStyles: {},\n    attributes: {},\n    flipped: false,\n    offsets: {}\n  };\n\n  // compute reference element offsets\n  data.offsets.reference = getReferenceOffsets(this.state, this.popper, this.reference, this.options.positionFixed);\n\n  // compute auto placement, store placement inside the data object,\n  // modifiers will be able to edit `placement` if needed\n  // and refer to originalPlacement to know the original value\n  data.placement = computeAutoPlacement(this.options.placement, data.offsets.reference, this.popper, this.reference, this.options.modifiers.flip.boundariesElement, this.options.modifiers.flip.padding);\n\n  // store the computed placement inside `originalPlacement`\n  data.originalPlacement = data.placement;\n\n  data.positionFixed = this.options.positionFixed;\n\n  // compute the popper offsets\n  data.offsets.popper = getPopperOffsets(this.popper, data.offsets.reference, data.placement);\n\n  data.offsets.popper.position = this.options.positionFixed ? 'fixed' : 'absolute';\n\n  // run the modifiers\n  data = runModifiers(this.modifiers, data);\n\n  // the first `update` will call `onCreate` callback\n  // the other ones will call `onUpdate` callback\n  if (!this.state.isCreated) {\n    this.state.isCreated = true;\n    this.options.onCreate(data);\n  } else {\n    this.options.onUpdate(data);\n  }\n}\n\n/**\n * Helper used to know if the given modifier is enabled.\n * @method\n * @memberof Popper.Utils\n * @returns {Boolean}\n */\nfunction isModifierEnabled(modifiers, modifierName) {\n  return modifiers.some(function (_ref) {\n    var name = _ref.name,\n        enabled = _ref.enabled;\n    return enabled && name === modifierName;\n  });\n}\n\n/**\n * Get the prefixed supported property name\n * @method\n * @memberof Popper.Utils\n * @argument {String} property (camelCase)\n * @returns {String} prefixed property (camelCase or PascalCase, depending on the vendor prefix)\n */\nfunction getSupportedPropertyName(property) {\n  var prefixes = [false, 'ms', 'Webkit', 'Moz', 'O'];\n  var upperProp = property.charAt(0).toUpperCase() + property.slice(1);\n\n  for (var i = 0; i < prefixes.length; i++) {\n    var prefix = prefixes[i];\n    var toCheck = prefix ? '' + prefix + upperProp : property;\n    if (typeof document.body.style[toCheck] !== 'undefined') {\n      return toCheck;\n    }\n  }\n  return null;\n}\n\n/**\n * Destroys the popper.\n * @method\n * @memberof Popper\n */\nfunction destroy() {\n  this.state.isDestroyed = true;\n\n  // touch DOM only if `applyStyle` modifier is enabled\n  if (isModifierEnabled(this.modifiers, 'applyStyle')) {\n    this.popper.removeAttribute('x-placement');\n    this.popper.style.position = '';\n    this.popper.style.top = '';\n    this.popper.style.left = '';\n    this.popper.style.right = '';\n    this.popper.style.bottom = '';\n    this.popper.style.willChange = '';\n    this.popper.style[getSupportedPropertyName('transform')] = '';\n  }\n\n  this.disableEventListeners();\n\n  // remove the popper if user explicity asked for the deletion on destroy\n  // do not use `remove` because IE11 doesn't support it\n  if (this.options.removeOnDestroy) {\n    this.popper.parentNode.removeChild(this.popper);\n  }\n  return this;\n}\n\n/**\n * Get the window associated with the element\n * @argument {Element} element\n * @returns {Window}\n */\nfunction getWindow(element) {\n  var ownerDocument = element.ownerDocument;\n  return ownerDocument ? ownerDocument.defaultView : window;\n}\n\nfunction attachToScrollParents(scrollParent, event, callback, scrollParents) {\n  var isBody = scrollParent.nodeName === 'BODY';\n  var target = isBody ? scrollParent.ownerDocument.defaultView : scrollParent;\n  target.addEventListener(event, callback, { passive: true });\n\n  if (!isBody) {\n    attachToScrollParents(getScrollParent(target.parentNode), event, callback, scrollParents);\n  }\n  scrollParents.push(target);\n}\n\n/**\n * Setup needed event listeners used to update the popper position\n * @method\n * @memberof Popper.Utils\n * @private\n */\nfunction setupEventListeners(reference, options, state, updateBound) {\n  // Resize event listener on window\n  state.updateBound = updateBound;\n  getWindow(reference).addEventListener('resize', state.updateBound, { passive: true });\n\n  // Scroll event listener on scroll parents\n  var scrollElement = getScrollParent(reference);\n  attachToScrollParents(scrollElement, 'scroll', state.updateBound, state.scrollParents);\n  state.scrollElement = scrollElement;\n  state.eventsEnabled = true;\n\n  return state;\n}\n\n/**\n * It will add resize/scroll events and start recalculating\n * position of the popper element when they are triggered.\n * @method\n * @memberof Popper\n */\nfunction enableEventListeners() {\n  if (!this.state.eventsEnabled) {\n    this.state = setupEventListeners(this.reference, this.options, this.state, this.scheduleUpdate);\n  }\n}\n\n/**\n * Remove event listeners used to update the popper position\n * @method\n * @memberof Popper.Utils\n * @private\n */\nfunction removeEventListeners(reference, state) {\n  // Remove resize event listener on window\n  getWindow(reference).removeEventListener('resize', state.updateBound);\n\n  // Remove scroll event listener on scroll parents\n  state.scrollParents.forEach(function (target) {\n    target.removeEventListener('scroll', state.updateBound);\n  });\n\n  // Reset state\n  state.updateBound = null;\n  state.scrollParents = [];\n  state.scrollElement = null;\n  state.eventsEnabled = false;\n  return state;\n}\n\n/**\n * It will remove resize/scroll events and won't recalculate popper position\n * when they are triggered. It also won't trigger `onUpdate` callback anymore,\n * unless you call `update` method manually.\n * @method\n * @memberof Popper\n */\nfunction disableEventListeners() {\n  if (this.state.eventsEnabled) {\n    cancelAnimationFrame(this.scheduleUpdate);\n    this.state = removeEventListeners(this.reference, this.state);\n  }\n}\n\n/**\n * Tells if a given input is a number\n * @method\n * @memberof Popper.Utils\n * @param {*} input to check\n * @return {Boolean}\n */\nfunction isNumeric(n) {\n  return n !== '' && !isNaN(parseFloat(n)) && isFinite(n);\n}\n\n/**\n * Set the style to the given popper\n * @method\n * @memberof Popper.Utils\n * @argument {Element} element - Element to apply the style to\n * @argument {Object} styles\n * Object with a list of properties and values which will be applied to the element\n */\nfunction setStyles(element, styles) {\n  Object.keys(styles).forEach(function (prop) {\n    var unit = '';\n    // add unit if the value is numeric and is one of the following\n    if (['width', 'height', 'top', 'right', 'bottom', 'left'].indexOf(prop) !== -1 && isNumeric(styles[prop])) {\n      unit = 'px';\n    }\n    element.style[prop] = styles[prop] + unit;\n  });\n}\n\n/**\n * Set the attributes to the given popper\n * @method\n * @memberof Popper.Utils\n * @argument {Element} element - Element to apply the attributes to\n * @argument {Object} styles\n * Object with a list of properties and values which will be applied to the element\n */\nfunction setAttributes(element, attributes) {\n  Object.keys(attributes).forEach(function (prop) {\n    var value = attributes[prop];\n    if (value !== false) {\n      element.setAttribute(prop, attributes[prop]);\n    } else {\n      element.removeAttribute(prop);\n    }\n  });\n}\n\n/**\n * @function\n * @memberof Modifiers\n * @argument {Object} data - The data object generated by `update` method\n * @argument {Object} data.styles - List of style properties - values to apply to popper element\n * @argument {Object} data.attributes - List of attribute properties - values to apply to popper element\n * @argument {Object} options - Modifiers configuration and options\n * @returns {Object} The same data object\n */\nfunction applyStyle(data) {\n  // any property present in `data.styles` will be applied to the popper,\n  // in this way we can make the 3rd party modifiers add custom styles to it\n  // Be aware, modifiers could override the properties defined in the previous\n  // lines of this modifier!\n  setStyles(data.instance.popper, data.styles);\n\n  // any property present in `data.attributes` will be applied to the popper,\n  // they will be set as HTML attributes of the element\n  setAttributes(data.instance.popper, data.attributes);\n\n  // if arrowElement is defined and arrowStyles has some properties\n  if (data.arrowElement && Object.keys(data.arrowStyles).length) {\n    setStyles(data.arrowElement, data.arrowStyles);\n  }\n\n  return data;\n}\n\n/**\n * Set the x-placement attribute before everything else because it could be used\n * to add margins to the popper margins needs to be calculated to get the\n * correct popper offsets.\n * @method\n * @memberof Popper.modifiers\n * @param {HTMLElement} reference - The reference element used to position the popper\n * @param {HTMLElement} popper - The HTML element used as popper\n * @param {Object} options - Popper.js options\n */\nfunction applyStyleOnLoad(reference, popper, options, modifierOptions, state) {\n  // compute reference element offsets\n  var referenceOffsets = getReferenceOffsets(state, popper, reference, options.positionFixed);\n\n  // compute auto placement, store placement inside the data object,\n  // modifiers will be able to edit `placement` if needed\n  // and refer to originalPlacement to know the original value\n  var placement = computeAutoPlacement(options.placement, referenceOffsets, popper, reference, options.modifiers.flip.boundariesElement, options.modifiers.flip.padding);\n\n  popper.setAttribute('x-placement', placement);\n\n  // Apply `position` to popper before anything else because\n  // without the position applied we can't guarantee correct computations\n  setStyles(popper, { position: options.positionFixed ? 'fixed' : 'absolute' });\n\n  return options;\n}\n\n/**\n * @function\n * @memberof Popper.Utils\n * @argument {Object} data - The data object generated by `update` method\n * @argument {Boolean} shouldRound - If the offsets should be rounded at all\n * @returns {Object} The popper's position offsets rounded\n *\n * The tale of pixel-perfect positioning. It's still not 100% perfect, but as\n * good as it can be within reason.\n * Discussion here: https://github.com/FezVrasta/popper.js/pull/715\n *\n * Low DPI screens cause a popper to be blurry if not using full pixels (Safari\n * as well on High DPI screens).\n *\n * Firefox prefers no rounding for positioning and does not have blurriness on\n * high DPI screens.\n *\n * Only horizontal placement and left/right values need to be considered.\n */\nfunction getRoundedOffsets(data, shouldRound) {\n  var _data$offsets = data.offsets,\n      popper = _data$offsets.popper,\n      reference = _data$offsets.reference;\n  var round = Math.round,\n      floor = Math.floor;\n\n  var noRound = function noRound(v) {\n    return v;\n  };\n\n  var referenceWidth = round(reference.width);\n  var popperWidth = round(popper.width);\n\n  var isVertical = ['left', 'right'].indexOf(data.placement) !== -1;\n  var isVariation = data.placement.indexOf('-') !== -1;\n  var sameWidthParity = referenceWidth % 2 === popperWidth % 2;\n  var bothOddWidth = referenceWidth % 2 === 1 && popperWidth % 2 === 1;\n\n  var horizontalToInteger = !shouldRound ? noRound : isVertical || isVariation || sameWidthParity ? round : floor;\n  var verticalToInteger = !shouldRound ? noRound : round;\n\n  return {\n    left: horizontalToInteger(bothOddWidth && !isVariation && shouldRound ? popper.left - 1 : popper.left),\n    top: verticalToInteger(popper.top),\n    bottom: verticalToInteger(popper.bottom),\n    right: horizontalToInteger(popper.right)\n  };\n}\n\nvar isFirefox = isBrowser && /Firefox/i.test(navigator.userAgent);\n\n/**\n * @function\n * @memberof Modifiers\n * @argument {Object} data - The data object generated by `update` method\n * @argument {Object} options - Modifiers configuration and options\n * @returns {Object} The data object, properly modified\n */\nfunction computeStyle(data, options) {\n  var x = options.x,\n      y = options.y;\n  var popper = data.offsets.popper;\n\n  // Remove this legacy support in Popper.js v2\n\n  var legacyGpuAccelerationOption = find(data.instance.modifiers, function (modifier) {\n    return modifier.name === 'applyStyle';\n  }).gpuAcceleration;\n  if (legacyGpuAccelerationOption !== undefined) {\n    console.warn('WARNING: `gpuAcceleration` option moved to `computeStyle` modifier and will not be supported in future versions of Popper.js!');\n  }\n  var gpuAcceleration = legacyGpuAccelerationOption !== undefined ? legacyGpuAccelerationOption : options.gpuAcceleration;\n\n  var offsetParent = getOffsetParent(data.instance.popper);\n  var offsetParentRect = getBoundingClientRect(offsetParent);\n\n  // Styles\n  var styles = {\n    position: popper.position\n  };\n\n  var offsets = getRoundedOffsets(data, window.devicePixelRatio < 2 || !isFirefox);\n\n  var sideA = x === 'bottom' ? 'top' : 'bottom';\n  var sideB = y === 'right' ? 'left' : 'right';\n\n  // if gpuAcceleration is set to `true` and transform is supported,\n  //  we use `translate3d` to apply the position to the popper we\n  // automatically use the supported prefixed version if needed\n  var prefixedProperty = getSupportedPropertyName('transform');\n\n  // now, let's make a step back and look at this code closely (wtf?)\n  // If the content of the popper grows once it's been positioned, it\n  // may happen that the popper gets misplaced because of the new content\n  // overflowing its reference element\n  // To avoid this problem, we provide two options (x and y), which allow\n  // the consumer to define the offset origin.\n  // If we position a popper on top of a reference element, we can set\n  // `x` to `top` to make the popper grow towards its top instead of\n  // its bottom.\n  var left = void 0,\n      top = void 0;\n  if (sideA === 'bottom') {\n    // when offsetParent is <html> the positioning is relative to the bottom of the screen (excluding the scrollbar)\n    // and not the bottom of the html element\n    if (offsetParent.nodeName === 'HTML') {\n      top = -offsetParent.clientHeight + offsets.bottom;\n    } else {\n      top = -offsetParentRect.height + offsets.bottom;\n    }\n  } else {\n    top = offsets.top;\n  }\n  if (sideB === 'right') {\n    if (offsetParent.nodeName === 'HTML') {\n      left = -offsetParent.clientWidth + offsets.right;\n    } else {\n      left = -offsetParentRect.width + offsets.right;\n    }\n  } else {\n    left = offsets.left;\n  }\n  if (gpuAcceleration && prefixedProperty) {\n    styles[prefixedProperty] = 'translate3d(' + left + 'px, ' + top + 'px, 0)';\n    styles[sideA] = 0;\n    styles[sideB] = 0;\n    styles.willChange = 'transform';\n  } else {\n    // othwerise, we use the standard `top`, `left`, `bottom` and `right` properties\n    var invertTop = sideA === 'bottom' ? -1 : 1;\n    var invertLeft = sideB === 'right' ? -1 : 1;\n    styles[sideA] = top * invertTop;\n    styles[sideB] = left * invertLeft;\n    styles.willChange = sideA + ', ' + sideB;\n  }\n\n  // Attributes\n  var attributes = {\n    'x-placement': data.placement\n  };\n\n  // Update `data` attributes, styles and arrowStyles\n  data.attributes = _extends({}, attributes, data.attributes);\n  data.styles = _extends({}, styles, data.styles);\n  data.arrowStyles = _extends({}, data.offsets.arrow, data.arrowStyles);\n\n  return data;\n}\n\n/**\n * Helper used to know if the given modifier depends from another one.<br />\n * It checks if the needed modifier is listed and enabled.\n * @method\n * @memberof Popper.Utils\n * @param {Array} modifiers - list of modifiers\n * @param {String} requestingName - name of requesting modifier\n * @param {String} requestedName - name of requested modifier\n * @returns {Boolean}\n */\nfunction isModifierRequired(modifiers, requestingName, requestedName) {\n  var requesting = find(modifiers, function (_ref) {\n    var name = _ref.name;\n    return name === requestingName;\n  });\n\n  var isRequired = !!requesting && modifiers.some(function (modifier) {\n    return modifier.name === requestedName && modifier.enabled && modifier.order < requesting.order;\n  });\n\n  if (!isRequired) {\n    var _requesting = '`' + requestingName + '`';\n    var requested = '`' + requestedName + '`';\n    console.warn(requested + ' modifier is required by ' + _requesting + ' modifier in order to work, be sure to include it before ' + _requesting + '!');\n  }\n  return isRequired;\n}\n\n/**\n * @function\n * @memberof Modifiers\n * @argument {Object} data - The data object generated by update method\n * @argument {Object} options - Modifiers configuration and options\n * @returns {Object} The data object, properly modified\n */\nfunction arrow(data, options) {\n  var _data$offsets$arrow;\n\n  // arrow depends on keepTogether in order to work\n  if (!isModifierRequired(data.instance.modifiers, 'arrow', 'keepTogether')) {\n    return data;\n  }\n\n  var arrowElement = options.element;\n\n  // if arrowElement is a string, suppose it's a CSS selector\n  if (typeof arrowElement === 'string') {\n    arrowElement = data.instance.popper.querySelector(arrowElement);\n\n    // if arrowElement is not found, don't run the modifier\n    if (!arrowElement) {\n      return data;\n    }\n  } else {\n    // if the arrowElement isn't a query selector we must check that the\n    // provided DOM node is child of its popper node\n    if (!data.instance.popper.contains(arrowElement)) {\n      console.warn('WARNING: `arrow.element` must be child of its popper element!');\n      return data;\n    }\n  }\n\n  var placement = data.placement.split('-')[0];\n  var _data$offsets = data.offsets,\n      popper = _data$offsets.popper,\n      reference = _data$offsets.reference;\n\n  var isVertical = ['left', 'right'].indexOf(placement) !== -1;\n\n  var len = isVertical ? 'height' : 'width';\n  var sideCapitalized = isVertical ? 'Top' : 'Left';\n  var side = sideCapitalized.toLowerCase();\n  var altSide = isVertical ? 'left' : 'top';\n  var opSide = isVertical ? 'bottom' : 'right';\n  var arrowElementSize = getOuterSizes(arrowElement)[len];\n\n  //\n  // extends keepTogether behavior making sure the popper and its\n  // reference have enough pixels in conjunction\n  //\n\n  // top/left side\n  if (reference[opSide] - arrowElementSize < popper[side]) {\n    data.offsets.popper[side] -= popper[side] - (reference[opSide] - arrowElementSize);\n  }\n  // bottom/right side\n  if (reference[side] + arrowElementSize > popper[opSide]) {\n    data.offsets.popper[side] += reference[side] + arrowElementSize - popper[opSide];\n  }\n  data.offsets.popper = getClientRect(data.offsets.popper);\n\n  // compute center of the popper\n  var center = reference[side] + reference[len] / 2 - arrowElementSize / 2;\n\n  // Compute the sideValue using the updated popper offsets\n  // take popper margin in account because we don't have this info available\n  var css = getStyleComputedProperty(data.instance.popper);\n  var popperMarginSide = parseFloat(css['margin' + sideCapitalized], 10);\n  var popperBorderSide = parseFloat(css['border' + sideCapitalized + 'Width'], 10);\n  var sideValue = center - data.offsets.popper[side] - popperMarginSide - popperBorderSide;\n\n  // prevent arrowElement from being placed not contiguously to its popper\n  sideValue = Math.max(Math.min(popper[len] - arrowElementSize, sideValue), 0);\n\n  data.arrowElement = arrowElement;\n  data.offsets.arrow = (_data$offsets$arrow = {}, defineProperty(_data$offsets$arrow, side, Math.round(sideValue)), defineProperty(_data$offsets$arrow, altSide, ''), _data$offsets$arrow);\n\n  return data;\n}\n\n/**\n * Get the opposite placement variation of the given one\n * @method\n * @memberof Popper.Utils\n * @argument {String} placement variation\n * @returns {String} flipped placement variation\n */\nfunction getOppositeVariation(variation) {\n  if (variation === 'end') {\n    return 'start';\n  } else if (variation === 'start') {\n    return 'end';\n  }\n  return variation;\n}\n\n/**\n * List of accepted placements to use as values of the `placement` option.<br />\n * Valid placements are:\n * - `auto`\n * - `top`\n * - `right`\n * - `bottom`\n * - `left`\n *\n * Each placement can have a variation from this list:\n * - `-start`\n * - `-end`\n *\n * Variations are interpreted easily if you think of them as the left to right\n * written languages. Horizontally (`top` and `bottom`), `start` is left and `end`\n * is right.<br />\n * Vertically (`left` and `right`), `start` is top and `end` is bottom.\n *\n * Some valid examples are:\n * - `top-end` (on top of reference, right aligned)\n * - `right-start` (on right of reference, top aligned)\n * - `bottom` (on bottom, centered)\n * - `auto-end` (on the side with more space available, alignment depends by placement)\n *\n * @static\n * @type {Array}\n * @enum {String}\n * @readonly\n * @method placements\n * @memberof Popper\n */\nvar placements = ['auto-start', 'auto', 'auto-end', 'top-start', 'top', 'top-end', 'right-start', 'right', 'right-end', 'bottom-end', 'bottom', 'bottom-start', 'left-end', 'left', 'left-start'];\n\n// Get rid of `auto` `auto-start` and `auto-end`\nvar validPlacements = placements.slice(3);\n\n/**\n * Given an initial placement, returns all the subsequent placements\n * clockwise (or counter-clockwise).\n *\n * @method\n * @memberof Popper.Utils\n * @argument {String} placement - A valid placement (it accepts variations)\n * @argument {Boolean} counter - Set to true to walk the placements counterclockwise\n * @returns {Array} placements including their variations\n */\nfunction clockwise(placement) {\n  var counter = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;\n\n  var index = validPlacements.indexOf(placement);\n  var arr = validPlacements.slice(index + 1).concat(validPlacements.slice(0, index));\n  return counter ? arr.reverse() : arr;\n}\n\nvar BEHAVIORS = {\n  FLIP: 'flip',\n  CLOCKWISE: 'clockwise',\n  COUNTERCLOCKWISE: 'counterclockwise'\n};\n\n/**\n * @function\n * @memberof Modifiers\n * @argument {Object} data - The data object generated by update method\n * @argument {Object} options - Modifiers configuration and options\n * @returns {Object} The data object, properly modified\n */\nfunction flip(data, options) {\n  // if `inner` modifier is enabled, we can't use the `flip` modifier\n  if (isModifierEnabled(data.instance.modifiers, 'inner')) {\n    return data;\n  }\n\n  if (data.flipped && data.placement === data.originalPlacement) {\n    // seems like flip is trying to loop, probably there's not enough space on any of the flippable sides\n    return data;\n  }\n\n  var boundaries = getBoundaries(data.instance.popper, data.instance.reference, options.padding, options.boundariesElement, data.positionFixed);\n\n  var placement = data.placement.split('-')[0];\n  var placementOpposite = getOppositePlacement(placement);\n  var variation = data.placement.split('-')[1] || '';\n\n  var flipOrder = [];\n\n  switch (options.behavior) {\n    case BEHAVIORS.FLIP:\n      flipOrder = [placement, placementOpposite];\n      break;\n    case BEHAVIORS.CLOCKWISE:\n      flipOrder = clockwise(placement);\n      break;\n    case BEHAVIORS.COUNTERCLOCKWISE:\n      flipOrder = clockwise(placement, true);\n      break;\n    default:\n      flipOrder = options.behavior;\n  }\n\n  flipOrder.forEach(function (step, index) {\n    if (placement !== step || flipOrder.length === index + 1) {\n      return data;\n    }\n\n    placement = data.placement.split('-')[0];\n    placementOpposite = getOppositePlacement(placement);\n\n    var popperOffsets = data.offsets.popper;\n    var refOffsets = data.offsets.reference;\n\n    // using floor because the reference offsets may contain decimals we are not going to consider here\n    var floor = Math.floor;\n    var overlapsRef = placement === 'left' && floor(popperOffsets.right) > floor(refOffsets.left) || placement === 'right' && floor(popperOffsets.left) < floor(refOffsets.right) || placement === 'top' && floor(popperOffsets.bottom) > floor(refOffsets.top) || placement === 'bottom' && floor(popperOffsets.top) < floor(refOffsets.bottom);\n\n    var overflowsLeft = floor(popperOffsets.left) < floor(boundaries.left);\n    var overflowsRight = floor(popperOffsets.right) > floor(boundaries.right);\n    var overflowsTop = floor(popperOffsets.top) < floor(boundaries.top);\n    var overflowsBottom = floor(popperOffsets.bottom) > floor(boundaries.bottom);\n\n    var overflowsBoundaries = placement === 'left' && overflowsLeft || placement === 'right' && overflowsRight || placement === 'top' && overflowsTop || placement === 'bottom' && overflowsBottom;\n\n    // flip the variation if required\n    var isVertical = ['top', 'bottom'].indexOf(placement) !== -1;\n\n    // flips variation if reference element overflows boundaries\n    var flippedVariationByRef = !!options.flipVariations && (isVertical && variation === 'start' && overflowsLeft || isVertical && variation === 'end' && overflowsRight || !isVertical && variation === 'start' && overflowsTop || !isVertical && variation === 'end' && overflowsBottom);\n\n    // flips variation if popper content overflows boundaries\n    var flippedVariationByContent = !!options.flipVariationsByContent && (isVertical && variation === 'start' && overflowsRight || isVertical && variation === 'end' && overflowsLeft || !isVertical && variation === 'start' && overflowsBottom || !isVertical && variation === 'end' && overflowsTop);\n\n    var flippedVariation = flippedVariationByRef || flippedVariationByContent;\n\n    if (overlapsRef || overflowsBoundaries || flippedVariation) {\n      // this boolean to detect any flip loop\n      data.flipped = true;\n\n      if (overlapsRef || overflowsBoundaries) {\n        placement = flipOrder[index + 1];\n      }\n\n      if (flippedVariation) {\n        variation = getOppositeVariation(variation);\n      }\n\n      data.placement = placement + (variation ? '-' + variation : '');\n\n      // this object contains `position`, we want to preserve it along with\n      // any additional property we may add in the future\n      data.offsets.popper = _extends({}, data.offsets.popper, getPopperOffsets(data.instance.popper, data.offsets.reference, data.placement));\n\n      data = runModifiers(data.instance.modifiers, data, 'flip');\n    }\n  });\n  return data;\n}\n\n/**\n * @function\n * @memberof Modifiers\n * @argument {Object} data - The data object generated by update method\n * @argument {Object} options - Modifiers configuration and options\n * @returns {Object} The data object, properly modified\n */\nfunction keepTogether(data) {\n  var _data$offsets = data.offsets,\n      popper = _data$offsets.popper,\n      reference = _data$offsets.reference;\n\n  var placement = data.placement.split('-')[0];\n  var floor = Math.floor;\n  var isVertical = ['top', 'bottom'].indexOf(placement) !== -1;\n  var side = isVertical ? 'right' : 'bottom';\n  var opSide = isVertical ? 'left' : 'top';\n  var measurement = isVertical ? 'width' : 'height';\n\n  if (popper[side] < floor(reference[opSide])) {\n    data.offsets.popper[opSide] = floor(reference[opSide]) - popper[measurement];\n  }\n  if (popper[opSide] > floor(reference[side])) {\n    data.offsets.popper[opSide] = floor(reference[side]);\n  }\n\n  return data;\n}\n\n/**\n * Converts a string containing value + unit into a px value number\n * @function\n * @memberof {modifiers~offset}\n * @private\n * @argument {String} str - Value + unit string\n * @argument {String} measurement - `height` or `width`\n * @argument {Object} popperOffsets\n * @argument {Object} referenceOffsets\n * @returns {Number|String}\n * Value in pixels, or original string if no values were extracted\n */\nfunction toValue(str, measurement, popperOffsets, referenceOffsets) {\n  // separate value from unit\n  var split = str.match(/((?:\\-|\\+)?\\d*\\.?\\d*)(.*)/);\n  var value = +split[1];\n  var unit = split[2];\n\n  // If it's not a number it's an operator, I guess\n  if (!value) {\n    return str;\n  }\n\n  if (unit.indexOf('%') === 0) {\n    var element = void 0;\n    switch (unit) {\n      case '%p':\n        element = popperOffsets;\n        break;\n      case '%':\n      case '%r':\n      default:\n        element = referenceOffsets;\n    }\n\n    var rect = getClientRect(element);\n    return rect[measurement] / 100 * value;\n  } else if (unit === 'vh' || unit === 'vw') {\n    // if is a vh or vw, we calculate the size based on the viewport\n    var size = void 0;\n    if (unit === 'vh') {\n      size = Math.max(document.documentElement.clientHeight, window.innerHeight || 0);\n    } else {\n      size = Math.max(document.documentElement.clientWidth, window.innerWidth || 0);\n    }\n    return size / 100 * value;\n  } else {\n    // if is an explicit pixel unit, we get rid of the unit and keep the value\n    // if is an implicit unit, it's px, and we return just the value\n    return value;\n  }\n}\n\n/**\n * Parse an `offset` string to extrapolate `x` and `y` numeric offsets.\n * @function\n * @memberof {modifiers~offset}\n * @private\n * @argument {String} offset\n * @argument {Object} popperOffsets\n * @argument {Object} referenceOffsets\n * @argument {String} basePlacement\n * @returns {Array} a two cells array with x and y offsets in numbers\n */\nfunction parseOffset(offset, popperOffsets, referenceOffsets, basePlacement) {\n  var offsets = [0, 0];\n\n  // Use height if placement is left or right and index is 0 otherwise use width\n  // in this way the first offset will use an axis and the second one\n  // will use the other one\n  var useHeight = ['right', 'left'].indexOf(basePlacement) !== -1;\n\n  // Split the offset string to obtain a list of values and operands\n  // The regex addresses values with the plus or minus sign in front (+10, -20, etc)\n  var fragments = offset.split(/(\\+|\\-)/).map(function (frag) {\n    return frag.trim();\n  });\n\n  // Detect if the offset string contains a pair of values or a single one\n  // they could be separated by comma or space\n  var divider = fragments.indexOf(find(fragments, function (frag) {\n    return frag.search(/,|\\s/) !== -1;\n  }));\n\n  if (fragments[divider] && fragments[divider].indexOf(',') === -1) {\n    console.warn('Offsets separated by white space(s) are deprecated, use a comma (,) instead.');\n  }\n\n  // If divider is found, we divide the list of values and operands to divide\n  // them by ofset X and Y.\n  var splitRegex = /\\s*,\\s*|\\s+/;\n  var ops = divider !== -1 ? [fragments.slice(0, divider).concat([fragments[divider].split(splitRegex)[0]]), [fragments[divider].split(splitRegex)[1]].concat(fragments.slice(divider + 1))] : [fragments];\n\n  // Convert the values with units to absolute pixels to allow our computations\n  ops = ops.map(function (op, index) {\n    // Most of the units rely on the orientation of the popper\n    var measurement = (index === 1 ? !useHeight : useHeight) ? 'height' : 'width';\n    var mergeWithPrevious = false;\n    return op\n    // This aggregates any `+` or `-` sign that aren't considered operators\n    // e.g.: 10 + +5 => [10, +, +5]\n    .reduce(function (a, b) {\n      if (a[a.length - 1] === '' && ['+', '-'].indexOf(b) !== -1) {\n        a[a.length - 1] = b;\n        mergeWithPrevious = true;\n        return a;\n      } else if (mergeWithPrevious) {\n        a[a.length - 1] += b;\n        mergeWithPrevious = false;\n        return a;\n      } else {\n        return a.concat(b);\n      }\n    }, [])\n    // Here we convert the string values into number values (in px)\n    .map(function (str) {\n      return toValue(str, measurement, popperOffsets, referenceOffsets);\n    });\n  });\n\n  // Loop trough the offsets arrays and execute the operations\n  ops.forEach(function (op, index) {\n    op.forEach(function (frag, index2) {\n      if (isNumeric(frag)) {\n        offsets[index] += frag * (op[index2 - 1] === '-' ? -1 : 1);\n      }\n    });\n  });\n  return offsets;\n}\n\n/**\n * @function\n * @memberof Modifiers\n * @argument {Object} data - The data object generated by update method\n * @argument {Object} options - Modifiers configuration and options\n * @argument {Number|String} options.offset=0\n * The offset value as described in the modifier description\n * @returns {Object} The data object, properly modified\n */\nfunction offset(data, _ref) {\n  var offset = _ref.offset;\n  var placement = data.placement,\n      _data$offsets = data.offsets,\n      popper = _data$offsets.popper,\n      reference = _data$offsets.reference;\n\n  var basePlacement = placement.split('-')[0];\n\n  var offsets = void 0;\n  if (isNumeric(+offset)) {\n    offsets = [+offset, 0];\n  } else {\n    offsets = parseOffset(offset, popper, reference, basePlacement);\n  }\n\n  if (basePlacement === 'left') {\n    popper.top += offsets[0];\n    popper.left -= offsets[1];\n  } else if (basePlacement === 'right') {\n    popper.top += offsets[0];\n    popper.left += offsets[1];\n  } else if (basePlacement === 'top') {\n    popper.left += offsets[0];\n    popper.top -= offsets[1];\n  } else if (basePlacement === 'bottom') {\n    popper.left += offsets[0];\n    popper.top += offsets[1];\n  }\n\n  data.popper = popper;\n  return data;\n}\n\n/**\n * @function\n * @memberof Modifiers\n * @argument {Object} data - The data object generated by `update` method\n * @argument {Object} options - Modifiers configuration and options\n * @returns {Object} The data object, properly modified\n */\nfunction preventOverflow(data, options) {\n  var boundariesElement = options.boundariesElement || getOffsetParent(data.instance.popper);\n\n  // If offsetParent is the reference element, we really want to\n  // go one step up and use the next offsetParent as reference to\n  // avoid to make this modifier completely useless and look like broken\n  if (data.instance.reference === boundariesElement) {\n    boundariesElement = getOffsetParent(boundariesElement);\n  }\n\n  // NOTE: DOM access here\n  // resets the popper's position so that the document size can be calculated excluding\n  // the size of the popper element itself\n  var transformProp = getSupportedPropertyName('transform');\n  var popperStyles = data.instance.popper.style; // assignment to help minification\n  var top = popperStyles.top,\n      left = popperStyles.left,\n      transform = popperStyles[transformProp];\n\n  popperStyles.top = '';\n  popperStyles.left = '';\n  popperStyles[transformProp] = '';\n\n  var boundaries = getBoundaries(data.instance.popper, data.instance.reference, options.padding, boundariesElement, data.positionFixed);\n\n  // NOTE: DOM access here\n  // restores the original style properties after the offsets have been computed\n  popperStyles.top = top;\n  popperStyles.left = left;\n  popperStyles[transformProp] = transform;\n\n  options.boundaries = boundaries;\n\n  var order = options.priority;\n  var popper = data.offsets.popper;\n\n  var check = {\n    primary: function primary(placement) {\n      var value = popper[placement];\n      if (popper[placement] < boundaries[placement] && !options.escapeWithReference) {\n        value = Math.max(popper[placement], boundaries[placement]);\n      }\n      return defineProperty({}, placement, value);\n    },\n    secondary: function secondary(placement) {\n      var mainSide = placement === 'right' ? 'left' : 'top';\n      var value = popper[mainSide];\n      if (popper[placement] > boundaries[placement] && !options.escapeWithReference) {\n        value = Math.min(popper[mainSide], boundaries[placement] - (placement === 'right' ? popper.width : popper.height));\n      }\n      return defineProperty({}, mainSide, value);\n    }\n  };\n\n  order.forEach(function (placement) {\n    var side = ['left', 'top'].indexOf(placement) !== -1 ? 'primary' : 'secondary';\n    popper = _extends({}, popper, check[side](placement));\n  });\n\n  data.offsets.popper = popper;\n\n  return data;\n}\n\n/**\n * @function\n * @memberof Modifiers\n * @argument {Object} data - The data object generated by `update` method\n * @argument {Object} options - Modifiers configuration and options\n * @returns {Object} The data object, properly modified\n */\nfunction shift(data) {\n  var placement = data.placement;\n  var basePlacement = placement.split('-')[0];\n  var shiftvariation = placement.split('-')[1];\n\n  // if shift shiftvariation is specified, run the modifier\n  if (shiftvariation) {\n    var _data$offsets = data.offsets,\n        reference = _data$offsets.reference,\n        popper = _data$offsets.popper;\n\n    var isVertical = ['bottom', 'top'].indexOf(basePlacement) !== -1;\n    var side = isVertical ? 'left' : 'top';\n    var measurement = isVertical ? 'width' : 'height';\n\n    var shiftOffsets = {\n      start: defineProperty({}, side, reference[side]),\n      end: defineProperty({}, side, reference[side] + reference[measurement] - popper[measurement])\n    };\n\n    data.offsets.popper = _extends({}, popper, shiftOffsets[shiftvariation]);\n  }\n\n  return data;\n}\n\n/**\n * @function\n * @memberof Modifiers\n * @argument {Object} data - The data object generated by update method\n * @argument {Object} options - Modifiers configuration and options\n * @returns {Object} The data object, properly modified\n */\nfunction hide(data) {\n  if (!isModifierRequired(data.instance.modifiers, 'hide', 'preventOverflow')) {\n    return data;\n  }\n\n  var refRect = data.offsets.reference;\n  var bound = find(data.instance.modifiers, function (modifier) {\n    return modifier.name === 'preventOverflow';\n  }).boundaries;\n\n  if (refRect.bottom < bound.top || refRect.left > bound.right || refRect.top > bound.bottom || refRect.right < bound.left) {\n    // Avoid unnecessary DOM access if visibility hasn't changed\n    if (data.hide === true) {\n      return data;\n    }\n\n    data.hide = true;\n    data.attributes['x-out-of-boundaries'] = '';\n  } else {\n    // Avoid unnecessary DOM access if visibility hasn't changed\n    if (data.hide === false) {\n      return data;\n    }\n\n    data.hide = false;\n    data.attributes['x-out-of-boundaries'] = false;\n  }\n\n  return data;\n}\n\n/**\n * @function\n * @memberof Modifiers\n * @argument {Object} data - The data object generated by `update` method\n * @argument {Object} options - Modifiers configuration and options\n * @returns {Object} The data object, properly modified\n */\nfunction inner(data) {\n  var placement = data.placement;\n  var basePlacement = placement.split('-')[0];\n  var _data$offsets = data.offsets,\n      popper = _data$offsets.popper,\n      reference = _data$offsets.reference;\n\n  var isHoriz = ['left', 'right'].indexOf(basePlacement) !== -1;\n\n  var subtractLength = ['top', 'left'].indexOf(basePlacement) === -1;\n\n  popper[isHoriz ? 'left' : 'top'] = reference[basePlacement] - (subtractLength ? popper[isHoriz ? 'width' : 'height'] : 0);\n\n  data.placement = getOppositePlacement(placement);\n  data.offsets.popper = getClientRect(popper);\n\n  return data;\n}\n\n/**\n * Modifier function, each modifier can have a function of this type assigned\n * to its `fn` property.<br />\n * These functions will be called on each update, this means that you must\n * make sure they are performant enough to avoid performance bottlenecks.\n *\n * @function ModifierFn\n * @argument {dataObject} data - The data object generated by `update` method\n * @argument {Object} options - Modifiers configuration and options\n * @returns {dataObject} The data object, properly modified\n */\n\n/**\n * Modifiers are plugins used to alter the behavior of your poppers.<br />\n * Popper.js uses a set of 9 modifiers to provide all the basic functionalities\n * needed by the library.\n *\n * Usually you don't want to override the `order`, `fn` and `onLoad` props.\n * All the other properties are configurations that could be tweaked.\n * @namespace modifiers\n */\nvar modifiers = {\n  /**\n   * Modifier used to shift the popper on the start or end of its reference\n   * element.<br />\n   * It will read the variation of the `placement` property.<br />\n   * It can be one either `-end` or `-start`.\n   * @memberof modifiers\n   * @inner\n   */\n  shift: {\n    /** @prop {number} order=100 - Index used to define the order of execution */\n    order: 100,\n    /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */\n    enabled: true,\n    /** @prop {ModifierFn} */\n    fn: shift\n  },\n\n  /**\n   * The `offset` modifier can shift your popper on both its axis.\n   *\n   * It accepts the following units:\n   * - `px` or unit-less, interpreted as pixels\n   * - `%` or `%r`, percentage relative to the length of the reference element\n   * - `%p`, percentage relative to the length of the popper element\n   * - `vw`, CSS viewport width unit\n   * - `vh`, CSS viewport height unit\n   *\n   * For length is intended the main axis relative to the placement of the popper.<br />\n   * This means that if the placement is `top` or `bottom`, the length will be the\n   * `width`. In case of `left` or `right`, it will be the `height`.\n   *\n   * You can provide a single value (as `Number` or `String`), or a pair of values\n   * as `String` divided by a comma or one (or more) white spaces.<br />\n   * The latter is a deprecated method because it leads to confusion and will be\n   * removed in v2.<br />\n   * Additionally, it accepts additions and subtractions between different units.\n   * Note that multiplications and divisions aren't supported.\n   *\n   * Valid examples are:\n   * ```\n   * 10\n   * '10%'\n   * '10, 10'\n   * '10%, 10'\n   * '10 + 10%'\n   * '10 - 5vh + 3%'\n   * '-10px + 5vh, 5px - 6%'\n   * ```\n   * > **NB**: If you desire to apply offsets to your poppers in a way that may make them overlap\n   * > with their reference element, unfortunately, you will have to disable the `flip` modifier.\n   * > You can read more on this at this [issue](https://github.com/FezVrasta/popper.js/issues/373).\n   *\n   * @memberof modifiers\n   * @inner\n   */\n  offset: {\n    /** @prop {number} order=200 - Index used to define the order of execution */\n    order: 200,\n    /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */\n    enabled: true,\n    /** @prop {ModifierFn} */\n    fn: offset,\n    /** @prop {Number|String} offset=0\n     * The offset value as described in the modifier description\n     */\n    offset: 0\n  },\n\n  /**\n   * Modifier used to prevent the popper from being positioned outside the boundary.\n   *\n   * A scenario exists where the reference itself is not within the boundaries.<br />\n   * We can say it has \"escaped the boundaries\" — or just \"escaped\".<br />\n   * In this case we need to decide whether the popper should either:\n   *\n   * - detach from the reference and remain \"trapped\" in the boundaries, or\n   * - if it should ignore the boundary and \"escape with its reference\"\n   *\n   * When `escapeWithReference` is set to`true` and reference is completely\n   * outside its boundaries, the popper will overflow (or completely leave)\n   * the boundaries in order to remain attached to the edge of the reference.\n   *\n   * @memberof modifiers\n   * @inner\n   */\n  preventOverflow: {\n    /** @prop {number} order=300 - Index used to define the order of execution */\n    order: 300,\n    /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */\n    enabled: true,\n    /** @prop {ModifierFn} */\n    fn: preventOverflow,\n    /**\n     * @prop {Array} [priority=['left','right','top','bottom']]\n     * Popper will try to prevent overflow following these priorities by default,\n     * then, it could overflow on the left and on top of the `boundariesElement`\n     */\n    priority: ['left', 'right', 'top', 'bottom'],\n    /**\n     * @prop {number} padding=5\n     * Amount of pixel used to define a minimum distance between the boundaries\n     * and the popper. This makes sure the popper always has a little padding\n     * between the edges of its container\n     */\n    padding: 5,\n    /**\n     * @prop {String|HTMLElement} boundariesElement='scrollParent'\n     * Boundaries used by the modifier. Can be `scrollParent`, `window`,\n     * `viewport` or any DOM element.\n     */\n    boundariesElement: 'scrollParent'\n  },\n\n  /**\n   * Modifier used to make sure the reference and its popper stay near each other\n   * without leaving any gap between the two. Especially useful when the arrow is\n   * enabled and you want to ensure that it points to its reference element.\n   * It cares only about the first axis. You can still have poppers with margin\n   * between the popper and its reference element.\n   * @memberof modifiers\n   * @inner\n   */\n  keepTogether: {\n    /** @prop {number} order=400 - Index used to define the order of execution */\n    order: 400,\n    /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */\n    enabled: true,\n    /** @prop {ModifierFn} */\n    fn: keepTogether\n  },\n\n  /**\n   * This modifier is used to move the `arrowElement` of the popper to make\n   * sure it is positioned between the reference element and its popper element.\n   * It will read the outer size of the `arrowElement` node to detect how many\n   * pixels of conjunction are needed.\n   *\n   * It has no effect if no `arrowElement` is provided.\n   * @memberof modifiers\n   * @inner\n   */\n  arrow: {\n    /** @prop {number} order=500 - Index used to define the order of execution */\n    order: 500,\n    /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */\n    enabled: true,\n    /** @prop {ModifierFn} */\n    fn: arrow,\n    /** @prop {String|HTMLElement} element='[x-arrow]' - Selector or node used as arrow */\n    element: '[x-arrow]'\n  },\n\n  /**\n   * Modifier used to flip the popper's placement when it starts to overlap its\n   * reference element.\n   *\n   * Requires the `preventOverflow` modifier before it in order to work.\n   *\n   * **NOTE:** this modifier will interrupt the current update cycle and will\n   * restart it if it detects the need to flip the placement.\n   * @memberof modifiers\n   * @inner\n   */\n  flip: {\n    /** @prop {number} order=600 - Index used to define the order of execution */\n    order: 600,\n    /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */\n    enabled: true,\n    /** @prop {ModifierFn} */\n    fn: flip,\n    /**\n     * @prop {String|Array} behavior='flip'\n     * The behavior used to change the popper's placement. It can be one of\n     * `flip`, `clockwise`, `counterclockwise` or an array with a list of valid\n     * placements (with optional variations)\n     */\n    behavior: 'flip',\n    /**\n     * @prop {number} padding=5\n     * The popper will flip if it hits the edges of the `boundariesElement`\n     */\n    padding: 5,\n    /**\n     * @prop {String|HTMLElement} boundariesElement='viewport'\n     * The element which will define the boundaries of the popper position.\n     * The popper will never be placed outside of the defined boundaries\n     * (except if `keepTogether` is enabled)\n     */\n    boundariesElement: 'viewport',\n    /**\n     * @prop {Boolean} flipVariations=false\n     * The popper will switch placement variation between `-start` and `-end` when\n     * the reference element overlaps its boundaries.\n     *\n     * The original placement should have a set variation.\n     */\n    flipVariations: false,\n    /**\n     * @prop {Boolean} flipVariationsByContent=false\n     * The popper will switch placement variation between `-start` and `-end` when\n     * the popper element overlaps its reference boundaries.\n     *\n     * The original placement should have a set variation.\n     */\n    flipVariationsByContent: false\n  },\n\n  /**\n   * Modifier used to make the popper flow toward the inner of the reference element.\n   * By default, when this modifier is disabled, the popper will be placed outside\n   * the reference element.\n   * @memberof modifiers\n   * @inner\n   */\n  inner: {\n    /** @prop {number} order=700 - Index used to define the order of execution */\n    order: 700,\n    /** @prop {Boolean} enabled=false - Whether the modifier is enabled or not */\n    enabled: false,\n    /** @prop {ModifierFn} */\n    fn: inner\n  },\n\n  /**\n   * Modifier used to hide the popper when its reference element is outside of the\n   * popper boundaries. It will set a `x-out-of-boundaries` attribute which can\n   * be used to hide with a CSS selector the popper when its reference is\n   * out of boundaries.\n   *\n   * Requires the `preventOverflow` modifier before it in order to work.\n   * @memberof modifiers\n   * @inner\n   */\n  hide: {\n    /** @prop {number} order=800 - Index used to define the order of execution */\n    order: 800,\n    /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */\n    enabled: true,\n    /** @prop {ModifierFn} */\n    fn: hide\n  },\n\n  /**\n   * Computes the style that will be applied to the popper element to gets\n   * properly positioned.\n   *\n   * Note that this modifier will not touch the DOM, it just prepares the styles\n   * so that `applyStyle` modifier can apply it. This separation is useful\n   * in case you need to replace `applyStyle` with a custom implementation.\n   *\n   * This modifier has `850` as `order` value to maintain backward compatibility\n   * with previous versions of Popper.js. Expect the modifiers ordering method\n   * to change in future major versions of the library.\n   *\n   * @memberof modifiers\n   * @inner\n   */\n  computeStyle: {\n    /** @prop {number} order=850 - Index used to define the order of execution */\n    order: 850,\n    /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */\n    enabled: true,\n    /** @prop {ModifierFn} */\n    fn: computeStyle,\n    /**\n     * @prop {Boolean} gpuAcceleration=true\n     * If true, it uses the CSS 3D transformation to position the popper.\n     * Otherwise, it will use the `top` and `left` properties\n     */\n    gpuAcceleration: true,\n    /**\n     * @prop {string} [x='bottom']\n     * Where to anchor the X axis (`bottom` or `top`). AKA X offset origin.\n     * Change this if your popper should grow in a direction different from `bottom`\n     */\n    x: 'bottom',\n    /**\n     * @prop {string} [x='left']\n     * Where to anchor the Y axis (`left` or `right`). AKA Y offset origin.\n     * Change this if your popper should grow in a direction different from `right`\n     */\n    y: 'right'\n  },\n\n  /**\n   * Applies the computed styles to the popper element.\n   *\n   * All the DOM manipulations are limited to this modifier. This is useful in case\n   * you want to integrate Popper.js inside a framework or view library and you\n   * want to delegate all the DOM manipulations to it.\n   *\n   * Note that if you disable this modifier, you must make sure the popper element\n   * has its position set to `absolute` before Popper.js can do its work!\n   *\n   * Just disable this modifier and define your own to achieve the desired effect.\n   *\n   * @memberof modifiers\n   * @inner\n   */\n  applyStyle: {\n    /** @prop {number} order=900 - Index used to define the order of execution */\n    order: 900,\n    /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */\n    enabled: true,\n    /** @prop {ModifierFn} */\n    fn: applyStyle,\n    /** @prop {Function} */\n    onLoad: applyStyleOnLoad,\n    /**\n     * @deprecated since version 1.10.0, the property moved to `computeStyle` modifier\n     * @prop {Boolean} gpuAcceleration=true\n     * If true, it uses the CSS 3D transformation to position the popper.\n     * Otherwise, it will use the `top` and `left` properties\n     */\n    gpuAcceleration: undefined\n  }\n};\n\n/**\n * The `dataObject` is an object containing all the information used by Popper.js.\n * This object is passed to modifiers and to the `onCreate` and `onUpdate` callbacks.\n * @name dataObject\n * @property {Object} data.instance The Popper.js instance\n * @property {String} data.placement Placement applied to popper\n * @property {String} data.originalPlacement Placement originally defined on init\n * @property {Boolean} data.flipped True if popper has been flipped by flip modifier\n * @property {Boolean} data.hide True if the reference element is out of boundaries, useful to know when to hide the popper\n * @property {HTMLElement} data.arrowElement Node used as arrow by arrow modifier\n * @property {Object} data.styles Any CSS property defined here will be applied to the popper. It expects the JavaScript nomenclature (eg. `marginBottom`)\n * @property {Object} data.arrowStyles Any CSS property defined here will be applied to the popper arrow. It expects the JavaScript nomenclature (eg. `marginBottom`)\n * @property {Object} data.boundaries Offsets of the popper boundaries\n * @property {Object} data.offsets The measurements of popper, reference and arrow elements\n * @property {Object} data.offsets.popper `top`, `left`, `width`, `height` values\n * @property {Object} data.offsets.reference `top`, `left`, `width`, `height` values\n * @property {Object} data.offsets.arrow] `top` and `left` offsets, only one of them will be different from 0\n */\n\n/**\n * Default options provided to Popper.js constructor.<br />\n * These can be overridden using the `options` argument of Popper.js.<br />\n * To override an option, simply pass an object with the same\n * structure of the `options` object, as the 3rd argument. For example:\n * ```\n * new Popper(ref, pop, {\n *   modifiers: {\n *     preventOverflow: { enabled: false }\n *   }\n * })\n * ```\n * @type {Object}\n * @static\n * @memberof Popper\n */\nvar Defaults = {\n  /**\n   * Popper's placement.\n   * @prop {Popper.placements} placement='bottom'\n   */\n  placement: 'bottom',\n\n  /**\n   * Set this to true if you want popper to position it self in 'fixed' mode\n   * @prop {Boolean} positionFixed=false\n   */\n  positionFixed: false,\n\n  /**\n   * Whether events (resize, scroll) are initially enabled.\n   * @prop {Boolean} eventsEnabled=true\n   */\n  eventsEnabled: true,\n\n  /**\n   * Set to true if you want to automatically remove the popper when\n   * you call the `destroy` method.\n   * @prop {Boolean} removeOnDestroy=false\n   */\n  removeOnDestroy: false,\n\n  /**\n   * Callback called when the popper is created.<br />\n   * By default, it is set to no-op.<br />\n   * Access Popper.js instance with `data.instance`.\n   * @prop {onCreate}\n   */\n  onCreate: function onCreate() {},\n\n  /**\n   * Callback called when the popper is updated. This callback is not called\n   * on the initialization/creation of the popper, but only on subsequent\n   * updates.<br />\n   * By default, it is set to no-op.<br />\n   * Access Popper.js instance with `data.instance`.\n   * @prop {onUpdate}\n   */\n  onUpdate: function onUpdate() {},\n\n  /**\n   * List of modifiers used to modify the offsets before they are applied to the popper.\n   * They provide most of the functionalities of Popper.js.\n   * @prop {modifiers}\n   */\n  modifiers: modifiers\n};\n\n/**\n * @callback onCreate\n * @param {dataObject} data\n */\n\n/**\n * @callback onUpdate\n * @param {dataObject} data\n */\n\n// Utils\n// Methods\nvar Popper = function () {\n  /**\n   * Creates a new Popper.js instance.\n   * @class Popper\n   * @param {Element|referenceObject} reference - The reference element used to position the popper\n   * @param {Element} popper - The HTML / XML element used as the popper\n   * @param {Object} options - Your custom options to override the ones defined in [Defaults](#defaults)\n   * @return {Object} instance - The generated Popper.js instance\n   */\n  function Popper(reference, popper) {\n    var _this = this;\n\n    var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n    classCallCheck(this, Popper);\n\n    this.scheduleUpdate = function () {\n      return requestAnimationFrame(_this.update);\n    };\n\n    // make update() debounced, so that it only runs at most once-per-tick\n    this.update = debounce(this.update.bind(this));\n\n    // with {} we create a new object with the options inside it\n    this.options = _extends({}, Popper.Defaults, options);\n\n    // init state\n    this.state = {\n      isDestroyed: false,\n      isCreated: false,\n      scrollParents: []\n    };\n\n    // get reference and popper elements (allow jQuery wrappers)\n    this.reference = reference && reference.jquery ? reference[0] : reference;\n    this.popper = popper && popper.jquery ? popper[0] : popper;\n\n    // Deep merge modifiers options\n    this.options.modifiers = {};\n    Object.keys(_extends({}, Popper.Defaults.modifiers, options.modifiers)).forEach(function (name) {\n      _this.options.modifiers[name] = _extends({}, Popper.Defaults.modifiers[name] || {}, options.modifiers ? options.modifiers[name] : {});\n    });\n\n    // Refactoring modifiers' list (Object => Array)\n    this.modifiers = Object.keys(this.options.modifiers).map(function (name) {\n      return _extends({\n        name: name\n      }, _this.options.modifiers[name]);\n    })\n    // sort the modifiers by order\n    .sort(function (a, b) {\n      return a.order - b.order;\n    });\n\n    // modifiers have the ability to execute arbitrary code when Popper.js get inited\n    // such code is executed in the same order of its modifier\n    // they could add new properties to their options configuration\n    // BE AWARE: don't add options to `options.modifiers.name` but to `modifierOptions`!\n    this.modifiers.forEach(function (modifierOptions) {\n      if (modifierOptions.enabled && isFunction(modifierOptions.onLoad)) {\n        modifierOptions.onLoad(_this.reference, _this.popper, _this.options, modifierOptions, _this.state);\n      }\n    });\n\n    // fire the first update to position the popper in the right place\n    this.update();\n\n    var eventsEnabled = this.options.eventsEnabled;\n    if (eventsEnabled) {\n      // setup event listeners, they will take care of update the position in specific situations\n      this.enableEventListeners();\n    }\n\n    this.state.eventsEnabled = eventsEnabled;\n  }\n\n  // We can't use class properties because they don't get listed in the\n  // class prototype and break stuff like Sinon stubs\n\n\n  createClass(Popper, [{\n    key: 'update',\n    value: function update$$1() {\n      return update.call(this);\n    }\n  }, {\n    key: 'destroy',\n    value: function destroy$$1() {\n      return destroy.call(this);\n    }\n  }, {\n    key: 'enableEventListeners',\n    value: function enableEventListeners$$1() {\n      return enableEventListeners.call(this);\n    }\n  }, {\n    key: 'disableEventListeners',\n    value: function disableEventListeners$$1() {\n      return disableEventListeners.call(this);\n    }\n\n    /**\n     * Schedules an update. It will run on the next UI update available.\n     * @method scheduleUpdate\n     * @memberof Popper\n     */\n\n\n    /**\n     * Collection of utilities useful when writing custom modifiers.\n     * Starting from version 1.7, this method is available only if you\n     * include `popper-utils.js` before `popper.js`.\n     *\n     * **DEPRECATION**: This way to access PopperUtils is deprecated\n     * and will be removed in v2! Use the PopperUtils module directly instead.\n     * Due to the high instability of the methods contained in Utils, we can't\n     * guarantee them to follow semver. Use them at your own risk!\n     * @static\n     * @private\n     * @type {Object}\n     * @deprecated since version 1.8\n     * @member Utils\n     * @memberof Popper\n     */\n\n  }]);\n  return Popper;\n}();\n\n/**\n * The `referenceObject` is an object that provides an interface compatible with Popper.js\n * and lets you use it as replacement of a real DOM node.<br />\n * You can use this method to position a popper relatively to a set of coordinates\n * in case you don't have a DOM node to use as reference.\n *\n * ```\n * new Popper(referenceObject, popperNode);\n * ```\n *\n * NB: This feature isn't supported in Internet Explorer 10.\n * @name referenceObject\n * @property {Function} data.getBoundingClientRect\n * A function that returns a set of coordinates compatible with the native `getBoundingClientRect` method.\n * @property {number} data.clientWidth\n * An ES6 getter that will return the width of the virtual reference element.\n * @property {number} data.clientHeight\n * An ES6 getter that will return the height of the virtual reference element.\n */\n\n\nPopper.Utils = (typeof window !== 'undefined' ? window : global).PopperUtils;\nPopper.placements = placements;\nPopper.Defaults = Defaults;\n\nexport default Popper;\n//# sourceMappingURL=popper.js.map\n"],"sourceRoot":""}