text: /*!
   * Keen UI v1.2.0 (https://github.com/JosephusPaye/keen-ui)
   * (c) 2019 Josephus Paye II
   * Released under the MIT License.
   */
  (function webpackUniversalModuleDefinition(root, factory) {
  	if(typeof exports === 'object' && typeof module === 'object')
  		module.exports = factory();
  	else if(typeof define === 'function' && define.amd)
  		define([], factory);
  	else if(typeof exports === 'object')
  		exports["UiToolbar"] = factory();
  	else
  		root["KeenUI"] = root["KeenUI"] || {}, root["KeenUI"]["UiToolbar"] = factory();
  })(this, function() {
  return /******/ (function(modules) { // webpackBootstrap
  /******/ 	// The module cache
  /******/ 	var installedModules = {};
  
  /******/ 	// The require function
  /******/ 	function __webpack_require__(moduleId) {
  
  /******/ 		// Check if module is in cache
  /******/ 		if(installedModules[moduleId])
  /******/ 			return installedModules[moduleId].exports;
  
  /******/ 		// Create a new module (and put it into the cache)
  /******/ 		var module = installedModules[moduleId] = {
  /******/ 			i: moduleId,
  /******/ 			l: false,
  /******/ 			exports: {}
  /******/ 		};
  
  /******/ 		// Execute the module function
  /******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
  
  /******/ 		// Flag the module as loaded
  /******/ 		module.l = true;
  
  /******/ 		// Return the exports of the module
  /******/ 		return module.exports;
  /******/ 	}
  
  
  /******/ 	// expose the modules object (__webpack_modules__)
  /******/ 	__webpack_require__.m = modules;
  
  /******/ 	// expose the module cache
  /******/ 	__webpack_require__.c = installedModules;
  
  /******/ 	// identity function for calling harmony imports with the correct context
  /******/ 	__webpack_require__.i = function(value) { return value; };
  
  /******/ 	// define getter function for harmony exports
  /******/ 	__webpack_require__.d = function(exports, name, getter) {
  /******/ 		if(!__webpack_require__.o(exports, name)) {
  /******/ 			Object.defineProperty(exports, name, {
  /******/ 				configurable: false,
  /******/ 				enumerable: true,
  /******/ 				get: getter
  /******/ 			});
  /******/ 		}
  /******/ 	};
  
  /******/ 	// getDefaultExport function for compatibility with non-harmony modules
  /******/ 	__webpack_require__.n = function(module) {
  /******/ 		var getter = module && module.__esModule ?
  /******/ 			function getDefault() { return module['default']; } :
  /******/ 			function getModuleExports() { return module; };
  /******/ 		__webpack_require__.d(getter, 'a', getter);
  /******/ 		return getter;
  /******/ 	};
  
  /******/ 	// Object.prototype.hasOwnProperty.call
  /******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
  
  /******/ 	// __webpack_public_path__
  /******/ 	__webpack_require__.p = "";
  
  /******/ 	// Load entry module and return exports
  /******/ 	return __webpack_require__(__webpack_require__.s = 263);
  /******/ })
  /************************************************************************/
  /******/ ({
  
  /***/ 0:
  /***/ (function(module, exports) {
  
  /*
  	MIT License http://www.opensource.org/licenses/mit-license.php
  	Author Tobias Koppers @sokra
  */
  // css base code, injected by the css-loader
  module.exports = function() {
  	var list = [];
  
  	// return the list of modules as css string
  	list.toString = function toString() {
  		var result = [];
  		for(var i = 0; i < this.length; i++) {
  			var item = this[i];
  			if(item[2]) {
  				result.push("@media " + item[2] + "{" + item[1] + "}");
  			} else {
  				result.push(item[1]);
  			}
  		}
  		return result.join("");
  	};
  
  	// import a list of modules into the list
  	list.i = function(modules, mediaQuery) {
  		if(typeof modules === "string")
  			modules = [[null, modules, ""]];
  		var alreadyImportedModules = {};
  		for(var i = 0; i < this.length; i++) {
  			var id = this[i][0];
  			if(typeof id === "number")
  				alreadyImportedModules[id] = true;
  		}
  		for(i = 0; i < modules.length; i++) {
  			var item = modules[i];
  			// skip already imported module
  			// this implementation is not 100% perfect for weird media query combinations
  			//  when a module is imported multiple times with different media queries.
  			//  I hope this will never occur (Hey this way we have smaller bundles)
  			if(typeof item[0] !== "number" || !alreadyImportedModules[item[0]]) {
  				if(mediaQuery && !item[2]) {
  					item[2] = mediaQuery;
  				} else if(mediaQuery) {
  					item[2] = "(" + item[2] + ") and (" + mediaQuery + ")";
  				}
  				list.push(item);
  			}
  		}
  	};
  	return list;
  };
  
  
  /***/ }),
  
  /***/ 1:
  /***/ (function(module, exports) {
  
  /* globals __VUE_SSR_CONTEXT__ */
  
  // this module is a runtime utility for cleaner component module output and will
  // be included in the final webpack user bundle
  
  module.exports = function normalizeComponent (
    rawScriptExports,
    compiledTemplate,
    injectStyles,
    scopeId,
    moduleIdentifier /* server only */
  ) {
    var esModule
    var scriptExports = rawScriptExports = rawScriptExports || {}
  
    // ES6 modules interop
    var type = typeof rawScriptExports.default
    if (type === 'object' || type === 'function') {
      esModule = rawScriptExports
      scriptExports = rawScriptExports.default
    }
  
    // Vue.extend constructor export interop
    var options = typeof scriptExports === 'function'
      ? scriptExports.options
      : scriptExports
  
    // render functions
    if (compiledTemplate) {
      options.render = compiledTemplate.render
      options.staticRenderFns = compiledTemplate.staticRenderFns
    }
  
    // scopedId
    if (scopeId) {
      options._scopeId = scopeId
    }
  
    var hook
    if (moduleIdentifier) { // server build
      hook = function (context) {
        // 2.3 injection
        context =
          context || // cached call
          (this.$vnode && this.$vnode.ssrContext) || // stateful
          (this.parent && this.parent.$vnode && this.parent.$vnode.ssrContext) // functional
        // 2.2 with runInNewContext: true
        if (!context && typeof __VUE_SSR_CONTEXT__ !== 'undefined') {
          context = __VUE_SSR_CONTEXT__
        }
        // inject component styles
        if (injectStyles) {
          injectStyles.call(this, context)
        }
        // register component module identifier for async chunk inferrence
        if (context && context._registeredComponents) {
          context._registeredComponents.add(moduleIdentifier)
        }
      }
      // used by ssr in case component is cached and beforeCreate
      // never gets called
      options._ssrRegister = hook
    } else if (injectStyles) {
      hook = injectStyles
    }
  
    if (hook) {
      var functional = options.functional
      var existing = functional
        ? options.render
        : options.beforeCreate
      if (!functional) {
        // inject component registration as beforeCreate hook
        options.beforeCreate = existing
          ? [].concat(existing, hook)
          : [hook]
      } else {
        // register for functioal component in vue file
        options.render = function renderWithStyleInjection (h, context) {
          hook.call(context)
          return existing(h, context)
        }
      }
    }
  
    return {
      esModule: esModule,
      exports: scriptExports,
      options: options
    }
  }
  
  
  /***/ }),
  
  /***/ 10:
  /***/ (function(module, exports, __webpack_require__) {
  
  // style-loader: Adds some css to the DOM by adding a <style> tag
  
  // load the styles
  var content = __webpack_require__(8);
  if(typeof content === 'string') content = [[module.i, content, '']];
  if(content.locals) module.exports = content.locals;
  // add the styles to the DOM
  var update = __webpack_require__(2)("c3ae284a", content, false);
  // Hot Module Replacement
  if(false) {
   // When the styles change, update the <style> tags
   if(!content.locals) {
     module.hot.accept("!!../node_modules/css-loader/index.js!../node_modules/vue-loader/lib/style-compiler/index.js?{\"vue\":true,\"id\":\"data-v-39a27af7\",\"scoped\":false,\"hasInlineConfig\":true}!../node_modules/sass-loader/index.js!../node_modules/vue-loader/lib/selector.js?type=styles&index=0!./UiIcon.vue", function() {
       var newContent = require("!!../node_modules/css-loader/index.js!../node_modules/vue-loader/lib/style-compiler/index.js?{\"vue\":true,\"id\":\"data-v-39a27af7\",\"scoped\":false,\"hasInlineConfig\":true}!../node_modules/sass-loader/index.js!../node_modules/vue-loader/lib/selector.js?type=styles&index=0!./UiIcon.vue");
       if(typeof newContent === 'string') newContent = [[module.id, newContent, '']];
       update(newContent);
     });
   }
   // When the module is disposed, remove the <style> tags
   module.hot.dispose(function() { update(); });
  }
  
  /***/ }),
  
  /***/ 103:
  /***/ (function(module, exports, __webpack_require__) {
  
  // style-loader: Adds some css to the DOM by adding a <style> tag
  
  // load the styles
  var content = __webpack_require__(92);
  if(typeof content === 'string') content = [[module.i, content, '']];
  if(content.locals) module.exports = content.locals;
  // add the styles to the DOM
  var update = __webpack_require__(2)("3178b48b", content, false);
  // Hot Module Replacement
  if(false) {
   // When the styles change, update the <style> tags
   if(!content.locals) {
     module.hot.accept("!!../node_modules/css-loader/index.js!../node_modules/vue-loader/lib/style-compiler/index.js?{\"vue\":true,\"id\":\"data-v-22995a30\",\"scoped\":false,\"hasInlineConfig\":true}!../node_modules/sass-loader/index.js!../node_modules/vue-loader/lib/selector.js?type=styles&index=0!./UiProgressLinear.vue", function() {
       var newContent = require("!!../node_modules/css-loader/index.js!../node_modules/vue-loader/lib/style-compiler/index.js?{\"vue\":true,\"id\":\"data-v-22995a30\",\"scoped\":false,\"hasInlineConfig\":true}!../node_modules/sass-loader/index.js!../node_modules/vue-loader/lib/selector.js?type=styles&index=0!./UiProgressLinear.vue");
       if(typeof newContent === 'string') newContent = [[module.id, newContent, '']];
       update(newContent);
     });
   }
   // When the module is disposed, remove the <style> tags
   module.hot.dispose(function() { update(); });
  }
  
  /***/ }),
  
  /***/ 11:
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  Object.defineProperty(__webpack_exports__, "__esModule", { value: true });
  /* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__babel_loader_node_modules_vue_loader_lib_selector_type_script_index_0_UiRippleInk_vue__ = __webpack_require__(12);
  /* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__node_modules_vue_loader_lib_template_compiler_index_id_data_v_5ef65288_hasScoped_false_node_modules_vue_loader_lib_selector_type_template_index_0_UiRippleInk_vue__ = __webpack_require__(14);
  var disposed = false
  function injectStyle (ssrContext) {
    if (disposed) return
    __webpack_require__(15)
  }
  var normalizeComponent = __webpack_require__(1)
  /* script */
  
  /* template */
  
  /* styles */
  var __vue_styles__ = injectStyle
  /* scopeId */
  var __vue_scopeId__ = null
  /* moduleIdentifier (server only) */
  var __vue_module_identifier__ = null
  var Component = normalizeComponent(
    __WEBPACK_IMPORTED_MODULE_0__babel_loader_node_modules_vue_loader_lib_selector_type_script_index_0_UiRippleInk_vue__["a" /* default */],
    __WEBPACK_IMPORTED_MODULE_1__node_modules_vue_loader_lib_template_compiler_index_id_data_v_5ef65288_hasScoped_false_node_modules_vue_loader_lib_selector_type_template_index_0_UiRippleInk_vue__["a" /* default */],
    __vue_styles__,
    __vue_scopeId__,
    __vue_module_identifier__
  )
  Component.options.__file = "src\\UiRippleInk.vue"
  if (Component.esModule && Object.keys(Component.esModule).some(function (key) {return key !== "default" && key.substr(0, 2) !== "__"})) {console.error("named exports are not supported in *.vue files.")}
  if (Component.options.functional) {console.error("[vue-loader] UiRippleInk.vue: functional components are not supported with templates, they should use render functions.")}
  
  /* hot reload */
  if (false) {(function () {
    var hotAPI = require("vue-hot-reload-api")
    hotAPI.install(require("vue"), false)
    if (!hotAPI.compatible) return
    module.hot.accept()
    if (!module.hot.data) {
      hotAPI.createRecord("data-v-5ef65288", Component.options)
    } else {
      hotAPI.reload("data-v-5ef65288", Component.options)
    }
    module.hot.dispose(function (data) {
      disposed = true
    })
  })()}
  
  /* harmony default export */ __webpack_exports__["default"] = Component.exports;
  
  
  /***/ }),
  
  /***/ 12:
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  /* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__helpers_classlist__ = __webpack_require__(5);
  /* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__helpers_element_ref__ = __webpack_require__(4);
  
  
  
  
  var startRipple = function startRipple(eventType, event) {
      var holder = event.currentTarget || event.target;
  
      if (holder && !__WEBPACK_IMPORTED_MODULE_0__helpers_classlist__["a" /* default */].has(holder, 'ui-ripple-ink')) {
          holder = holder.querySelector('.ui-ripple-ink');
      }
  
      if (!holder) {
          return;
      }
  
      var prev = holder.getAttribute('data-ui-event');
  
      if (prev && prev !== eventType) {
          return;
      }
  
      holder.setAttribute('data-ui-event', eventType);
  
      var rect = holder.getBoundingClientRect();
      var x = event.clientX - rect.left;
      var y = event.clientY - rect.top;
  
      var ripple = document.createElement('div');
      var max = void 0;
  
      if (rect.width === rect.height) {
          max = rect.width * 1.412;
      } else {
          max = Math.sqrt(rect.width * rect.width + rect.height * rect.height);
      }
  
      var size = max * 2 + 'px';
  
      ripple.style.width = size;
      ripple.style.height = size;
      ripple.style.marginLeft = -max + x + 'px';
      ripple.style.marginTop = -max + y + 'px';
  
      ripple.className = 'ui-ripple-ink__ink';
      holder.appendChild(ripple);
  
      setTimeout(function () {
          __WEBPACK_IMPORTED_MODULE_0__helpers_classlist__["a" /* default */].add(ripple, 'is-held');
      }, 0);
  
      var releaseEvent = eventType === 'mousedown' ? 'mouseup' : 'touchend';
  
      var handleRelease = function handleRelease() {
          document.removeEventListener(releaseEvent, handleRelease);
  
          __WEBPACK_IMPORTED_MODULE_0__helpers_classlist__["a" /* default */].add(ripple, 'is-done');
  
          var timeout = 650;
  
          setTimeout(function () {
              holder.removeChild(ripple);
  
              if (holder.children.length === 0) {
                  holder.removeAttribute('data-ui-event');
              }
          }, timeout);
      };
  
      document.addEventListener(releaseEvent, handleRelease);
  };
  
  var handleMouseDown = function handleMouseDown(e) {
      if (e.button === 0) {
          startRipple(e.type, e);
      }
  };
  
  var handleTouchStart = function handleTouchStart(e) {
      if (e.changedTouches) {
          for (var i = 0; i < e.changedTouches.length; ++i) {
              startRipple(e.type, e.changedTouches[i]);
          }
      }
  };
  
  /* harmony default export */ __webpack_exports__["a"] = {
      name: 'ui-ripple-ink',
  
      props: {
          trigger: {
              validator: function validator(value) {
                  return __WEBPACK_IMPORTED_MODULE_1__helpers_element_ref__["a" /* default */].validate(value, '[UiRippleInk]: Invalid prop: "trigger". Expected Element, VueComponent or CSS selector string.');
              }
          }
      },
  
      watch: {
          trigger: function trigger() {
              this.setupRipple();
          }
      },
  
      created: function created() {
          this.triggerEl = null;
      },
      mounted: function mounted() {
          this.setupRipple();
      },
      beforeDestroy: function beforeDestroy() {
          this.destroyRipple();
      },
  
  
      methods: {
          setupRipple: function setupRipple() {
              this.triggerEl = __WEBPACK_IMPORTED_MODULE_1__helpers_element_ref__["a" /* default */].resolve(this.trigger, this.$el.parentElement);
  
              if (!this.triggerEl) {
                  console.error('[UiRippleInk]: Trigger element not found.');
                  return;
              }
  
              this.triggerEl.addEventListener('touchstart', handleTouchStart);
              this.triggerEl.addEventListener('mousedown', handleMouseDown);
          },
          destroyRipple: function destroyRipple() {
              if (!this.triggerEl) {
                  return;
              }
  
              this.triggerEl.removeEventListener('mousedown', handleMouseDown);
              this.triggerEl.removeEventListener('touchstart', handleTouchStart);
          }
      }
  };
  
  /***/ }),
  
  /***/ 126:
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  Object.defineProperty(__webpack_exports__, "__esModule", { value: true });
  /* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__babel_loader_node_modules_vue_loader_lib_selector_type_script_index_0_UiToolbar_vue__ = __webpack_require__(151);
  /* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__node_modules_vue_loader_lib_template_compiler_index_id_data_v_b19a1326_hasScoped_false_node_modules_vue_loader_lib_selector_type_template_index_0_UiToolbar_vue__ = __webpack_require__(204);
  var disposed = false
  function injectStyle (ssrContext) {
    if (disposed) return
    __webpack_require__(228)
  }
  var normalizeComponent = __webpack_require__(1)
  /* script */
  
  /* template */
  
  /* styles */
  var __vue_styles__ = injectStyle
  /* scopeId */
  var __vue_scopeId__ = null
  /* moduleIdentifier (server only) */
  var __vue_module_identifier__ = null
  var Component = normalizeComponent(
    __WEBPACK_IMPORTED_MODULE_0__babel_loader_node_modules_vue_loader_lib_selector_type_script_index_0_UiToolbar_vue__["a" /* default */],
    __WEBPACK_IMPORTED_MODULE_1__node_modules_vue_loader_lib_template_compiler_index_id_data_v_b19a1326_hasScoped_false_node_modules_vue_loader_lib_selector_type_template_index_0_UiToolbar_vue__["a" /* default */],
    __vue_styles__,
    __vue_scopeId__,
    __vue_module_identifier__
  )
  Component.options.__file = "src\\UiToolbar.vue"
  if (Component.esModule && Object.keys(Component.esModule).some(function (key) {return key !== "default" && key.substr(0, 2) !== "__"})) {console.error("named exports are not supported in *.vue files.")}
  if (Component.options.functional) {console.error("[vue-loader] UiToolbar.vue: functional components are not supported with templates, they should use render functions.")}
  
  /* hot reload */
  if (false) {(function () {
    var hotAPI = require("vue-hot-reload-api")
    hotAPI.install(require("vue"), false)
    if (!hotAPI.compatible) return
    module.hot.accept()
    if (!module.hot.data) {
      hotAPI.createRecord("data-v-b19a1326", Component.options)
    } else {
      hotAPI.reload("data-v-b19a1326", Component.options)
    }
    module.hot.dispose(function (data) {
      disposed = true
    })
  })()}
  
  /* harmony default export */ __webpack_exports__["default"] = Component.exports;
  
  
  /***/ }),
  
  /***/ 13:
  /***/ (function(module, exports, __webpack_require__) {
  
  exports = module.exports = __webpack_require__(0)();
  // imports
  
  
  // module
  exports.push([module.i, "\n.ui-ripple-ink {\n  border-radius: inherit;\n  bottom: 0;\n  display: block;\n  left: 0;\n  overflow: hidden;\n  position: absolute;\n  right: 0;\n  top: 0;\n  -webkit-mask-image: -webkit-radial-gradient(circle, white, black);\n}\n.ui-ripple-ink__ink {\n  background-clip: padding-box;\n  background-color: currentColor;\n  border-radius: 50%;\n  height: 0;\n  opacity: 0.2;\n  pointer-events: none;\n  position: absolute;\n  -webkit-transform: scale(0);\n          transform: scale(0);\n  -webkit-transition: opacity 0.6s ease-out, -webkit-transform 0.6s ease-out;\n  transition: opacity 0.6s ease-out, -webkit-transform 0.6s ease-out;\n  transition: transform 0.6s ease-out, opacity 0.6s ease-out;\n  transition: transform 0.6s ease-out, opacity 0.6s ease-out, -webkit-transform 0.6s ease-out;\n  -webkit-user-select: none;\n     -moz-user-select: none;\n      -ms-user-select: none;\n          user-select: none;\n  width: 0;\n}\n.ui-ripple-ink__ink.is-held {\n    opacity: 0.4;\n    -webkit-transform: scale(1);\n            transform: scale(1);\n}\n.ui-ripple-ink__ink.is-done {\n    opacity: 0 !important;\n}\n", ""]);
  
  // exports
  
  
  /***/ }),
  
  /***/ 14:
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  var render = function () {var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;
    return _c('div', {
      staticClass: "ui-ripple-ink"
    })
  }
  var staticRenderFns = []
  render._withStripped = true
  var esExports = { render: render, staticRenderFns: staticRenderFns }
  /* harmony default export */ __webpack_exports__["a"] = esExports;
  if (false) {
    module.hot.accept()
    if (module.hot.data) {
       require("vue-hot-reload-api").rerender("data-v-5ef65288", esExports)
    }
  }
  
  /***/ }),
  
  /***/ 15:
  /***/ (function(module, exports, __webpack_require__) {
  
  // style-loader: Adds some css to the DOM by adding a <style> tag
  
  // load the styles
  var content = __webpack_require__(13);
  if(typeof content === 'string') content = [[module.i, content, '']];
  if(content.locals) module.exports = content.locals;
  // add the styles to the DOM
  var update = __webpack_require__(2)("1485a295", content, false);
  // Hot Module Replacement
  if(false) {
   // When the styles change, update the <style> tags
   if(!content.locals) {
     module.hot.accept("!!../node_modules/css-loader/index.js!../node_modules/vue-loader/lib/style-compiler/index.js?{\"vue\":true,\"id\":\"data-v-5ef65288\",\"scoped\":false,\"hasInlineConfig\":true}!../node_modules/sass-loader/index.js!../node_modules/vue-loader/lib/selector.js?type=styles&index=0!./UiRippleInk.vue", function() {
       var newContent = require("!!../node_modules/css-loader/index.js!../node_modules/vue-loader/lib/style-compiler/index.js?{\"vue\":true,\"id\":\"data-v-5ef65288\",\"scoped\":false,\"hasInlineConfig\":true}!../node_modules/sass-loader/index.js!../node_modules/vue-loader/lib/selector.js?type=styles&index=0!./UiRippleInk.vue");
       if(typeof newContent === 'string') newContent = [[module.id, newContent, '']];
       update(newContent);
     });
   }
   // When the module is disposed, remove the <style> tags
   module.hot.dispose(function() { update(); });
  }
  
  /***/ }),
  
  /***/ 151:
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  /* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__UiIconButton_vue__ = __webpack_require__(43);
  /* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__UiProgressLinear_vue__ = __webpack_require__(80);
  
  
  
  
  
  /* harmony default export */ __webpack_exports__["a"] = {
      name: 'ui-toolbar',
  
      props: {
          type: {
              type: String,
              default: 'default' },
          textColor: {
              type: String,
              default: 'black' },
          title: String,
          brand: String,
          removeBrandDivider: {
              type: Boolean,
              default: false
          },
          navIcon: {
              type: String,
              default: 'menu'
          },
          removeNavIcon: {
              type: Boolean,
              default: false
          },
          raised: {
              type: Boolean,
              default: true
          },
          progressPosition: {
              type: String,
              default: 'bottom' },
          loading: {
              type: Boolean,
              default: false
          }
      },
  
      computed: {
          classes: function classes() {
              return ['ui-toolbar--type-' + this.type, 'ui-toolbar--text-color-' + this.textColor, 'ui-toolbar--progress-position-' + this.progressPosition, { 'is-raised': this.raised }];
          },
          progressColor: function progressColor() {
              return this.textColor === 'black' ? 'primary' : 'white';
          },
          hasBrandDivider: function hasBrandDivider() {
              return this.removeBrandDivider ? false : this.brand || this.$slots.brand;
          }
      },
  
      methods: {
          navIconClick: function navIconClick() {
              this.$emit('nav-icon-click');
          }
      },
  
      components: {
          UiIconButton: __WEBPACK_IMPORTED_MODULE_0__UiIconButton_vue__["default"],
          UiProgressLinear: __WEBPACK_IMPORTED_MODULE_1__UiProgressLinear_vue__["default"]
      }
  };
  
  /***/ }),
  
  /***/ 16:
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  /* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_popper_js__ = __webpack_require__(21);
  /**!
  * tippy.js v4.2.1
  * (c) 2017-2019 atomiks
  * MIT License
  */
  
  
  function _extends() {
    _extends = Object.assign || function (target) {
      for (var i = 1; i < arguments.length; i++) {
        var source = arguments[i];
  
        for (var key in source) {
          if (Object.prototype.hasOwnProperty.call(source, key)) {
            target[key] = source[key];
          }
        }
      }
  
      return target;
    };
  
    return _extends.apply(this, arguments);
  }
  
  var version = "4.2.1";
  
  var isBrowser = typeof window !== 'undefined' && typeof document !== 'undefined';
  var ua = isBrowser ? navigator.userAgent : '';
  var isIE = /MSIE |Trident\//.test(ua);
  var isUCBrowser = /UCBrowser\//.test(ua);
  var isIOS = isBrowser && /iPhone|iPad|iPod/.test(navigator.platform) && !window.MSStream;
  
  var defaultProps = {
    a11y: true,
    allowHTML: true,
    animateFill: true,
    animation: 'shift-away',
    appendTo: function appendTo() {
      return document.body;
    },
    aria: 'describedby',
    arrow: false,
    arrowType: 'sharp',
    boundary: 'scrollParent',
    content: '',
    delay: 0,
    distance: 10,
    duration: [325, 275],
    flip: true,
    flipBehavior: 'flip',
    flipOnUpdate: false,
    followCursor: false,
    hideOnClick: true,
    ignoreAttributes: false,
    inertia: false,
    interactive: false,
    interactiveBorder: 2,
    interactiveDebounce: 0,
    lazy: true,
    maxWidth: 350,
    multiple: false,
    offset: 0,
    onHidden: function onHidden() {},
    onHide: function onHide() {},
    onMount: function onMount() {},
    onShow: function onShow() {},
    onShown: function onShown() {},
    placement: 'top',
    popperOptions: {},
    role: 'tooltip',
    showOnInit: false,
    size: 'regular',
    sticky: false,
    target: '',
    theme: 'dark',
    touch: true,
    touchHold: false,
    trigger: 'mouseenter focus',
    updateDuration: 0,
    wait: null,
    zIndex: 9999
    /**
     * If the set() method encounters one of these, the popperInstance must be
     * recreated
     */
  
  };
  var POPPER_INSTANCE_DEPENDENCIES = ['arrow', 'arrowType', 'boundary', 'distance', 'flip', 'flipBehavior', 'flipOnUpdate', 'offset', 'placement', 'popperOptions'];
  
  var elementProto = isBrowser ? Element.prototype : {};
  var matches = elementProto.matches || elementProto.matchesSelector || elementProto.webkitMatchesSelector || elementProto.mozMatchesSelector || elementProto.msMatchesSelector;
  /**
   * Ponyfill for Array.from - converts iterable values to an array
   */
  
  function arrayFrom(value) {
    return [].slice.call(value);
  }
  /**
   * Ponyfill for Element.prototype.closest
   */
  
  function closest(element, parentSelector) {
    return (elementProto.closest || function (selector) {
      // @ts-ignore
      var el = this;
  
      while (el) {
        if (matches.call(el, selector)) {
          return el;
        }
  
        el = el.parentElement;
      }
    }).call(element, parentSelector);
  }
  /**
   * Works like Element.prototype.closest, but uses a callback instead
   */
  
  function closestCallback(element, callback) {
    while (element) {
      if (callback(element)) {
        return element;
      }
  
      element = element.parentElement;
    }
  }
  
  // Passive event listener config
  var PASSIVE = {
    passive: true // Popper `preventOverflow` padding
  
  };
  var PADDING = 4; // Popper attributes
  // In Popper v2 these will be `data-*` instead of `x-*` to adhere to HTML5 spec
  
  var PLACEMENT_ATTRIBUTE = 'x-placement';
  var OUT_OF_BOUNDARIES_ATTRIBUTE = 'x-out-of-boundaries'; // Classes
  
  var IOS_CLASS = 'tippy-iOS';
  var ACTIVE_CLASS = 'tippy-active'; // Selectors
  
  var POPPER_SELECTOR = '.tippy-popper';
  var TOOLTIP_SELECTOR = '.tippy-tooltip';
  var CONTENT_SELECTOR = '.tippy-content';
  var BACKDROP_SELECTOR = '.tippy-backdrop';
  var ARROW_SELECTOR = '.tippy-arrow';
  var ROUND_ARROW_SELECTOR = '.tippy-roundarrow';
  
  var keys = Object.keys(defaultProps);
  /**
   * Returns an object of optional props from data-tippy-* attributes
   */
  
  function getDataAttributeOptions(reference) {
    return keys.reduce(function (acc, key) {
      var valueAsString = (reference.getAttribute("data-tippy-".concat(key)) || '').trim();
  
      if (!valueAsString) {
        return acc;
      }
  
      if (key === 'content') {
        acc[key] = valueAsString;
      } else {
        try {
          acc[key] = JSON.parse(valueAsString);
        } catch (e) {
          acc[key] = valueAsString;
        }
      }
  
      return acc;
    }, {});
  }
  /**
   * Polyfills the virtual reference (plain object) with Element.prototype props
   * Mutating because DOM elements are mutated, adds `_tippy` property
   */
  
  function polyfillElementPrototypeProperties(virtualReference) {
    var polyfills = {
      isVirtual: true,
      attributes: virtualReference.attributes || {},
      setAttribute: function setAttribute(key, value) {
        virtualReference.attributes[key] = value;
      },
      getAttribute: function getAttribute(key) {
        return virtualReference.attributes[key];
      },
      removeAttribute: function removeAttribute(key) {
        delete virtualReference.attributes[key];
      },
      hasAttribute: function hasAttribute(key) {
        return key in virtualReference.attributes;
      },
      addEventListener: function addEventListener() {},
      removeEventListener: function removeEventListener() {},
      classList: {
        classNames: {},
        add: function add(key) {
          virtualReference.classList.classNames[key] = true;
        },
        remove: function remove(key) {
          delete virtualReference.classList.classNames[key];
        },
        contains: function contains(key) {
          return key in virtualReference.classList.classNames;
        }
      }
    };
  
    for (var key in polyfills) {
      virtualReference[key] = polyfills[key];
    }
  }
  
  /**
   * Determines if a value is a "bare" virtual element (before mutations done
   * by `polyfillElementPrototypeProperties()`). JSDOM elements show up as
   * [object Object], we can check if the value is "element-like" if it has
   * `addEventListener`
   */
  
  function isBareVirtualElement(value) {
    return {}.toString.call(value) === '[object Object]' && !value.addEventListener;
  }
  /**
   * Safe .hasOwnProperty check, for prototype-less objects
   */
  
  function hasOwnProperty(obj, key) {
    return {}.hasOwnProperty.call(obj, key);
  }
  /**
   * Returns an array of elements based on the value
   */
  
  function getArrayOfElements(value) {
    if (isSingular(value)) {
      // TODO: VirtualReference is not compatible to type Element
      return [value];
    }
  
    if (value instanceof NodeList) {
      return arrayFrom(value);
    }
  
    if (Array.isArray(value)) {
      return value;
    }
  
    try {
      return arrayFrom(document.querySelectorAll(value));
    } catch (e) {
      return [];
    }
  }
  /**
   * Returns a value at a given index depending on if it's an array or number
   */
  
  function getValue(value, index, defaultValue) {
    if (Array.isArray(value)) {
      var v = value[index];
      return v == null ? defaultValue : v;
    }
  
    return value;
  }
  /**
   * Debounce utility
   */
  
  function debounce(fn, ms) {
    var timeoutId;
    return function () {
      var _this = this,
          _arguments = arguments;
  
      clearTimeout(timeoutId); // @ts-ignore
  
      timeoutId = setTimeout(function () {
        return fn.apply(_this, _arguments);
      }, ms);
    };
  }
  /**
   * Prevents errors from being thrown while accessing nested modifier objects
   * in `popperOptions`
   */
  
  function getModifier(obj, key) {
    return obj && obj.modifiers && obj.modifiers[key];
  }
  /**
   * Determines if an array or string includes a value
   */
  
  function includes(a, b) {
    return a.indexOf(b) > -1;
  }
  /**
   * Determines if the value is singular-like
   */
  
  function isSingular(value) {
    return !!(value && hasOwnProperty(value, 'isVirtual')) || value instanceof Element;
  }
  /**
   * Firefox extensions don't allow setting .innerHTML directly, this will trick it
   */
  
  function innerHTML() {
    return 'innerHTML';
  }
  /**
   * Evaluates a function if one, or returns the value
   */
  
  function evaluateValue(value, args) {
    return typeof value === 'function' ? value.apply(null, args) : value;
  }
  /**
   * Sets a popperInstance `flip` modifier's enabled state
   */
  
  function setFlipModifierEnabled(modifiers, value) {
    modifiers.filter(function (m) {
      return m.name === 'flip';
    })[0].enabled = value;
  }
  /**
   * Determines if an element can receive focus
   * Always returns true for virtual objects
   */
  
  function canReceiveFocus(element) {
    return element instanceof Element ? matches.call(element, 'a[href],area[href],button,details,input,textarea,select,iframe,[tabindex]') && !element.hasAttribute('disabled') : true;
  }
  /**
   * Returns a new `div` element
   */
  
  function div() {
    return document.createElement('div');
  }
  /**
   * Applies a transition duration to a list of elements
   */
  
  function setTransitionDuration(els, value) {
    els.forEach(function (el) {
      if (el) {
        el.style.transitionDuration = "".concat(value, "ms");
      }
    });
  }
  /**
   * Sets the visibility state to elements so they can begin to transition
   */
  
  function setVisibilityState(els, state) {
    els.forEach(function (el) {
      if (el) {
        el.setAttribute('data-state', state);
      }
    });
  }
  /**
   * Evaluates the props object by merging data attributes and
   * disabling conflicting options where necessary
   */
  
  function evaluateProps(reference, props) {
    var out = _extends({}, props, {
      content: evaluateValue(props.content, [reference])
    }, props.ignoreAttributes ? {} : getDataAttributeOptions(reference));
  
    if (out.arrow || isUCBrowser) {
      out.animateFill = false;
    }
  
    return out;
  }
  /**
   * Validates an object of options with the valid default props object
   */
  
  function validateOptions(options, defaultProps) {
    Object.keys(options).forEach(function (option) {
      if (!hasOwnProperty(defaultProps, option)) {
        throw new Error("[tippy]: `".concat(option, "` is not a valid option"));
      }
    });
  }
  
  /**
   * Sets the innerHTML of an element
   */
  
  function setInnerHTML(element, html) {
    element[innerHTML()] = html instanceof Element ? html[innerHTML()] : html;
  }
  /**
   * Sets the content of a tooltip
   */
  
  function setContent(contentEl, props) {
    if (props.content instanceof Element) {
      setInnerHTML(contentEl, '');
      contentEl.appendChild(props.content);
    } else if (typeof props.content !== 'function') {
      var key = props.allowHTML ? 'innerHTML' : 'textContent';
      contentEl[key] = props.content;
    }
  }
  /**
   * Returns the child elements of a popper element
   */
  
  function getChildren(popper) {
    return {
      tooltip: popper.querySelector(TOOLTIP_SELECTOR),
      backdrop: popper.querySelector(BACKDROP_SELECTOR),
      content: popper.querySelector(CONTENT_SELECTOR),
      arrow: popper.querySelector(ARROW_SELECTOR) || popper.querySelector(ROUND_ARROW_SELECTOR)
    };
  }
  /**
   * Adds `data-inertia` attribute
   */
  
  function addInertia(tooltip) {
    tooltip.setAttribute('data-inertia', '');
  }
  /**
   * Removes `data-inertia` attribute
   */
  
  function removeInertia(tooltip) {
    tooltip.removeAttribute('data-inertia');
  }
  /**
   * Creates an arrow element and returns it
   */
  
  function createArrowElement(arrowType) {
    var arrow = div();
  
    if (arrowType === 'round') {
      arrow.className = 'tippy-roundarrow';
      setInnerHTML(arrow, '<svg viewBox="0 0 18 7" xmlns="http://www.w3.org/2000/svg"><path d="M0 7s2.021-.015 5.253-4.218C6.584 1.051 7.797.007 9 0c1.203-.007 2.416 1.035 3.761 2.782C16.012 7.005 18 7 18 7H0z"/></svg>');
    } else {
      arrow.className = 'tippy-arrow';
    }
  
    return arrow;
  }
  /**
   * Creates a backdrop element and returns it
   */
  
  function createBackdropElement() {
    var backdrop = div();
    backdrop.className = 'tippy-backdrop';
    backdrop.setAttribute('data-state', 'hidden');
    return backdrop;
  }
  /**
   * Adds interactive-related attributes
   */
  
  function addInteractive(popper, tooltip) {
    popper.setAttribute('tabindex', '-1');
    tooltip.setAttribute('data-interactive', '');
  }
  /**
   * Removes interactive-related attributes
   */
  
  function removeInteractive(popper, tooltip) {
    popper.removeAttribute('tabindex');
    tooltip.removeAttribute('data-interactive');
  }
  /**
   * Add/remove transitionend listener from tooltip
   */
  
  function updateTransitionEndListener(tooltip, action, listener) {
    // UC Browser hasn't adopted the `transitionend` event despite supporting
    // unprefixed transitions...
    var eventName = isUCBrowser && document.body.style.webkitTransition !== undefined ? 'webkitTransitionEnd' : 'transitionend';
    tooltip[action + 'EventListener'](eventName, listener);
  }
  /**
   * Returns the popper's placement, ignoring shifting (top-start, etc)
   */
  
  function getBasicPlacement(popper) {
    var fullPlacement = popper.getAttribute(PLACEMENT_ATTRIBUTE);
    return fullPlacement ? fullPlacement.split('-')[0] : '';
  }
  /**
   * Triggers reflow
   */
  
  function reflow(popper) {
    void popper.offsetHeight;
  }
  /**
   * Adds/removes theme from tooltip's classList
   */
  
  function updateTheme(tooltip, action, theme) {
    theme.split(' ').forEach(function (themeName) {
      tooltip.classList[action](themeName + '-theme');
    });
  }
  /**
   * Constructs the popper element and returns it
   */
  
  function createPopperElement(id, props) {
    var popper = div();
    popper.className = 'tippy-popper';
    popper.id = "tippy-".concat(id);
    popper.style.zIndex = '' + props.zIndex;
  
    if (props.role) {
      popper.setAttribute('role', props.role);
    }
  
    var tooltip = div();
    tooltip.className = 'tippy-tooltip';
    tooltip.style.maxWidth = props.maxWidth + (typeof props.maxWidth === 'number' ? 'px' : '');
    tooltip.setAttribute('data-size', props.size);
    tooltip.setAttribute('data-animation', props.animation);
    tooltip.setAttribute('data-state', 'hidden');
    updateTheme(tooltip, 'add', props.theme);
    var content = div();
    content.className = 'tippy-content';
    content.setAttribute('data-state', 'hidden');
  
    if (props.interactive) {
      addInteractive(popper, tooltip);
    }
  
    if (props.arrow) {
      tooltip.appendChild(createArrowElement(props.arrowType));
    }
  
    if (props.animateFill) {
      tooltip.appendChild(createBackdropElement());
      tooltip.setAttribute('data-animatefill', '');
    }
  
    if (props.inertia) {
      addInertia(tooltip);
    }
  
    setContent(content, props);
    tooltip.appendChild(content);
    popper.appendChild(tooltip);
    return popper;
  }
  /**
   * Updates the popper element based on the new props
   */
  
  function updatePopperElement(popper, prevProps, nextProps) {
    var _getChildren = getChildren(popper),
        tooltip = _getChildren.tooltip,
        content = _getChildren.content,
        backdrop = _getChildren.backdrop,
        arrow = _getChildren.arrow;
  
    popper.style.zIndex = '' + nextProps.zIndex;
    tooltip.setAttribute('data-size', nextProps.size);
    tooltip.setAttribute('data-animation', nextProps.animation);
    tooltip.style.maxWidth = nextProps.maxWidth + (typeof nextProps.maxWidth === 'number' ? 'px' : '');
  
    if (nextProps.role) {
      popper.setAttribute('role', nextProps.role);
    } else {
      popper.removeAttribute('role');
    }
  
    if (prevProps.content !== nextProps.content) {
      setContent(content, nextProps);
    } // animateFill
  
  
    if (!prevProps.animateFill && nextProps.animateFill) {
      tooltip.appendChild(createBackdropElement());
      tooltip.setAttribute('data-animatefill', '');
    } else if (prevProps.animateFill && !nextProps.animateFill) {
      tooltip.removeChild(backdrop);
      tooltip.removeAttribute('data-animatefill');
    } // arrow
  
  
    if (!prevProps.arrow && nextProps.arrow) {
      tooltip.appendChild(createArrowElement(nextProps.arrowType));
    } else if (prevProps.arrow && !nextProps.arrow) {
      tooltip.removeChild(arrow);
    } // arrowType
  
  
    if (prevProps.arrow && nextProps.arrow && prevProps.arrowType !== nextProps.arrowType) {
      tooltip.replaceChild(createArrowElement(nextProps.arrowType), arrow);
    } // interactive
  
  
    if (!prevProps.interactive && nextProps.interactive) {
      addInteractive(popper, tooltip);
    } else if (prevProps.interactive && !nextProps.interactive) {
      removeInteractive(popper, tooltip);
    } // inertia
  
  
    if (!prevProps.inertia && nextProps.inertia) {
      addInertia(tooltip);
    } else if (prevProps.inertia && !nextProps.inertia) {
      removeInertia(tooltip);
    } // theme
  
  
    if (prevProps.theme !== nextProps.theme) {
      updateTheme(tooltip, 'remove', prevProps.theme);
      updateTheme(tooltip, 'add', nextProps.theme);
    }
  }
  /**
   * Runs the callback after the popper's position has been updated
   * update() is debounced with Promise.resolve() or setTimeout()
   * scheduleUpdate() is update() wrapped in requestAnimationFrame()
   */
  
  function afterPopperPositionUpdates(popperInstance, callback) {
    var popper = popperInstance.popper,
        options = popperInstance.options;
    var onCreate = options.onCreate,
        onUpdate = options.onUpdate;
  
    options.onCreate = options.onUpdate = function (data) {
      reflow(popper);
      callback();
  
      if (onUpdate) {
        onUpdate(data);
      }
  
      options.onCreate = onCreate;
      options.onUpdate = onUpdate;
    };
  }
  /**
   * Hides all visible poppers on the document
   */
  
  function hideAll() {
    var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
        checkHideOnClick = _ref.checkHideOnClick,
        exclude = _ref.exclude,
        duration = _ref.duration;
  
    arrayFrom(document.querySelectorAll(POPPER_SELECTOR)).forEach(function (popper) {
      var instance = popper._tippy;
  
      if (instance && (checkHideOnClick ? instance.props.hideOnClick === true : true) && (!exclude || popper !== exclude.popper)) {
        instance.hide(duration);
      }
    });
  }
  /**
   * Determines if the mouse cursor is outside of the popper's interactive border
   * region
   */
  
  function isCursorOutsideInteractiveBorder(popperPlacement, popperRect, event, props) {
    if (!popperPlacement) {
      return true;
    }
  
    var x = event.clientX,
        y = event.clientY;
    var interactiveBorder = props.interactiveBorder,
        distance = props.distance;
    var exceedsTop = popperRect.top - y > (popperPlacement === 'top' ? interactiveBorder + distance : interactiveBorder);
    var exceedsBottom = y - popperRect.bottom > (popperPlacement === 'bottom' ? interactiveBorder + distance : interactiveBorder);
    var exceedsLeft = popperRect.left - x > (popperPlacement === 'left' ? interactiveBorder + distance : interactiveBorder);
    var exceedsRight = x - popperRect.right > (popperPlacement === 'right' ? interactiveBorder + distance : interactiveBorder);
    return exceedsTop || exceedsBottom || exceedsLeft || exceedsRight;
  }
  /**
   * Returns the distance offset, taking into account the default offset due to
   * the transform: translate() rule (10px) in CSS
   */
  
  function getOffsetDistanceInPx(distance) {
    return -(distance - 10) + 'px';
  }
  
  var isUsingTouch = false;
  function onDocumentTouch() {
    if (isUsingTouch) {
      return;
    }
  
    isUsingTouch = true;
  
    if (isIOS) {
      document.body.classList.add(IOS_CLASS);
    }
  
    if (window.performance) {
      document.addEventListener('mousemove', onDocumentMouseMove);
    }
  }
  var lastMouseMoveTime = 0;
  function onDocumentMouseMove() {
    var now = performance.now(); // Chrome 60+ is 1 mousemove per animation frame, use 20ms time difference
  
    if (now - lastMouseMoveTime < 20) {
      isUsingTouch = false;
      document.removeEventListener('mousemove', onDocumentMouseMove);
  
      if (!isIOS) {
        document.body.classList.remove(IOS_CLASS);
      }
    }
  
    lastMouseMoveTime = now;
  }
  function onDocumentClick(event) {
    // Simulated events dispatched on the document
    if (!(event.target instanceof Element)) {
      return hideAll();
    } // Clicked on an interactive popper
  
  
    var popper = closest(event.target, POPPER_SELECTOR);
  
    if (popper && popper._tippy && popper._tippy.props.interactive) {
      return;
    } // Clicked on a reference
  
  
    var reference = closestCallback(event.target, function (el) {
      return el._tippy && el._tippy.reference === el;
    });
  
    if (reference) {
      var instance = reference._tippy;
  
      if (instance) {
        var isClickTrigger = includes(instance.props.trigger || '', 'click');
  
        if (isUsingTouch || isClickTrigger) {
          return hideAll({
            exclude: instance,
            checkHideOnClick: true
          });
        }
  
        if (instance.props.hideOnClick !== true || isClickTrigger) {
          return;
        }
  
        instance.clearDelayTimeouts();
      }
    }
  
    hideAll({
      checkHideOnClick: true
    });
  }
  function onWindowBlur() {
    var _document = document,
        activeElement = _document.activeElement;
  
    if (activeElement && activeElement.blur && activeElement._tippy) {
      activeElement.blur();
    }
  }
  /**
   * Adds the needed global event listeners
   */
  
  function bindGlobalEventListeners() {
    document.addEventListener('click', onDocumentClick, true);
    document.addEventListener('touchstart', onDocumentTouch, PASSIVE);
    window.addEventListener('blur', onWindowBlur);
  }
  
  var idCounter = 1;
  /**
   * Creates and returns a Tippy object. We're using a closure pattern instead of
   * a class so that the exposed object API is clean without private members
   * prefixed with `_`.
   */
  
  function createTippy(reference, collectionProps) {
    var props = evaluateProps(reference, collectionProps); // If the reference shouldn't have multiple tippys, return null early
  
    if (!props.multiple && reference._tippy) {
      return null;
    }
    /* ======================= 🔒 Private members 🔒 ======================= */
  
  
    var lastTriggerEventType;
    var lastMouseMoveEvent;
    var showTimeoutId;
    var hideTimeoutId;
    var animationFrameId;
    var isScheduledToShow = false;
    var currentParentNode;
    var previousPlacement;
    var wasVisibleDuringPreviousUpdate = false;
    var currentTransitionEndListener;
    var listeners = [];
    var debouncedOnMouseMove = props.interactiveDebounce > 0 ? debounce(onMouseMove, props.interactiveDebounce) : onMouseMove;
    /* ======================= 🔑 Public members 🔑 ======================= */
  
    var id = idCounter++;
    var popper = createPopperElement(id, props);
    var popperChildren = getChildren(popper);
    var popperInstance = null;
    var state = {
      // Is the instance currently enabled?
      isEnabled: true,
      // Is the tippy currently showing and not transitioning out?
      isVisible: false,
      // Has the instance been destroyed?
      isDestroyed: false,
      // Is the tippy currently mounted to the DOM?
      isMounted: false,
      // Has the tippy finished transitioning in?
      isShown: false
    };
    var instance = {
      // properties
      id: id,
      reference: reference,
      popper: popper,
      popperChildren: popperChildren,
      popperInstance: popperInstance,
      props: props,
      state: state,
      // methods
      clearDelayTimeouts: clearDelayTimeouts,
      set: set,
      setContent: setContent$$1,
      show: show,
      hide: hide,
      enable: enable,
      disable: disable,
      destroy: destroy
      /* ==================== Initial instance mutations =================== */
  
    };
    reference._tippy = instance;
    popper._tippy = instance;
    addTriggersToReference();
  
    if (!props.lazy) {
      createPopperInstance();
      instance.popperInstance.disableEventListeners();
    }
  
    if (props.showOnInit) {
      scheduleShow();
    } // Ensure the reference element can receive focus (and is not a delegate)
  
  
    if (props.a11y && !props.target && !canReceiveFocus(reference)) {
      reference.setAttribute('tabindex', '0');
    } // Prevent a tippy with a delay from hiding if the cursor left then returned
    // before it started hiding
  
  
    popper.addEventListener('mouseenter', function (event) {
      if (instance.props.interactive && instance.state.isVisible && lastTriggerEventType === 'mouseenter') {
        scheduleShow(event);
      }
    });
    popper.addEventListener('mouseleave', function () {
      if (instance.props.interactive && lastTriggerEventType === 'mouseenter') {
        document.addEventListener('mousemove', debouncedOnMouseMove);
      }
    });
    return instance;
    /* ======================= 🔒 Private methods 🔒 ======================= */
  
    /**
     * Removes the follow cursor listener
     */
  
    function removeFollowCursorListener() {
      document.removeEventListener('mousemove', positionVirtualReferenceNearCursor);
    }
    /**
     * Cleans up old listeners
     */
  
  
    function cleanupOldMouseListeners() {
      document.body.removeEventListener('mouseleave', scheduleHide);
      document.removeEventListener('mousemove', debouncedOnMouseMove);
    }
    /**
     * Returns transitionable inner elements used in show/hide methods
     */
  
  
    function getTransitionableElements() {
      return [instance.popperChildren.tooltip, instance.popperChildren.backdrop, instance.popperChildren.content];
    }
    /**
     * Determines if the instance is in `followCursor` mode
     */
  
  
    function hasFollowCursorBehavior() {
      return instance.props.followCursor && !isUsingTouch && lastTriggerEventType !== 'focus';
    }
    /**
     * Updates the tooltip's position on each animation frame
     */
  
  
    function makeSticky() {
      setTransitionDuration([instance.popper], isIE ? 0 : instance.props.updateDuration);
  
      function updatePosition() {
        if (instance.popperInstance) {
          instance.popperInstance.scheduleUpdate();
        }
  
        if (instance.state.isMounted) {
          requestAnimationFrame(updatePosition);
        } else {
          setTransitionDuration([instance.popper], 0);
        }
      }
  
      updatePosition();
    }
    /**
     * Invokes a callback once the tooltip has fully transitioned out
     */
  
  
    function onTransitionedOut(duration, callback) {
      onTransitionEnd(duration, function () {
        if (!instance.state.isVisible && currentParentNode && currentParentNode.contains(instance.popper)) {
          callback();
        }
      });
    }
    /**
     * Invokes a callback once the tooltip has fully transitioned in
     */
  
  
    function onTransitionedIn(duration, callback) {
      onTransitionEnd(duration, callback);
    }
    /**
     * Invokes a callback once the tooltip's CSS transition ends
     */
  
  
    function onTransitionEnd(duration, callback) {
      var tooltip = instance.popperChildren.tooltip;
      /**
       * Listener added as the `transitionend` handler
       */
  
      function listener(event) {
        if (event.target === tooltip) {
          updateTransitionEndListener(tooltip, 'remove', listener);
          callback();
        }
      } // Make callback synchronous if duration is 0
      // `transitionend` won't fire otherwise
  
  
      if (duration === 0) {
        return callback();
      }
  
      updateTransitionEndListener(tooltip, 'remove', currentTransitionEndListener);
      updateTransitionEndListener(tooltip, 'add', listener);
      currentTransitionEndListener = listener;
    }
    /**
     * Adds an event listener to the reference and stores it in `listeners`
     */
  
  
    function on(eventType, handler) {
      var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
      instance.reference.addEventListener(eventType, handler, options);
      listeners.push({
        eventType: eventType,
        handler: handler,
        options: options
      });
    }
    /**
     * Adds event listeners to the reference based on the `trigger` prop
     */
  
  
    function addTriggersToReference() {
      if (instance.props.touchHold && !instance.props.target) {
        on('touchstart', onTrigger, PASSIVE);
        on('touchend', onMouseLeave, PASSIVE);
      }
  
      instance.props.trigger.trim().split(' ').forEach(function (eventType) {
        if (eventType === 'manual') {
          return;
        } // Non-delegates
  
  
        if (!instance.props.target) {
          on(eventType, onTrigger);
  
          switch (eventType) {
            case 'mouseenter':
              on('mouseleave', onMouseLeave);
              break;
  
            case 'focus':
              on(isIE ? 'focusout' : 'blur', onBlur);
              break;
          }
        } else {
          // Delegates
          switch (eventType) {
            case 'mouseenter':
              on('mouseover', onDelegateShow);
              on('mouseout', onDelegateHide);
              break;
  
            case 'focus':
              on('focusin', onDelegateShow);
              on('focusout', onDelegateHide);
              break;
  
            case 'click':
              on(eventType, onDelegateShow);
              break;
          }
        }
      });
    }
    /**
     * Removes event listeners from the reference
     */
  
  
    function removeTriggersFromReference() {
      listeners.forEach(function (_ref) {
        var eventType = _ref.eventType,
            handler = _ref.handler,
            options = _ref.options;
        instance.reference.removeEventListener(eventType, handler, options);
      });
      listeners = [];
    }
    /**
     * Positions the virtual reference near the cursor
     */
  
  
    function positionVirtualReferenceNearCursor(event) {
      var _lastMouseMoveEvent = lastMouseMoveEvent = event,
          clientX = _lastMouseMoveEvent.clientX,
          clientY = _lastMouseMoveEvent.clientY;
  
      if (!instance.popperInstance) {
        return;
      } // Ensure virtual reference is padded to prevent tooltip from
      // overflowing. Maybe Popper.js issue?
  
  
      var placement = getBasicPlacement(instance.popper);
      var padding = instance.props.arrow ? PADDING + (instance.props.arrowType === 'round' ? 18 : 16) : PADDING;
      var isVerticalPlacement = includes(['top', 'bottom'], placement);
      var isHorizontalPlacement = includes(['left', 'right'], placement); // Top / left boundary
  
      var x = isVerticalPlacement ? Math.max(padding, clientX) : clientX;
      var y = isHorizontalPlacement ? Math.max(padding, clientY) : clientY; // Bottom / right boundary
  
      if (isVerticalPlacement && x > padding) {
        x = Math.min(clientX, window.innerWidth - padding);
      }
  
      if (isHorizontalPlacement && y > padding) {
        y = Math.min(clientY, window.innerHeight - padding);
      }
  
      var rect = instance.reference.getBoundingClientRect();
      var followCursor = instance.props.followCursor;
      var isHorizontal = followCursor === 'horizontal';
      var isVertical = followCursor === 'vertical';
      instance.popperInstance.reference = _extends({}, instance.popperInstance.reference, {
        getBoundingClientRect: function getBoundingClientRect() {
          return {
            width: 0,
            height: 0,
            top: isHorizontal ? rect.top : y,
            bottom: isHorizontal ? rect.bottom : y,
            left: isVertical ? rect.left : x,
            right: isVertical ? rect.right : x
          };
        },
        clientWidth: 0,
        clientHeight: 0
      });
      instance.popperInstance.scheduleUpdate();
  
      if (followCursor === 'initial' && instance.state.isVisible) {
        removeFollowCursorListener();
      }
    }
    /**
     * Creates the tippy instance for a delegate when it's been triggered
     */
  
  
    function createDelegateChildTippy(event) {
      if (event) {
        var targetEl = closest(event.target, instance.props.target);
  
        if (targetEl && !targetEl._tippy) {
          createTippy(targetEl, _extends({}, instance.props, {
            content: evaluateValue(collectionProps.content, [targetEl]),
            appendTo: collectionProps.appendTo,
            target: '',
            showOnInit: true
          }));
          scheduleShow(event);
        }
      }
    }
    /**
     * Event listener invoked upon trigger
     */
  
  
    function onTrigger(event) {
      if (!instance.state.isEnabled || isEventListenerStopped(event)) {
        return;
      }
  
      if (!instance.state.isVisible) {
        lastTriggerEventType = event.type;
  
        if (event instanceof MouseEvent) {
          lastMouseMoveEvent = event;
        }
      } // Toggle show/hide when clicking click-triggered tooltips
  
  
      if (event.type === 'click' && instance.props.hideOnClick !== false && instance.state.isVisible) {
        scheduleHide();
      } else {
        scheduleShow(event);
      }
    }
    /**
     * Event listener used for interactive tooltips to detect when they should
     * hide
     */
  
  
    function onMouseMove(event) {
      var referenceTheCursorIsOver = closestCallback(event.target, function (el) {
        return el._tippy;
      });
      var isCursorOverPopper = closest(event.target, POPPER_SELECTOR) === instance.popper;
      var isCursorOverReference = referenceTheCursorIsOver === instance.reference;
  
      if (isCursorOverPopper || isCursorOverReference) {
        return;
      }
  
      if (isCursorOutsideInteractiveBorder(getBasicPlacement(instance.popper), instance.popper.getBoundingClientRect(), event, instance.props)) {
        cleanupOldMouseListeners();
        scheduleHide();
      }
    }
    /**
     * Event listener invoked upon mouseleave
     */
  
  
    function onMouseLeave(event) {
      if (isEventListenerStopped(event)) {
        return;
      }
  
      if (instance.props.interactive) {
        document.body.addEventListener('mouseleave', scheduleHide);
        document.addEventListener('mousemove', debouncedOnMouseMove);
        return;
      }
  
      scheduleHide();
    }
    /**
     * Event listener invoked upon blur
     */
  
  
    function onBlur(event) {
      if (event.target !== instance.reference) {
        return;
      }
  
      if (instance.props.interactive && event.relatedTarget && instance.popper.contains(event.relatedTarget)) {
        return;
      }
  
      scheduleHide();
    }
    /**
     * Event listener invoked when a child target is triggered
     */
  
  
    function onDelegateShow(event) {
      if (closest(event.target, instance.props.target)) {
        scheduleShow(event);
      }
    }
    /**
     * Event listener invoked when a child target should hide
     */
  
  
    function onDelegateHide(event) {
      if (closest(event.target, instance.props.target)) {
        scheduleHide();
      }
    }
    /**
     * Determines if an event listener should stop further execution due to the
     * `touchHold` option
     */
  
  
    function isEventListenerStopped(event) {
      var supportsTouch = 'ontouchstart' in window;
      var isTouchEvent = includes(event.type, 'touch');
      var touchHold = instance.props.touchHold;
      return supportsTouch && isUsingTouch && touchHold && !isTouchEvent || isUsingTouch && !touchHold && isTouchEvent;
    }
    /**
     * Creates the popper instance for the instance
     */
  
  
    function createPopperInstance() {
      var popperOptions = instance.props.popperOptions;
      var _instance$popperChild = instance.popperChildren,
          tooltip = _instance$popperChild.tooltip,
          arrow = _instance$popperChild.arrow;
      var preventOverflowModifier = getModifier(popperOptions, 'preventOverflow');
  
      function applyMutations(data) {
        if (instance.props.flip && !instance.props.flipOnUpdate) {
          if (data.flipped) {
            instance.popperInstance.options.placement = data.placement;
          }
  
          setFlipModifierEnabled(instance.popperInstance.modifiers, false);
        } // Apply all of the popper's attributes to the tootip node as well.
        // Allows users to avoid using the .tippy-popper selector for themes.
  
  
        tooltip.setAttribute(PLACEMENT_ATTRIBUTE, data.placement);
  
        if (data.attributes[OUT_OF_BOUNDARIES_ATTRIBUTE] !== false) {
          tooltip.setAttribute(OUT_OF_BOUNDARIES_ATTRIBUTE, '');
        } else {
          tooltip.removeAttribute(OUT_OF_BOUNDARIES_ATTRIBUTE);
        } // Prevents a transition when changing placements (while tippy is visible)
        // for scroll/resize updates
  
  
        if (previousPlacement && previousPlacement !== data.placement && wasVisibleDuringPreviousUpdate) {
          tooltip.style.transition = 'none';
          requestAnimationFrame(function () {
            tooltip.style.transition = '';
          });
        }
  
        previousPlacement = data.placement;
        wasVisibleDuringPreviousUpdate = instance.state.isVisible;
        var basicPlacement = getBasicPlacement(instance.popper);
        var styles = tooltip.style; // Account for the `distance` offset
  
        styles.top = styles.bottom = styles.left = styles.right = '';
        styles[basicPlacement] = getOffsetDistanceInPx(instance.props.distance);
        var padding = preventOverflowModifier && preventOverflowModifier.padding !== undefined ? preventOverflowModifier.padding : PADDING;
        var isPaddingNumber = typeof padding === 'number';
  
        var computedPadding = _extends({
          top: isPaddingNumber ? padding : padding.top,
          bottom: isPaddingNumber ? padding : padding.bottom,
          left: isPaddingNumber ? padding : padding.left,
          right: isPaddingNumber ? padding : padding.right
        }, !isPaddingNumber && padding);
  
        computedPadding[basicPlacement] = isPaddingNumber ? padding + instance.props.distance : (padding[basicPlacement] || 0) + instance.props.distance;
        instance.popperInstance.modifiers.filter(function (m) {
          return m.name === 'preventOverflow';
        })[0].padding = computedPadding;
      }
  
      var config = _extends({
        placement: instance.props.placement
      }, popperOptions, {
        modifiers: _extends({}, popperOptions ? popperOptions.modifiers : {}, {
          preventOverflow: _extends({
            boundariesElement: instance.props.boundary,
            padding: PADDING
          }, preventOverflowModifier),
          arrow: _extends({
            element: arrow,
            enabled: !!arrow
          }, getModifier(popperOptions, 'arrow')),
          flip: _extends({
            enabled: instance.props.flip,
            // The tooltip is offset by 10px from the popper in CSS,
            // we need to account for its distance
            padding: instance.props.distance + PADDING,
            behavior: instance.props.flipBehavior
          }, getModifier(popperOptions, 'flip')),
          offset: _extends({
            offset: instance.props.offset
          }, getModifier(popperOptions, 'offset'))
        }),
        // This gets invoked when calling `.set()` and updating a popper
        // instance dependency, since a new popper instance gets created
        onCreate: function onCreate(data) {
          applyMutations(data);
  
          if (popperOptions && popperOptions.onCreate) {
            popperOptions.onCreate(data);
          }
        },
        // This gets invoked on initial create and show()/scroll/resize update.
        // This is due to `afterPopperPositionUpdates` overwriting onCreate()
        // with onUpdate()
        onUpdate: function onUpdate(data) {
          applyMutations(data);
  
          if (popperOptions && popperOptions.onUpdate) {
            popperOptions.onUpdate(data);
          }
        }
      });
  
      instance.popperInstance = new __WEBPACK_IMPORTED_MODULE_0_popper_js__["a" /* default */](instance.reference, instance.popper, config);
    }
    /**
     * Mounts the tooltip to the DOM, callback to show tooltip is run **after**
     * popper's position has updated
     */
  
  
    function mount(callback) {
      var shouldEnableListeners = !hasFollowCursorBehavior() && !(instance.props.followCursor === 'initial' && isUsingTouch);
  
      if (!instance.popperInstance) {
        createPopperInstance();
  
        if (!shouldEnableListeners) {
          instance.popperInstance.disableEventListeners();
        }
      } else {
        if (!hasFollowCursorBehavior()) {
          instance.popperInstance.scheduleUpdate();
  
          if (shouldEnableListeners) {
            instance.popperInstance.enableEventListeners();
          }
        }
  
        setFlipModifierEnabled(instance.popperInstance.modifiers, instance.props.flip);
      } // If the instance previously had followCursor behavior, it will be
      // positioned incorrectly if triggered by `focus` afterwards.
      // Update the reference back to the real DOM element
  
  
      instance.popperInstance.reference = instance.reference;
      var arrow = instance.popperChildren.arrow;
  
      if (hasFollowCursorBehavior()) {
        if (arrow) {
          arrow.style.margin = '0';
        }
  
        if (lastMouseMoveEvent) {
          positionVirtualReferenceNearCursor(lastMouseMoveEvent);
        }
      } else if (arrow) {
        arrow.style.margin = '';
      } // Allow followCursor: 'initial' on touch devices
  
  
      if (isUsingTouch && lastMouseMoveEvent && instance.props.followCursor === 'initial') {
        positionVirtualReferenceNearCursor(lastMouseMoveEvent);
  
        if (arrow) {
          arrow.style.margin = '0';
        }
      }
  
      afterPopperPositionUpdates(instance.popperInstance, callback);
      var appendTo = instance.props.appendTo;
      currentParentNode = appendTo === 'parent' ? instance.reference.parentNode : evaluateValue(appendTo, [instance.reference]);
  
      if (!currentParentNode.contains(instance.popper)) {
        currentParentNode.appendChild(instance.popper);
        instance.props.onMount(instance);
        instance.state.isMounted = true;
      }
    }
    /**
     * Setup before show() is invoked (delays, etc.)
     */
  
  
    function scheduleShow(event) {
      clearDelayTimeouts();
  
      if (instance.state.isVisible) {
        return;
      } // Is a delegate, create an instance for the child target
  
  
      if (instance.props.target) {
        return createDelegateChildTippy(event);
      }
  
      isScheduledToShow = true;
  
      if (instance.props.wait) {
        return instance.props.wait(instance, event);
      } // If the tooltip has a delay, we need to be listening to the mousemove as
      // soon as the trigger event is fired, so that it's in the correct position
      // upon mount.
      // Edge case: if the tooltip is still mounted, but then scheduleShow() is
      // called, it causes a jump.
  
  
      if (hasFollowCursorBehavior() && !instance.state.isMounted) {
        document.addEventListener('mousemove', positionVirtualReferenceNearCursor);
      }
  
      var delay = getValue(instance.props.delay, 0, defaultProps.delay);
  
      if (delay) {
        showTimeoutId = setTimeout(function () {
          show();
        }, delay);
      } else {
        show();
      }
    }
    /**
     * Setup before hide() is invoked (delays, etc.)
     */
  
  
    function scheduleHide() {
      clearDelayTimeouts();
  
      if (!instance.state.isVisible) {
        return removeFollowCursorListener();
      }
  
      isScheduledToShow = false;
      var delay = getValue(instance.props.delay, 1, defaultProps.delay);
  
      if (delay) {
        hideTimeoutId = setTimeout(function () {
          if (instance.state.isVisible) {
            hide();
          }
        }, delay);
      } else {
        // Fixes a `transitionend` problem when it fires 1 frame too
        // late sometimes, we don't want hide() to be called.
        animationFrameId = requestAnimationFrame(function () {
          hide();
        });
      }
    }
    /* ======================= 🔑 Public methods 🔑 ======================= */
  
    /**
     * Enables the instance to allow it to show or hide
     */
  
  
    function enable() {
      instance.state.isEnabled = true;
    }
    /**
     * Disables the instance to disallow it to show or hide
     */
  
  
    function disable() {
      instance.state.isEnabled = false;
    }
    /**
     * Clears pending timeouts related to the `delay` prop if any
     */
  
  
    function clearDelayTimeouts() {
      clearTimeout(showTimeoutId);
      clearTimeout(hideTimeoutId);
      cancelAnimationFrame(animationFrameId);
    }
    /**
     * Sets new props for the instance and redraws the tooltip
     */
  
  
    function set(options) {
      // Backwards-compatible after TypeScript change
      options = options || {};
      validateOptions(options, defaultProps);
      var prevProps = instance.props;
      var nextProps = evaluateProps(instance.reference, _extends({}, instance.props, options, {
        ignoreAttributes: true
      }));
      nextProps.ignoreAttributes = hasOwnProperty(options, 'ignoreAttributes') ? options.ignoreAttributes || false : prevProps.ignoreAttributes;
      instance.props = nextProps;
  
      if (hasOwnProperty(options, 'trigger') || hasOwnProperty(options, 'touchHold')) {
        removeTriggersFromReference();
        addTriggersToReference();
      }
  
      if (hasOwnProperty(options, 'interactiveDebounce')) {
        cleanupOldMouseListeners();
        debouncedOnMouseMove = debounce(onMouseMove, options.interactiveDebounce || 0);
      }
  
      updatePopperElement(instance.popper, prevProps, nextProps);
      instance.popperChildren = getChildren(instance.popper);
  
      if (instance.popperInstance) {
        instance.popperInstance.update();
  
        if (POPPER_INSTANCE_DEPENDENCIES.some(function (prop) {
          return hasOwnProperty(options, prop) && options[prop] !== prevProps[prop];
        })) {
          instance.popperInstance.destroy();
          createPopperInstance();
  
          if (!instance.state.isVisible) {
            instance.popperInstance.disableEventListeners();
          }
  
          if (instance.props.followCursor && lastMouseMoveEvent) {
            positionVirtualReferenceNearCursor(lastMouseMoveEvent);
          }
        }
      }
    }
    /**
     * Shortcut for .set({ content: newContent })
     */
  
  
    function setContent$$1(content) {
      set({
        content: content
      });
    }
    /**
     * Shows the tooltip
     */
  
  
    function show() {
      var duration = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : getValue(instance.props.duration, 0, defaultProps.duration[1]);
  
      if (instance.state.isDestroyed || !instance.state.isEnabled || isUsingTouch && !instance.props.touch) {
        return;
      } // Standardize `disabled` behavior across browsers.
      // Firefox allows events on disabled elements, but Chrome doesn't.
      // Using a wrapper element (i.e. <span>) is recommended.
  
  
      if (instance.reference.hasAttribute('disabled')) {
        return;
      }
  
      if (instance.props.onShow(instance) === false) {
        return;
      }
  
      instance.popper.style.visibility = 'visible';
      instance.state.isVisible = true;
  
      if (instance.props.interactive) {
        instance.reference.classList.add(ACTIVE_CLASS);
      }
  
      var transitionableElements = getTransitionableElements(); // Prevent a transition if the popper is at the opposite placement
  
      setTransitionDuration(transitionableElements.concat(instance.popper), 0);
      mount(function () {
        if (!instance.state.isVisible) {
          return;
        } // Double update will apply correct mutations
  
  
        if (!hasFollowCursorBehavior()) {
          instance.popperInstance.update();
        }
  
        if (instance.popperChildren.backdrop) {
          instance.popperChildren.content.style.transitionDelay = Math.round(duration / 12) + 'ms';
        }
  
        if (instance.props.sticky) {
          makeSticky();
        }
  
        setTransitionDuration([instance.popper], props.updateDuration);
        setTransitionDuration(transitionableElements, duration);
        setVisibilityState(transitionableElements, 'visible');
        onTransitionedIn(duration, function () {
          if (instance.props.aria) {
            instance.reference.setAttribute("aria-".concat(instance.props.aria), instance.popper.id);
          }
  
          instance.props.onShown(instance);
          instance.state.isShown = true;
        });
      });
    }
    /**
     * Hides the tooltip
     */
  
  
    function hide() {
      var duration = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : getValue(instance.props.duration, 1, defaultProps.duration[1]);
  
      if (instance.state.isDestroyed || !instance.state.isEnabled) {
        return;
      }
  
      if (instance.props.onHide(instance) === false) {
        return;
      }
  
      instance.popper.style.visibility = 'hidden';
      instance.state.isVisible = false;
      instance.state.isShown = false;
      wasVisibleDuringPreviousUpdate = false;
  
      if (instance.props.interactive) {
        instance.reference.classList.remove(ACTIVE_CLASS);
      }
  
      var transitionableElements = getTransitionableElements();
      setTransitionDuration(transitionableElements, duration);
      setVisibilityState(transitionableElements, 'hidden');
      onTransitionedOut(duration, function () {
        if (!isScheduledToShow) {
          removeFollowCursorListener();
        }
  
        if (instance.props.aria) {
          instance.reference.removeAttribute("aria-".concat(instance.props.aria));
        }
  
        instance.popperInstance.disableEventListeners();
        instance.popperInstance.options.placement = instance.props.placement;
        currentParentNode.removeChild(instance.popper);
        instance.props.onHidden(instance);
        instance.state.isMounted = false;
      });
    }
    /**
     * Destroys the tooltip
     */
  
  
    function destroy(destroyTargetInstances) {
      if (instance.state.isDestroyed) {
        return;
      } // If the popper is currently mounted to the DOM, we want to ensure it gets
      // hidden and unmounted instantly upon destruction
  
  
      if (instance.state.isMounted) {
        hide(0);
      }
  
      removeTriggersFromReference();
      delete instance.reference._tippy;
  
      if (instance.props.target && destroyTargetInstances) {
        arrayFrom(instance.reference.querySelectorAll(instance.props.target)).forEach(function (child) {
          if (child._tippy) {
            child._tippy.destroy();
          }
        });
      }
  
      if (instance.popperInstance) {
        instance.popperInstance.destroy();
      }
  
      instance.state.isDestroyed = true;
    }
  }
  
  /**
   * Groups an array of instances by taking control of their props during
   * certain lifecycles.
   */
  
  function group(instances) {
    var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
        _ref$delay = _ref.delay,
        delay = _ref$delay === void 0 ? instances[0].props.delay : _ref$delay,
        _ref$duration = _ref.duration,
        duration = _ref$duration === void 0 ? 0 : _ref$duration;
  
    // Already grouped. Cannot group instances more than once (yet) or stale lifecycle
    // closures will be invoked, causing a stack overflow
    if (instances.some(function (instance) {
      return hasOwnProperty(instance, '_originalProps');
    })) {
      return;
    }
  
    var isAnyTippyOpen = false;
    instances.forEach(function (instance) {
      instance._originalProps = _extends({}, instance.props);
    });
  
    function setIsAnyTippyOpen(value) {
      isAnyTippyOpen = value;
      updateInstances();
    }
  
    function onShow(instance) {
      instance._originalProps.onShow(instance);
  
      instances.forEach(function (instance) {
        instance.set({
          duration: duration
        });
        instance.hide();
      });
      setIsAnyTippyOpen(true);
    }
  
    function onHide(instance) {
      instance._originalProps.onHide(instance);
  
      setIsAnyTippyOpen(false);
    }
  
    function onShown(instance) {
      instance._originalProps.onShown(instance);
  
      instance.set({
        duration: instance._originalProps.duration
      });
    }
  
    function updateInstances() {
      instances.forEach(function (instance) {
        instance.set({
          onShow: onShow,
          onShown: onShown,
          onHide: onHide,
          delay: isAnyTippyOpen ? [0, Array.isArray(delay) ? delay[1] : delay] : delay,
          duration: isAnyTippyOpen ? duration : instance._originalProps.duration
        });
      });
    }
  
    updateInstances();
  }
  
  var globalEventListenersBound = false;
  /**
   * Exported module
   */
  
  function tippy(targets, options) {
    validateOptions(options || {}, defaultProps);
  
    if (!globalEventListenersBound) {
      bindGlobalEventListeners();
      globalEventListenersBound = true;
    }
  
    var props = _extends({}, defaultProps, options); // If they are specifying a virtual positioning reference, we need to polyfill
    // some native DOM props
  
  
    if (isBareVirtualElement(targets)) {
      polyfillElementPrototypeProperties(targets);
    }
  
    var instances = getArrayOfElements(targets).reduce(function (acc, reference) {
      var instance = reference && createTippy(reference, props);
  
      if (instance) {
        acc.push(instance);
      }
  
      return acc;
    }, []);
    return isSingular(targets) ? instances[0] : instances;
  }
  /**
   * Static props
   */
  
  
  tippy.version = version;
  tippy.defaults = defaultProps;
  /**
   * Static methods
   */
  
  tippy.setDefaults = function (partialDefaults) {
    Object.keys(partialDefaults).forEach(function (key) {
      // @ts-ignore
      defaultProps[key] = partialDefaults[key];
    });
  };
  
  tippy.hideAll = hideAll;
  tippy.group = group;
  /**
   * Auto-init tooltips for elements with a `data-tippy="..."` attribute
   */
  
  function autoInit() {
    arrayFrom(document.querySelectorAll('[data-tippy]')).forEach(function (el) {
      var content = el.getAttribute('data-tippy');
  
      if (content) {
        tippy(el, {
          content: content
        });
      }
    });
  }
  
  if (isBrowser) {
    setTimeout(autoInit);
  }
  
  /* harmony default export */ __webpack_exports__["a"] = tippy;
  //# sourceMappingURL=index.js.map
  
  
  /***/ }),
  
  /***/ 17:
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  /* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__babel_loader_node_modules_vue_loader_lib_selector_type_script_index_0_UiFocusContainer_vue__ = __webpack_require__(19);
  /* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__node_modules_vue_loader_lib_template_compiler_index_id_data_v_6c26f987_hasScoped_false_node_modules_vue_loader_lib_selector_type_template_index_0_UiFocusContainer_vue__ = __webpack_require__(22);
  var disposed = false
  function injectStyle (ssrContext) {
    if (disposed) return
    __webpack_require__(23)
  }
  var normalizeComponent = __webpack_require__(1)
  /* script */
  
  /* template */
  
  /* styles */
  var __vue_styles__ = injectStyle
  /* scopeId */
  var __vue_scopeId__ = null
  /* moduleIdentifier (server only) */
  var __vue_module_identifier__ = null
  var Component = normalizeComponent(
    __WEBPACK_IMPORTED_MODULE_0__babel_loader_node_modules_vue_loader_lib_selector_type_script_index_0_UiFocusContainer_vue__["a" /* default */],
    __WEBPACK_IMPORTED_MODULE_1__node_modules_vue_loader_lib_template_compiler_index_id_data_v_6c26f987_hasScoped_false_node_modules_vue_loader_lib_selector_type_template_index_0_UiFocusContainer_vue__["a" /* default */],
    __vue_styles__,
    __vue_scopeId__,
    __vue_module_identifier__
  )
  Component.options.__file = "src\\UiFocusContainer.vue"
  if (Component.esModule && Object.keys(Component.esModule).some(function (key) {return key !== "default" && key.substr(0, 2) !== "__"})) {console.error("named exports are not supported in *.vue files.")}
  if (Component.options.functional) {console.error("[vue-loader] UiFocusContainer.vue: functional components are not supported with templates, they should use render functions.")}
  
  /* hot reload */
  if (false) {(function () {
    var hotAPI = require("vue-hot-reload-api")
    hotAPI.install(require("vue"), false)
    if (!hotAPI.compatible) return
    module.hot.accept()
    if (!module.hot.data) {
      hotAPI.createRecord("data-v-6c26f987", Component.options)
    } else {
      hotAPI.reload("data-v-6c26f987", Component.options)
    }
    module.hot.dispose(function (data) {
      disposed = true
    })
  })()}
  
  /* harmony default export */ __webpack_exports__["a"] = Component.exports;
  
  
  /***/ }),
  
  /***/ 175:
  /***/ (function(module, exports, __webpack_require__) {
  
  exports = module.exports = __webpack_require__(0)();
  // imports
  
  
  // module
  exports.push([module.i, "\n.ui-toolbar {\n  -webkit-box-align: center;\n      -ms-flex-align: center;\n          align-items: center;\n  display: -webkit-box;\n  display: -ms-flexbox;\n  display: flex;\n  font-family: inherit;\n  font-size: 1.125rem;\n  height: 3.5rem;\n  padding-left: 1rem;\n  position: relative;\n}\n.ui-toolbar.is-raised {\n    box-shadow: 0 0 2px rgba(0, 0, 0, 0.12), 0 2px 2px rgba(0, 0, 0, 0.2);\n}\n.ui-toolbar:not(.is-raised).ui-toolbar--type-default {\n    border-bottom: 0.0625rem solid rgba(0, 0, 0, 0.12);\n}\n.ui-toolbar .ui-icon-button {\n    height: 3rem;\n    width: 3rem;\n}\n.ui-toolbar__left {\n  -webkit-box-align: center;\n      -ms-flex-align: center;\n          align-items: center;\n  display: -webkit-box;\n  display: -ms-flexbox;\n  display: flex;\n  -ms-flex-negative: 0;\n      flex-shrink: 0;\n}\n.ui-toolbar__nav-icon {\n  margin-left: -1rem;\n  margin-right: 0.5rem;\n}\n.ui-toolbar__brand {\n  min-width: 10rem;\n}\n.ui-toolbar__brand-text {\n  -webkit-box-flex: 1;\n      -ms-flex-positive: 1;\n          flex-grow: 1;\n  padding-right: 0.5rem;\n}\n.ui-toolbar__body {\n  display: -webkit-box;\n  display: -ms-flexbox;\n  display: flex;\n  -webkit-box-flex: 1;\n      -ms-flex-positive: 1;\n          flex-grow: 1;\n}\n.ui-toolbar__body.has-brand-divider {\n    border-left-style: solid;\n    border-left-width: 0.0625rem;\n    padding-left: 1.5rem;\n}\n.ui-toolbar__right {\n  -ms-flex-negative: 0;\n      flex-shrink: 0;\n  margin-left: auto;\n}\n.ui-toolbar__progress {\n  bottom: 0;\n  height: 0.1875rem;\n  left: 0;\n  position: absolute;\n  right: 0;\n}\n.ui-toolbar--type-default {\n  background-color: white;\n}\n.ui-toolbar--type-colored {\n  background-color: #2196f3;\n}\n.ui-toolbar--type-clear {\n  background-color: transparent;\n  border: none;\n  box-shadow: none;\n}\n.ui-toolbar--text-color-black {\n  color: rgba(0, 0, 0, 0.87);\n}\n.ui-toolbar--text-color-black .ui-toolbar__body {\n    border-left-color: rgba(0, 0, 0, 0.15);\n}\n.ui-toolbar--text-color-white {\n  color: white;\n}\n.ui-toolbar--text-color-white .ui-toolbar__body {\n    border-color: rgba(255, 255, 255, 0.4);\n}\n.ui-toolbar--progress-position-top .ui-toolbar__progress {\n  top: 0;\n}\n", ""]);
  
  // exports
  
  
  /***/ }),
  
  /***/ 18:
  /***/ (function(module, exports) {
  
  var g;
  
  // This works in non-strict mode
  g = (function() {
  	return this;
  })();
  
  try {
  	// This works if eval is allowed (see CSP)
  	g = g || Function("return this")() || (1,eval)("this");
  } catch(e) {
  	// This works if the window reference is available
  	if(typeof window === "object")
  		g = window;
  }
  
  // g can still be undefined, but nothing to do about it...
  // We return undefined, instead of nothing here, so it's
  // easier to handle this case. if(!global) { ...}
  
  module.exports = g;
  
  
  /***/ }),
  
  /***/ 19:
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  
  
  /* harmony default export */ __webpack_exports__["a"] = {
      name: 'ui-focus-container',
  
      props: {
          containFocus: {
              type: Boolean,
              default: true
          },
          focusRedirector: Function,
          disabled: {
              type: Boolean,
              default: false
          },
          tag: {
              type: String,
              default: 'div'
          },
          lazy: {
              type: Boolean,
              defualt: false }
      },
  
      computed: {
          renderRedirector: function renderRedirector() {
              if (this.disabled) {
                  return false;
              }
  
              return this.lazy ? this.containFocus : true;
          }
      },
  
      methods: {
          focus: function focus() {
              this.$refs.content.focus();
          },
          redirectFocus: function redirectFocus(e, options) {
              if (!this.containFocus) {
                  this.$emit('focus-overflow', e, options);
                  return;
              }
  
              e.stopPropagation();
  
              if (this.focusRedirector) {
                  this.focusRedirector(e, options);
                  return;
              }
  
              if (options.isTabbingForward) {
                  this.$refs.content.focus();
              } else {
                  this.$refs.lastFocusable.focus();
              }
          }
      }
  };
  
  /***/ }),
  
  /***/ 2:
  /***/ (function(module, exports, __webpack_require__) {
  
  /*
    MIT License http://www.opensource.org/licenses/mit-license.php
    Author Tobias Koppers @sokra
    Modified by Evan You @yyx990803
  */
  
  var hasDocument = typeof document !== 'undefined'
  
  if (typeof DEBUG !== 'undefined' && DEBUG) {
    if (!hasDocument) {
      throw new Error(
      'vue-style-loader cannot be used in a non-browser environment. ' +
      "Use { target: 'node' } in your Webpack config to indicate a server-rendering environment."
    ) }
  }
  
  var listToStyles = __webpack_require__(3)
  
  /*
  type StyleObject = {
    id: number;
    parts: Array<StyleObjectPart>
  }
  
  type StyleObjectPart = {
    css: string;
    media: string;
    sourceMap: ?string
  }
  */
  
  var stylesInDom = {/*
    [id: number]: {
      id: number,
      refs: number,
      parts: Array<(obj?: StyleObjectPart) => void>
    }
  */}
  
  var head = hasDocument && (document.head || document.getElementsByTagName('head')[0])
  var singletonElement = null
  var singletonCounter = 0
  var isProduction = false
  var noop = function () {}
  
  // Force single-tag solution on IE6-9, which has a hard limit on the # of <style>
  // tags it will allow on a page
  var isOldIE = typeof navigator !== 'undefined' && /msie [6-9]\b/.test(navigator.userAgent.toLowerCase())
  
  module.exports = function (parentId, list, _isProduction) {
    isProduction = _isProduction
  
    var styles = listToStyles(parentId, list)
    addStylesToDom(styles)
  
    return function update (newList) {
      var mayRemove = []
      for (var i = 0; i < styles.length; i++) {
        var item = styles[i]
        var domStyle = stylesInDom[item.id]
        domStyle.refs--
        mayRemove.push(domStyle)
      }
      if (newList) {
        styles = listToStyles(parentId, newList)
        addStylesToDom(styles)
      } else {
        styles = []
      }
      for (var i = 0; i < mayRemove.length; i++) {
        var domStyle = mayRemove[i]
        if (domStyle.refs === 0) {
          for (var j = 0; j < domStyle.parts.length; j++) {
            domStyle.parts[j]()
          }
          delete stylesInDom[domStyle.id]
        }
      }
    }
  }
  
  function addStylesToDom (styles /* Array<StyleObject> */) {
    for (var i = 0; i < styles.length; i++) {
      var item = styles[i]
      var domStyle = stylesInDom[item.id]
      if (domStyle) {
        domStyle.refs++
        for (var j = 0; j < domStyle.parts.length; j++) {
          domStyle.parts[j](item.parts[j])
        }
        for (; j < item.parts.length; j++) {
          domStyle.parts.push(addStyle(item.parts[j]))
        }
        if (domStyle.parts.length > item.parts.length) {
          domStyle.parts.length = item.parts.length
        }
      } else {
        var parts = []
        for (var j = 0; j < item.parts.length; j++) {
          parts.push(addStyle(item.parts[j]))
        }
        stylesInDom[item.id] = { id: item.id, refs: 1, parts: parts }
      }
    }
  }
  
  function createStyleElement () {
    var styleElement = document.createElement('style')
    styleElement.type = 'text/css'
    head.appendChild(styleElement)
    return styleElement
  }
  
  function addStyle (obj /* StyleObjectPart */) {
    var update, remove
    var styleElement = document.querySelector('style[data-vue-ssr-id~="' + obj.id + '"]')
  
    if (styleElement) {
      if (isProduction) {
        // has SSR styles and in production mode.
        // simply do nothing.
        return noop
      } else {
        // has SSR styles but in dev mode.
        // for some reason Chrome can't handle source map in server-rendered
        // style tags - source maps in <style> only works if the style tag is
        // created and inserted dynamically. So we remove the server rendered
        // styles and inject new ones.
        styleElement.parentNode.removeChild(styleElement)
      }
    }
  
    if (isOldIE) {
      // use singleton mode for IE9.
      var styleIndex = singletonCounter++
      styleElement = singletonElement || (singletonElement = createStyleElement())
      update = applyToSingletonTag.bind(null, styleElement, styleIndex, false)
      remove = applyToSingletonTag.bind(null, styleElement, styleIndex, true)
    } else {
      // use multi-style-tag mode in all other cases
      styleElement = createStyleElement()
      update = applyToTag.bind(null, styleElement)
      remove = function () {
        styleElement.parentNode.removeChild(styleElement)
      }
    }
  
    update(obj)
  
    return function updateStyle (newObj /* StyleObjectPart */) {
      if (newObj) {
        if (newObj.css === obj.css &&
            newObj.media === obj.media &&
            newObj.sourceMap === obj.sourceMap) {
          return
        }
        update(obj = newObj)
      } else {
        remove()
      }
    }
  }
  
  var replaceText = (function () {
    var textStore = []
  
    return function (index, replacement) {
      textStore[index] = replacement
      return textStore.filter(Boolean).join('\n')
    }
  })()
  
  function applyToSingletonTag (styleElement, index, remove, obj) {
    var css = remove ? '' : obj.css
  
    if (styleElement.styleSheet) {
      styleElement.styleSheet.cssText = replaceText(index, css)
    } else {
      var cssNode = document.createTextNode(css)
      var childNodes = styleElement.childNodes
      if (childNodes[index]) styleElement.removeChild(childNodes[index])
      if (childNodes.length) {
        styleElement.insertBefore(cssNode, childNodes[index])
      } else {
        styleElement.appendChild(cssNode)
      }
    }
  }
  
  function applyToTag (styleElement, obj) {
    var css = obj.css
    var media = obj.media
    var sourceMap = obj.sourceMap
  
    if (media) {
      styleElement.setAttribute('media', media)
    }
  
    if (sourceMap) {
      // https://developer.chrome.com/devtools/docs/javascript-debugging
      // this makes source maps inside style tags work properly in Chrome
      css += '\n/*# sourceURL=' + sourceMap.sources[0] + ' */'
      // http://stackoverflow.com/a/26603875
      css += '\n/*# sourceMappingURL=data:application/json;base64,' + btoa(unescape(encodeURIComponent(JSON.stringify(sourceMap)))) + ' */'
    }
  
    if (styleElement.styleSheet) {
      styleElement.styleSheet.cssText = css
    } else {
      while (styleElement.firstChild) {
        styleElement.removeChild(styleElement.firstChild)
      }
      styleElement.appendChild(document.createTextNode(css))
    }
  }
  
  
  /***/ }),
  
  /***/ 20:
  /***/ (function(module, exports, __webpack_require__) {
  
  exports = module.exports = __webpack_require__(0)();
  // imports
  
  
  // module
  exports.push([module.i, "\n.ui-focus-container__focus-redirector,\n.ui-focus-container__last-focusable {\n  opacity: 0;\n  position: absolute;\n}\n.ui-focus-container__content {\n  outline: none;\n}\n", ""]);
  
  // exports
  
  
  /***/ }),
  
  /***/ 204:
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  var render = function () {var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;
    return _c('div', {
      staticClass: "ui-toolbar",
      class: _vm.classes
    }, [_c('div', {
      staticClass: "ui-toolbar__left"
    }, [(!_vm.removeNavIcon) ? _c('div', {
      staticClass: "ui-toolbar__nav-icon"
    }, [_vm._t("icon", [_c('ui-icon-button', {
      attrs: {
        "size": "large",
        "type": "secondary",
        "color": _vm.textColor,
        "icon": _vm.navIcon
      },
      on: {
        "click": _vm.navIconClick
      }
    })])], 2) : _vm._e(), _vm._v(" "), (_vm.brand || _vm.$slots.brand) ? _c('div', {
      staticClass: "ui-toolbar__brand"
    }, [_vm._t("brand", [_c('div', {
      staticClass: "ui-toolbar__brand-text"
    }, [_vm._v(_vm._s(_vm.brand))])])], 2) : _vm._e()]), _vm._v(" "), _c('div', {
      staticClass: "ui-toolbar__body",
      class: {
        'has-brand-divider': _vm.hasBrandDivider
      }
    }, [_vm._t("default", [(_vm.title) ? _c('div', {
      staticClass: "ui-toolbar__title"
    }, [_vm._v(_vm._s(_vm.title))]) : _vm._e()])], 2), _vm._v(" "), _c('div', {
      staticClass: "ui-toolbar__right"
    }, [_vm._t("actions")], 2), _vm._v(" "), _c('ui-progress-linear', {
      directives: [{
        name: "show",
        rawName: "v-show",
        value: (_vm.loading),
        expression: "loading"
      }],
      staticClass: "ui-toolbar__progress",
      attrs: {
        "color": _vm.progressColor
      }
    })], 1)
  }
  var staticRenderFns = []
  render._withStripped = true
  var esExports = { render: render, staticRenderFns: staticRenderFns }
  /* harmony default export */ __webpack_exports__["a"] = esExports;
  if (false) {
    module.hot.accept()
    if (module.hot.data) {
       require("vue-hot-reload-api").rerender("data-v-b19a1326", esExports)
    }
  }
  
  /***/ }),
  
  /***/ 21:
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  /* WEBPACK VAR INJECTION */(function(global) {/**!
   * @fileOverview Kickass library to create and place poppers near their reference elements.
   * @version 1.14.7
   * @license
   * Copyright (c) 2016 Federico Zivolo and contributors
   *
   * Permission is hereby granted, free of charge, to any person obtaining a copy
   * of this software and associated documentation files (the "Software"), to deal
   * in the Software without restriction, including without limitation the rights
   * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
   * copies of the Software, and to permit persons to whom the Software is
   * furnished to do so, subject to the following conditions:
   *
   * The above copyright notice and this permission notice shall be included in all
   * copies or substantial portions of the Software.
   *
   * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
   * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
   * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
   * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
   * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
   * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
   * SOFTWARE.
   */
  var isBrowser = typeof window !== 'undefined' && typeof document !== 'undefined';
  
  var longerTimeoutBrowsers = ['Edge', 'Trident', 'Firefox'];
  var timeoutDuration = 0;
  for (var i = 0; i < longerTimeoutBrowsers.length; i += 1) {
    if (isBrowser && navigator.userAgent.indexOf(longerTimeoutBrowsers[i]) >= 0) {
      timeoutDuration = 1;
      break;
    }
  }
  
  function microtaskDebounce(fn) {
    var called = false;
    return function () {
      if (called) {
        return;
      }
      called = true;
      window.Promise.resolve().then(function () {
        called = false;
        fn();
      });
    };
  }
  
  function taskDebounce(fn) {
    var scheduled = false;
    return function () {
      if (!scheduled) {
        scheduled = true;
        setTimeout(function () {
          scheduled = false;
          fn();
        }, timeoutDuration);
      }
    };
  }
  
  var supportsMicroTasks = isBrowser && window.Promise;
  
  /**
  * Create a debounced version of a method, that's asynchronously deferred
  * but called in the minimum time possible.
  *
  * @method
  * @memberof Popper.Utils
  * @argument {Function} fn
  * @returns {Function}
  */
  var debounce = supportsMicroTasks ? microtaskDebounce : taskDebounce;
  
  /**
   * Check if the given variable is a function
   * @method
   * @memberof Popper.Utils
   * @argument {Any} functionToCheck - variable to check
   * @returns {Boolean} answer to: is a function?
   */
  function isFunction(functionToCheck) {
    var getType = {};
    return functionToCheck && getType.toString.call(functionToCheck) === '[object Function]';
  }
  
  /**
   * Get CSS computed property of the given element
   * @method
   * @memberof Popper.Utils
   * @argument {Eement} element
   * @argument {String} property
   */
  function getStyleComputedProperty(element, property) {
    if (element.nodeType !== 1) {
      return [];
    }
    // NOTE: 1 DOM access here
    var window = element.ownerDocument.defaultView;
    var css = window.getComputedStyle(element, null);
    return property ? css[property] : css;
  }
  
  /**
   * Returns the parentNode or the host of the element
   * @method
   * @memberof Popper.Utils
   * @argument {Element} element
   * @returns {Element} parent
   */
  function getParentNode(element) {
    if (element.nodeName === 'HTML') {
      return element;
    }
    return element.parentNode || element.host;
  }
  
  /**
   * Returns the scrolling parent of the given element
   * @method
   * @memberof Popper.Utils
   * @argument {Element} element
   * @returns {Element} scroll parent
   */
  function getScrollParent(element) {
    // Return body, `getScroll` will take care to get the correct `scrollTop` from it
    if (!element) {
      return document.body;
    }
  
    switch (element.nodeName) {
      case 'HTML':
      case 'BODY':
        return element.ownerDocument.body;
      case '#document':
        return element.body;
    }
  
    // Firefox want us to check `-x` and `-y` variations as well
  
    var _getStyleComputedProp = getStyleComputedProperty(element),
        overflow = _getStyleComputedProp.overflow,
        overflowX = _getStyleComputedProp.overflowX,
        overflowY = _getStyleComputedProp.overflowY;
  
    if (/(auto|scroll|overlay)/.test(overflow + overflowY + overflowX)) {
      return element;
    }
  
    return getScrollParent(getParentNode(element));
  }
  
  var isIE11 = isBrowser && !!(window.MSInputMethodContext && document.documentMode);
  var isIE10 = isBrowser && /MSIE 10/.test(navigator.userAgent);
  
  /**
   * Determines if the browser is Internet Explorer
   * @method
   * @memberof Popper.Utils
   * @param {Number} version to check
   * @returns {Boolean} isIE
   */
  function isIE(version) {
    if (version === 11) {
      return isIE11;
    }
    if (version === 10) {
      return isIE10;
    }
    return isIE11 || isIE10;
  }
  
  /**
   * Returns the offset parent of the given element
   * @method
   * @memberof Popper.Utils
   * @argument {Element} element
   * @returns {Element} offset parent
   */
  function getOffsetParent(element) {
    if (!element) {
      return document.documentElement;
    }
  
    var noOffsetParent = isIE(10) ? document.body : null;
  
    // NOTE: 1 DOM access here
    var offsetParent = element.offsetParent || null;
    // Skip hidden elements which don't have an offsetParent
    while (offsetParent === noOffsetParent && element.nextElementSibling) {
      offsetParent = (element = element.nextElementSibling).offsetParent;
    }
  
    var nodeName = offsetParent && offsetParent.nodeName;
  
    if (!nodeName || nodeName === 'BODY' || nodeName === 'HTML') {
      return element ? element.ownerDocument.documentElement : document.documentElement;
    }
  
    // .offsetParent will return the closest TH, TD or TABLE in case
    // no offsetParent is present, I hate this job...
    if (['TH', 'TD', 'TABLE'].indexOf(offsetParent.nodeName) !== -1 && getStyleComputedProperty(offsetParent, 'position') === 'static') {
      return getOffsetParent(offsetParent);
    }
  
    return offsetParent;
  }
  
  function isOffsetContainer(element) {
    var nodeName = element.nodeName;
  
    if (nodeName === 'BODY') {
      return false;
    }
    return nodeName === 'HTML' || getOffsetParent(element.firstElementChild) === element;
  }
  
  /**
   * Finds the root node (document, shadowDOM root) of the given element
   * @method
   * @memberof Popper.Utils
   * @argument {Element} node
   * @returns {Element} root node
   */
  function getRoot(node) {
    if (node.parentNode !== null) {
      return getRoot(node.parentNode);
    }
  
    return node;
  }
  
  /**
   * Finds the offset parent common to the two provided nodes
   * @method
   * @memberof Popper.Utils
   * @argument {Element} element1
   * @argument {Element} element2
   * @returns {Element} common offset parent
   */
  function findCommonOffsetParent(element1, element2) {
    // This check is needed to avoid errors in case one of the elements isn't defined for any reason
    if (!element1 || !element1.nodeType || !element2 || !element2.nodeType) {
      return document.documentElement;
    }
  
    // Here we make sure to give as "start" the element that comes first in the DOM
    var order = element1.compareDocumentPosition(element2) & Node.DOCUMENT_POSITION_FOLLOWING;
    var start = order ? element1 : element2;
    var end = order ? element2 : element1;
  
    // Get common ancestor container
    var range = document.createRange();
    range.setStart(start, 0);
    range.setEnd(end, 0);
    var commonAncestorContainer = range.commonAncestorContainer;
  
    // Both nodes are inside #document
  
    if (element1 !== commonAncestorContainer && element2 !== commonAncestorContainer || start.contains(end)) {
      if (isOffsetContainer(commonAncestorContainer)) {
        return commonAncestorContainer;
      }
  
      return getOffsetParent(commonAncestorContainer);
    }
  
    // one of the nodes is inside shadowDOM, find which one
    var element1root = getRoot(element1);
    if (element1root.host) {
      return findCommonOffsetParent(element1root.host, element2);
    } else {
      return findCommonOffsetParent(element1, getRoot(element2).host);
    }
  }
  
  /**
   * Gets the scroll value of the given element in the given side (top and left)
   * @method
   * @memberof Popper.Utils
   * @argument {Element} element
   * @argument {String} side `top` or `left`
   * @returns {number} amount of scrolled pixels
   */
  function getScroll(element) {
    var side = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'top';
  
    var upperSide = side === 'top' ? 'scrollTop' : 'scrollLeft';
    var nodeName = element.nodeName;
  
    if (nodeName === 'BODY' || nodeName === 'HTML') {
      var html = element.ownerDocument.documentElement;
      var scrollingElement = element.ownerDocument.scrollingElement || html;
      return scrollingElement[upperSide];
    }
  
    return element[upperSide];
  }
  
  /*
   * Sum or subtract the element scroll values (left and top) from a given rect object
   * @method
   * @memberof Popper.Utils
   * @param {Object} rect - Rect object you want to change
   * @param {HTMLElement} element - The element from the function reads the scroll values
   * @param {Boolean} subtract - set to true if you want to subtract the scroll values
   * @return {Object} rect - The modifier rect object
   */
  function includeScroll(rect, element) {
    var subtract = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
  
    var scrollTop = getScroll(element, 'top');
    var scrollLeft = getScroll(element, 'left');
    var modifier = subtract ? -1 : 1;
    rect.top += scrollTop * modifier;
    rect.bottom += scrollTop * modifier;
    rect.left += scrollLeft * modifier;
    rect.right += scrollLeft * modifier;
    return rect;
  }
  
  /*
   * Helper to detect borders of a given element
   * @method
   * @memberof Popper.Utils
   * @param {CSSStyleDeclaration} styles
   * Result of `getStyleComputedProperty` on the given element
   * @param {String} axis - `x` or `y`
   * @return {number} borders - The borders size of the given axis
   */
  
  function getBordersSize(styles, axis) {
    var sideA = axis === 'x' ? 'Left' : 'Top';
    var sideB = sideA === 'Left' ? 'Right' : 'Bottom';
  
    return parseFloat(styles['border' + sideA + 'Width'], 10) + parseFloat(styles['border' + sideB + 'Width'], 10);
  }
  
  function getSize(axis, body, html, computedStyle) {
    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);
  }
  
  function getWindowSizes(document) {
    var body = document.body;
    var html = document.documentElement;
    var computedStyle = isIE(10) && getComputedStyle(html);
  
    return {
      height: getSize('Height', body, html, computedStyle),
      width: getSize('Width', body, html, computedStyle)
    };
  }
  
  var classCallCheck = function (instance, Constructor) {
    if (!(instance instanceof Constructor)) {
      throw new TypeError("Cannot call a class as a function");
    }
  };
  
  var createClass = function () {
    function defineProperties(target, props) {
      for (var i = 0; i < props.length; i++) {
        var descriptor = props[i];
        descriptor.enumerable = descriptor.enumerable || false;
        descriptor.configurable = true;
        if ("value" in descriptor) descriptor.writable = true;
        Object.defineProperty(target, descriptor.key, descriptor);
      }
    }
  
    return function (Constructor, protoProps, staticProps) {
      if (protoProps) defineProperties(Constructor.prototype, protoProps);
      if (staticProps) defineProperties(Constructor, staticProps);
      return Constructor;
    };
  }();
  
  
  
  
  
  var defineProperty = function (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;
  };
  
  var _extends = Object.assign || function (target) {
    for (var i = 1; i < arguments.length; i++) {
      var source = arguments[i];
  
      for (var key in source) {
        if (Object.prototype.hasOwnProperty.call(source, key)) {
          target[key] = source[key];
        }
      }
    }
  
    return target;
  };
  
  /**
   * Given element offsets, generate an output similar to getBoundingClientRect
   * @method
   * @memberof Popper.Utils
   * @argument {Object} offsets
   * @returns {Object} ClientRect like output
   */
  function getClientRect(offsets) {
    return _extends({}, offsets, {
      right: offsets.left + offsets.width,
      bottom: offsets.top + offsets.height
    });
  }
  
  /**
   * Get bounding client rect of given element
   * @method
   * @memberof Popper.Utils
   * @param {HTMLElement} element
   * @return {Object} client rect
   */
  function getBoundingClientRect(element) {
    var rect = {};
  
    // IE10 10 FIX: Please, don't ask, the element isn't
    // considered in DOM in some circumstances...
    // This isn't reproducible in IE10 compatibility mode of IE11
    try {
      if (isIE(10)) {
        rect = element.getBoundingClientRect();
        var scrollTop = getScroll(element, 'top');
        var scrollLeft = getScroll(element, 'left');
        rect.top += scrollTop;
        rect.left += scrollLeft;
        rect.bottom += scrollTop;
        rect.right += scrollLeft;
      } else {
        rect = element.getBoundingClientRect();
      }
    } catch (e) {}
  
    var result = {
      left: rect.left,
      top: rect.top,
      width: rect.right - rect.left,
      height: rect.bottom - rect.top
    };
  
    // subtract scrollbar size from sizes
    var sizes = element.nodeName === 'HTML' ? getWindowSizes(element.ownerDocument) : {};
    var width = sizes.width || element.clientWidth || result.right - result.left;
    var height = sizes.height || element.clientHeight || result.bottom - result.top;
  
    var horizScrollbar = element.offsetWidth - width;
    var vertScrollbar = element.offsetHeight - height;
  
    // if an hypothetical scrollbar is detected, we must be sure it's not a `border`
    // we make this check conditional for performance reasons
    if (horizScrollbar || vertScrollbar) {
      var styles = getStyleComputedProperty(element);
      horizScrollbar -= getBordersSize(styles, 'x');
      vertScrollbar -= getBordersSize(styles, 'y');
  
      result.width -= horizScrollbar;
      result.height -= vertScrollbar;
    }
  
    return getClientRect(result);
  }
  
  function getOffsetRectRelativeToArbitraryNode(children, parent) {
    var fixedPosition = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
  
    var isIE10 = isIE(10);
    var isHTML = parent.nodeName === 'HTML';
    var childrenRect = getBoundingClientRect(children);
    var parentRect = getBoundingClientRect(parent);
    var scrollParent = getScrollParent(children);
  
    var styles = getStyleComputedProperty(parent);
    var borderTopWidth = parseFloat(styles.borderTopWidth, 10);
    var borderLeftWidth = parseFloat(styles.borderLeftWidth, 10);
  
    // In cases where the parent is fixed, we must ignore negative scroll in offset calc
    if (fixedPosition && isHTML) {
      parentRect.top = Math.max(parentRect.top, 0);
      parentRect.left = Math.max(parentRect.left, 0);
    }
    var offsets = getClientRect({
      top: childrenRect.top - parentRect.top - borderTopWidth,
      left: childrenRect.left - parentRect.left - borderLeftWidth,
      width: childrenRect.width,
      height: childrenRect.height
    });
    offsets.marginTop = 0;
    offsets.marginLeft = 0;
  
    // Subtract margins of documentElement in case it's being used as parent
    // we do this only on HTML because it's the only element that behaves
    // differently when margins are applied to it. The margins are included in
    // the box of the documentElement, in the other cases not.
    if (!isIE10 && isHTML) {
      var marginTop = parseFloat(styles.marginTop, 10);
      var marginLeft = parseFloat(styles.marginLeft, 10);
  
      offsets.top -= borderTopWidth - marginTop;
      offsets.bottom -= borderTopWidth - marginTop;
      offsets.left -= borderLeftWidth - marginLeft;
      offsets.right -= borderLeftWidth - marginLeft;
  
      // Attach marginTop and marginLeft because in some circumstances we may need them
      offsets.marginTop = marginTop;
      offsets.marginLeft = marginLeft;
    }
  
    if (isIE10 && !fixedPosition ? parent.contains(scrollParent) : parent === scrollParent && scrollParent.nodeName !== 'BODY') {
      offsets = includeScroll(offsets, parent);
    }
  
    return offsets;
  }
  
  function getViewportOffsetRectRelativeToArtbitraryNode(element) {
    var excludeScroll = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
  
    var html = element.ownerDocument.documentElement;
    var relativeOffset = getOffsetRectRelativeToArbitraryNode(element, html);
    var width = Math.max(html.clientWidth, window.innerWidth || 0);
    var height = Math.max(html.clientHeight, window.innerHeight || 0);
  
    var scrollTop = !excludeScroll ? getScroll(html) : 0;
    var scrollLeft = !excludeScroll ? getScroll(html, 'left') : 0;
  
    var offset = {
      top: scrollTop - relativeOffset.top + relativeOffset.marginTop,
      left: scrollLeft - relativeOffset.left + relativeOffset.marginLeft,
      width: width,
      height: height
    };
  
    return getClientRect(offset);
  }
  
  /**
   * Check if the given element is fixed or is inside a fixed parent
   * @method
   * @memberof Popper.Utils
   * @argument {Element} element
   * @argument {Element} customContainer
   * @returns {Boolean} answer to "isFixed?"
   */
  function isFixed(element) {
    var nodeName = element.nodeName;
    if (nodeName === 'BODY' || nodeName === 'HTML') {
      return false;
    }
    if (getStyleComputedProperty(element, 'position') === 'fixed') {
      return true;
    }
    var parentNode = getParentNode(element);
    if (!parentNode) {
      return false;
    }
    return isFixed(parentNode);
  }
  
  /**
   * Finds the first parent of an element that has a transformed property defined
   * @method
   * @memberof Popper.Utils
   * @argument {Element} element
   * @returns {Element} first transformed parent or documentElement
   */
  
  function getFixedPositionOffsetParent(element) {
    // This check is needed to avoid errors in case one of the elements isn't defined for any reason
    if (!element || !element.parentElement || isIE()) {
      return document.documentElement;
    }
    var el = element.parentElement;
    while (el && getStyleComputedProperty(el, 'transform') === 'none') {
      el = el.parentElement;
    }
    return el || document.documentElement;
  }
  
  /**
   * Computed the boundaries limits and return them
   * @method
   * @memberof Popper.Utils
   * @param {HTMLElement} popper
   * @param {HTMLElement} reference
   * @param {number} padding
   * @param {HTMLElement} boundariesElement - Element used to define the boundaries
   * @param {Boolean} fixedPosition - Is in fixed position mode
   * @returns {Object} Coordinates of the boundaries
   */
  function getBoundaries(popper, reference, padding, boundariesElement) {
    var fixedPosition = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;
  
    // NOTE: 1 DOM access here
  
    var boundaries = { top: 0, left: 0 };
    var offsetParent = fixedPosition ? getFixedPositionOffsetParent(popper) : findCommonOffsetParent(popper, reference);
  
    // Handle viewport case
    if (boundariesElement === 'viewport') {
      boundaries = getViewportOffsetRectRelativeToArtbitraryNode(offsetParent, fixedPosition);
    } else {
      // Handle other cases based on DOM element used as boundaries
      var boundariesNode = void 0;
      if (boundariesElement === 'scrollParent') {
        boundariesNode = getScrollParent(getParentNode(reference));
        if (boundariesNode.nodeName === 'BODY') {
          boundariesNode = popper.ownerDocument.documentElement;
        }
      } else if (boundariesElement === 'window') {
        boundariesNode = popper.ownerDocument.documentElement;
      } else {
        boundariesNode = boundariesElement;
      }
  
      var offsets = getOffsetRectRelativeToArbitraryNode(boundariesNode, offsetParent, fixedPosition);
  
      // In case of HTML, we need a different computation
      if (boundariesNode.nodeName === 'HTML' && !isFixed(offsetParent)) {
        var _getWindowSizes = getWindowSizes(popper.ownerDocument),
            height = _getWindowSizes.height,
            width = _getWindowSizes.width;
  
        boundaries.top += offsets.top - offsets.marginTop;
        boundaries.bottom = height + offsets.top;
        boundaries.left += offsets.left - offsets.marginLeft;
        boundaries.right = width + offsets.left;
      } else {
        // for all the other DOM elements, this one is good
        boundaries = offsets;
      }
    }
  
    // Add paddings
    padding = padding || 0;
    var isPaddingNumber = typeof padding === 'number';
    boundaries.left += isPaddingNumber ? padding : padding.left || 0;
    boundaries.top += isPaddingNumber ? padding : padding.top || 0;
    boundaries.right -= isPaddingNumber ? padding : padding.right || 0;
    boundaries.bottom -= isPaddingNumber ? padding : padding.bottom || 0;
  
    return boundaries;
  }
  
  function getArea(_ref) {
    var width = _ref.width,
        height = _ref.height;
  
    return width * height;
  }
  
  /**
   * Utility used to transform the `auto` placement to the placement with more
   * available space.
   * @method
   * @memberof Popper.Utils
   * @argument {Object} data - The data object generated by update method
   * @argument {Object} options - Modifiers configuration and options
   * @returns {Object} The data object, properly modified
   */
  function computeAutoPlacement(placement, refRect, popper, reference, boundariesElement) {
    var padding = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : 0;
  
    if (placement.indexOf('auto') === -1) {
      return placement;
    }
  
    var boundaries = getBoundaries(popper, reference, padding, boundariesElement);
  
    var rects = {
      top: {
        width: boundaries.width,
        height: refRect.top - boundaries.top
      },
      right: {
        width: boundaries.right - refRect.right,
        height: boundaries.height
      },
      bottom: {
        width: boundaries.width,
        height: boundaries.bottom - refRect.bottom
      },
      left: {
        width: refRect.left - boundaries.left,
        height: boundaries.height
      }
    };
  
    var sortedAreas = Object.keys(rects).map(function (key) {
      return _extends({
        key: key
      }, rects[key], {
        area: getArea(rects[key])
      });
    }).sort(function (a, b) {
      return b.area - a.area;
    });
  
    var filteredAreas = sortedAreas.filter(function (_ref2) {
      var width = _ref2.width,
          height = _ref2.height;
      return width >= popper.clientWidth && height >= popper.clientHeight;
    });
  
    var computedPlacement = filteredAreas.length > 0 ? filteredAreas[0].key : sortedAreas[0].key;
  
    var variation = placement.split('-')[1];
  
    return computedPlacement + (variation ? '-' + variation : '');
  }
  
  /**
   * Get offsets to the reference element
   * @method
   * @memberof Popper.Utils
   * @param {Object} state
   * @param {Element} popper - the popper element
   * @param {Element} reference - the reference element (the popper will be relative to this)
   * @param {Element} fixedPosition - is in fixed position mode
   * @returns {Object} An object containing the offsets which will be applied to the popper
   */
  function getReferenceOffsets(state, popper, reference) {
    var fixedPosition = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;
  
    var commonOffsetParent = fixedPosition ? getFixedPositionOffsetParent(popper) : findCommonOffsetParent(popper, reference);
    return getOffsetRectRelativeToArbitraryNode(reference, commonOffsetParent, fixedPosition);
  }
  
  /**
   * Get the outer sizes of the given element (offset size + margins)
   * @method
   * @memberof Popper.Utils
   * @argument {Element} element
   * @returns {Object} object containing width and height properties
   */
  function getOuterSizes(element) {
    var window = element.ownerDocument.defaultView;
    var styles = window.getComputedStyle(element);
    var x = parseFloat(styles.marginTop || 0) + parseFloat(styles.marginBottom || 0);
    var y = parseFloat(styles.marginLeft || 0) + parseFloat(styles.marginRight || 0);
    var result = {
      width: element.offsetWidth + y,
      height: element.offsetHeight + x
    };
    return result;
  }
  
  /**
   * Get the opposite placement of the given one
   * @method
   * @memberof Popper.Utils
   * @argument {String} placement
   * @returns {String} flipped placement
   */
  function getOppositePlacement(placement) {
    var hash = { left: 'right', right: 'left', bottom: 'top', top: 'bottom' };
    return placement.replace(/left|right|bottom|top/g, function (matched) {
      return hash[matched];
    });
  }
  
  /**
   * Get offsets to the popper
   * @method
   * @memberof Popper.Utils
   * @param {Object} position - CSS position the Popper will get applied
   * @param {HTMLElement} popper - the popper element
   * @param {Object} referenceOffsets - the reference offsets (the popper will be relative to this)
   * @param {String} placement - one of the valid placement options
   * @returns {Object} popperOffsets - An object containing the offsets which will be applied to the popper
   */
  function getPopperOffsets(popper, referenceOffsets, placement) {
    placement = placement.split('-')[0];
  
    // Get popper node sizes
    var popperRect = getOuterSizes(popper);
  
    // Add position, width and height to our offsets object
    var popperOffsets = {
      width: popperRect.width,
      height: popperRect.height
    };
  
    // depending by the popper placement we have to compute its offsets slightly differently
    var isHoriz = ['right', 'left'].indexOf(placement) !== -1;
    var mainSide = isHoriz ? 'top' : 'left';
    var secondarySide = isHoriz ? 'left' : 'top';
    var measurement = isHoriz ? 'height' : 'width';
    var secondaryMeasurement = !isHoriz ? 'height' : 'width';
  
    popperOffsets[mainSide] = referenceOffsets[mainSide] + referenceOffsets[measurement] / 2 - popperRect[measurement] / 2;
    if (placement === secondarySide) {
      popperOffsets[secondarySide] = referenceOffsets[secondarySide] - popperRect[secondaryMeasurement];
    } else {
      popperOffsets[secondarySide] = referenceOffsets[getOppositePlacement(secondarySide)];
    }
  
    return popperOffsets;
  }
  
  /**
   * Mimics the `find` method of Array
   * @method
   * @memberof Popper.Utils
   * @argument {Array} arr
   * @argument prop
   * @argument value
   * @returns index or -1
   */
  function find(arr, check) {
    // use native find if supported
    if (Array.prototype.find) {
      return arr.find(check);
    }
  
    // use `filter` to obtain the same behavior of `find`
    return arr.filter(check)[0];
  }
  
  /**
   * Return the index of the matching object
   * @method
   * @memberof Popper.Utils
   * @argument {Array} arr
   * @argument prop
   * @argument value
   * @returns index or -1
   */
  function findIndex(arr, prop, value) {
    // use native findIndex if supported
    if (Array.prototype.findIndex) {
      return arr.findIndex(function (cur) {
        return cur[prop] === value;
      });
    }
  
    // use `find` + `indexOf` if `findIndex` isn't supported
    var match = find(arr, function (obj) {
      return obj[prop] === value;
    });
    return arr.indexOf(match);
  }
  
  /**
   * Loop trough the list of modifiers and run them in order,
   * each of them will then edit the data object.
   * @method
   * @memberof Popper.Utils
   * @param {dataObject} data
   * @param {Array} modifiers
   * @param {String} ends - Optional modifier name used as stopper
   * @returns {dataObject}
   */
  function runModifiers(modifiers, data, ends) {
    var modifiersToRun = ends === undefined ? modifiers : modifiers.slice(0, findIndex(modifiers, 'name', ends));
  
    modifiersToRun.forEach(function (modifier) {
      if (modifier['function']) {
        // eslint-disable-line dot-notation
        console.warn('`modifier.function` is deprecated, use `modifier.fn`!');
      }
      var fn = modifier['function'] || modifier.fn; // eslint-disable-line dot-notation
      if (modifier.enabled && isFunction(fn)) {
        // Add properties to offsets to make them a complete clientRect object
        // we do this before each modifier to make sure the previous one doesn't
        // mess with these values
        data.offsets.popper = getClientRect(data.offsets.popper);
        data.offsets.reference = getClientRect(data.offsets.reference);
  
        data = fn(data, modifier);
      }
    });
  
    return data;
  }
  
  /**
   * Updates the position of the popper, computing the new offsets and applying
   * the new style.<br />
   * Prefer `scheduleUpdate` over `update` because of performance reasons.
   * @method
   * @memberof Popper
   */
  function update() {
    // if popper is destroyed, don't perform any further update
    if (this.state.isDestroyed) {
      return;
    }
  
    var data = {
      instance: this,
      styles: {},
      arrowStyles: {},
      attributes: {},
      flipped: false,
      offsets: {}
    };
  
    // compute reference element offsets
    data.offsets.reference = getReferenceOffsets(this.state, this.popper, this.reference, this.options.positionFixed);
  
    // compute auto placement, store placement inside the data object,
    // modifiers will be able to edit `placement` if needed
    // and refer to originalPlacement to know the original value
    data.placement = computeAutoPlacement(this.options.placement, data.offsets.reference, this.popper, this.reference, this.options.modifiers.flip.boundariesElement, this.options.modifiers.flip.padding);
  
    // store the computed placement inside `originalPlacement`
    data.originalPlacement = data.placement;
  
    data.positionFixed = this.options.positionFixed;
  
    // compute the popper offsets
    data.offsets.popper = getPopperOffsets(this.popper, data.offsets.reference, data.placement);
  
    data.offsets.popper.position = this.options.positionFixed ? 'fixed' : 'absolute';
  
    // run the modifiers
    data = runModifiers(this.modifiers, data);
  
    // the first `update` will call `onCreate` callback
    // the other ones will call `onUpdate` callback
    if (!this.state.isCreated) {
      this.state.isCreated = true;
      this.options.onCreate(data);
    } else {
      this.options.onUpdate(data);
    }
  }
  
  /**
   * Helper used to know if the given modifier is enabled.
   * @method
   * @memberof Popper.Utils
   * @returns {Boolean}
   */
  function isModifierEnabled(modifiers, modifierName) {
    return modifiers.some(function (_ref) {
      var name = _ref.name,
          enabled = _ref.enabled;
      return enabled && name === modifierName;
    });
  }
  
  /**
   * Get the prefixed supported property name
   * @method
   * @memberof Popper.Utils
   * @argument {String} property (camelCase)
   * @returns {String} prefixed property (camelCase or PascalCase, depending on the vendor prefix)
   */
  function getSupportedPropertyName(property) {
    var prefixes = [false, 'ms', 'Webkit', 'Moz', 'O'];
    var upperProp = property.charAt(0).toUpperCase() + property.slice(1);
  
    for (var i = 0; i < prefixes.length; i++) {
      var prefix = prefixes[i];
      var toCheck = prefix ? '' + prefix + upperProp : property;
      if (typeof document.body.style[toCheck] !== 'undefined') {
        return toCheck;
      }
    }
    return null;
  }
  
  /**
   * Destroys the popper.
   * @method
   * @memberof Popper
   */
  function destroy() {
    this.state.isDestroyed = true;
  
    // touch DOM only if `applyStyle` modifier is enabled
    if (isModifierEnabled(this.modifiers, 'applyStyle')) {
      this.popper.removeAttribute('x-placement');
      this.popper.style.position = '';
      this.popper.style.top = '';
      this.popper.style.left = '';
      this.popper.style.right = '';
      this.popper.style.bottom = '';
      this.popper.style.willChange = '';
      this.popper.style[getSupportedPropertyName('transform')] = '';
    }
  
    this.disableEventListeners();
  
    // remove the popper if user explicity asked for the deletion on destroy
    // do not use `remove` because IE11 doesn't support it
    if (this.options.removeOnDestroy) {
      this.popper.parentNode.removeChild(this.popper);
    }
    return this;
  }
  
  /**
   * Get the window associated with the element
   * @argument {Element} element
   * @returns {Window}
   */
  function getWindow(element) {
    var ownerDocument = element.ownerDocument;
    return ownerDocument ? ownerDocument.defaultView : window;
  }
  
  function attachToScrollParents(scrollParent, event, callback, scrollParents) {
    var isBody = scrollParent.nodeName === 'BODY';
    var target = isBody ? scrollParent.ownerDocument.defaultView : scrollParent;
    target.addEventListener(event, callback, { passive: true });
  
    if (!isBody) {
      attachToScrollParents(getScrollParent(target.parentNode), event, callback, scrollParents);
    }
    scrollParents.push(target);
  }
  
  /**
   * Setup needed event listeners used to update the popper position
   * @method
   * @memberof Popper.Utils
   * @private
   */
  function setupEventListeners(reference, options, state, updateBound) {
    // Resize event listener on window
    state.updateBound = updateBound;
    getWindow(reference).addEventListener('resize', state.updateBound, { passive: true });
  
    // Scroll event listener on scroll parents
    var scrollElement = getScrollParent(reference);
    attachToScrollParents(scrollElement, 'scroll', state.updateBound, state.scrollParents);
    state.scrollElement = scrollElement;
    state.eventsEnabled = true;
  
    return state;
  }
  
  /**
   * It will add resize/scroll events and start recalculating
   * position of the popper element when they are triggered.
   * @method
   * @memberof Popper
   */
  function enableEventListeners() {
    if (!this.state.eventsEnabled) {
      this.state = setupEventListeners(this.reference, this.options, this.state, this.scheduleUpdate);
    }
  }
  
  /**
   * Remove event listeners used to update the popper position
   * @method
   * @memberof Popper.Utils
   * @private
   */
  function removeEventListeners(reference, state) {
    // Remove resize event listener on window
    getWindow(reference).removeEventListener('resize', state.updateBound);
  
    // Remove scroll event listener on scroll parents
    state.scrollParents.forEach(function (target) {
      target.removeEventListener('scroll', state.updateBound);
    });
  
    // Reset state
    state.updateBound = null;
    state.scrollParents = [];
    state.scrollElement = null;
    state.eventsEnabled = false;
    return state;
  }
  
  /**
   * It will remove resize/scroll events and won't recalculate popper position
   * when they are triggered. It also won't trigger `onUpdate` callback anymore,
   * unless you call `update` method manually.
   * @method
   * @memberof Popper
   */
  function disableEventListeners() {
    if (this.state.eventsEnabled) {
      cancelAnimationFrame(this.scheduleUpdate);
      this.state = removeEventListeners(this.reference, this.state);
    }
  }
  
  /**
   * Tells if a given input is a number
   * @method
   * @memberof Popper.Utils
   * @param {*} input to check
   * @return {Boolean}
   */
  function isNumeric(n) {
    return n !== '' && !isNaN(parseFloat(n)) && isFinite(n);
  }
  
  /**
   * Set the style to the given popper
   * @method
   * @memberof Popper.Utils
   * @argument {Element} element - Element to apply the style to
   * @argument {Object} styles
   * Object with a list of properties and values which will be applied to the element
   */
  function setStyles(element, styles) {
    Object.keys(styles).forEach(function (prop) {
      var unit = '';
      // add unit if the value is numeric and is one of the following
      if (['width', 'height', 'top', 'right', 'bottom', 'left'].indexOf(prop) !== -1 && isNumeric(styles[prop])) {
        unit = 'px';
      }
      element.style[prop] = styles[prop] + unit;
    });
  }
  
  /**
   * Set the attributes to the given popper
   * @method
   * @memberof Popper.Utils
   * @argument {Element} element - Element to apply the attributes to
   * @argument {Object} styles
   * Object with a list of properties and values which will be applied to the element
   */
  function setAttributes(element, attributes) {
    Object.keys(attributes).forEach(function (prop) {
      var value = attributes[prop];
      if (value !== false) {
        element.setAttribute(prop, attributes[prop]);
      } else {
        element.removeAttribute(prop);
      }
    });
  }
  
  /**
   * @function
   * @memberof Modifiers
   * @argument {Object} data - The data object generated by `update` method
   * @argument {Object} data.styles - List of style properties - values to apply to popper element
   * @argument {Object} data.attributes - List of attribute properties - values to apply to popper element
   * @argument {Object} options - Modifiers configuration and options
   * @returns {Object} The same data object
   */
  function applyStyle(data) {
    // any property present in `data.styles` will be applied to the popper,
    // in this way we can make the 3rd party modifiers add custom styles to it
    // Be aware, modifiers could override the properties defined in the previous
    // lines of this modifier!
    setStyles(data.instance.popper, data.styles);
  
    // any property present in `data.attributes` will be applied to the popper,
    // they will be set as HTML attributes of the element
    setAttributes(data.instance.popper, data.attributes);
  
    // if arrowElement is defined and arrowStyles has some properties
    if (data.arrowElement && Object.keys(data.arrowStyles).length) {
      setStyles(data.arrowElement, data.arrowStyles);
    }
  
    return data;
  }
  
  /**
   * Set the x-placement attribute before everything else because it could be used
   * to add margins to the popper margins needs to be calculated to get the
   * correct popper offsets.
   * @method
   * @memberof Popper.modifiers
   * @param {HTMLElement} reference - The reference element used to position the popper
   * @param {HTMLElement} popper - The HTML element used as popper
   * @param {Object} options - Popper.js options
   */
  function applyStyleOnLoad(reference, popper, options, modifierOptions, state) {
    // compute reference element offsets
    var referenceOffsets = getReferenceOffsets(state, popper, reference, options.positionFixed);
  
    // compute auto placement, store placement inside the data object,
    // modifiers will be able to edit `placement` if needed
    // and refer to originalPlacement to know the original value
    var placement = computeAutoPlacement(options.placement, referenceOffsets, popper, reference, options.modifiers.flip.boundariesElement, options.modifiers.flip.padding);
  
    popper.setAttribute('x-placement', placement);
  
    // Apply `position` to popper before anything else because
    // without the position applied we can't guarantee correct computations
    setStyles(popper, { position: options.positionFixed ? 'fixed' : 'absolute' });
  
    return options;
  }
  
  /**
   * @function
   * @memberof Popper.Utils
   * @argument {Object} data - The data object generated by `update` method
   * @argument {Boolean} shouldRound - If the offsets should be rounded at all
   * @returns {Object} The popper's position offsets rounded
   *
   * The tale of pixel-perfect positioning. It's still not 100% perfect, but as
   * good as it can be within reason.
   * Discussion here: https://github.com/FezVrasta/popper.js/pull/715
   *
   * Low DPI screens cause a popper to be blurry if not using full pixels (Safari
   * as well on High DPI screens).
   *
   * Firefox prefers no rounding for positioning and does not have blurriness on
   * high DPI screens.
   *
   * Only horizontal placement and left/right values need to be considered.
   */
  function getRoundedOffsets(data, shouldRound) {
    var _data$offsets = data.offsets,
        popper = _data$offsets.popper,
        reference = _data$offsets.reference;
    var round = Math.round,
        floor = Math.floor;
  
    var noRound = function noRound(v) {
      return v;
    };
  
    var referenceWidth = round(reference.width);
    var popperWidth = round(popper.width);
  
    var isVertical = ['left', 'right'].indexOf(data.placement) !== -1;
    var isVariation = data.placement.indexOf('-') !== -1;
    var sameWidthParity = referenceWidth % 2 === popperWidth % 2;
    var bothOddWidth = referenceWidth % 2 === 1 && popperWidth % 2 === 1;
  
    var horizontalToInteger = !shouldRound ? noRound : isVertical || isVariation || sameWidthParity ? round : floor;
    var verticalToInteger = !shouldRound ? noRound : round;
  
    return {
      left: horizontalToInteger(bothOddWidth && !isVariation && shouldRound ? popper.left - 1 : popper.left),
      top: verticalToInteger(popper.top),
      bottom: verticalToInteger(popper.bottom),
      right: horizontalToInteger(popper.right)
    };
  }
  
  var isFirefox = isBrowser && /Firefox/i.test(navigator.userAgent);
  
  /**
   * @function
   * @memberof Modifiers
   * @argument {Object} data - The data object generated by `update` method
   * @argument {Object} options - Modifiers configuration and options
   * @returns {Object} The data object, properly modified
   */
  function computeStyle(data, options) {
    var x = options.x,
        y = options.y;
    var popper = data.offsets.popper;
  
    // Remove this legacy support in Popper.js v2
  
    var legacyGpuAccelerationOption = find(data.instance.modifiers, function (modifier) {
      return modifier.name === 'applyStyle';
    }).gpuAcceleration;
    if (legacyGpuAccelerationOption !== undefined) {
      console.warn('WARNING: `gpuAcceleration` option moved to `computeStyle` modifier and will not be supported in future versions of Popper.js!');
    }
    var gpuAcceleration = legacyGpuAccelerationOption !== undefined ? legacyGpuAccelerationOption : options.gpuAcceleration;
  
    var offsetParent = getOffsetParent(data.instance.popper);
    var offsetParentRect = getBoundingClientRect(offsetParent);
  
    // Styles
    var styles = {
      position: popper.position
    };
  
    var offsets = getRoundedOffsets(data, window.devicePixelRatio < 2 || !isFirefox);
  
    var sideA = x === 'bottom' ? 'top' : 'bottom';
    var sideB = y === 'right' ? 'left' : 'right';
  
    // if gpuAcceleration is set to `true` and transform is supported,
    //  we use `translate3d` to apply the position to the popper we
    // automatically use the supported prefixed version if needed
    var prefixedProperty = getSupportedPropertyName('transform');
  
    // now, let's make a step back and look at this code closely (wtf?)
    // If the content of the popper grows once it's been positioned, it
    // may happen that the popper gets misplaced because of the new content
    // overflowing its reference element
    // To avoid this problem, we provide two options (x and y), which allow
    // the consumer to define the offset origin.
    // If we position a popper on top of a reference element, we can set
    // `x` to `top` to make the popper grow towards its top instead of
    // its bottom.
    var left = void 0,
        top = void 0;
    if (sideA === 'bottom') {
      // when offsetParent is <html> the positioning is relative to the bottom of the screen (excluding the scrollbar)
      // and not the bottom of the html element
      if (offsetParent.nodeName === 'HTML') {
        top = -offsetParent.clientHeight + offsets.bottom;
      } else {
        top = -offsetParentRect.height + offsets.bottom;
      }
    } else {
      top = offsets.top;
    }
    if (sideB === 'right') {
      if (offsetParent.nodeName === 'HTML') {
        left = -offsetParent.clientWidth + offsets.right;
      } else {
        left = -offsetParentRect.width + offsets.right;
      }
    } else {
      left = offsets.left;
    }
    if (gpuAcceleration && prefixedProperty) {
      styles[prefixedProperty] = 'translate3d(' + left + 'px, ' + top + 'px, 0)';
      styles[sideA] = 0;
      styles[sideB] = 0;
      styles.willChange = 'transform';
    } else {
      // othwerise, we use the standard `top`, `left`, `bottom` and `right` properties
      var invertTop = sideA === 'bottom' ? -1 : 1;
      var invertLeft = sideB === 'right' ? -1 : 1;
      styles[sideA] = top * invertTop;
      styles[sideB] = left * invertLeft;
      styles.willChange = sideA + ', ' + sideB;
    }
  
    // Attributes
    var attributes = {
      'x-placement': data.placement
    };
  
    // Update `data` attributes, styles and arrowStyles
    data.attributes = _extends({}, attributes, data.attributes);
    data.styles = _extends({}, styles, data.styles);
    data.arrowStyles = _extends({}, data.offsets.arrow, data.arrowStyles);
  
    return data;
  }
  
  /**
   * Helper used to know if the given modifier depends from another one.<br />
   * It checks if the needed modifier is listed and enabled.
   * @method
   * @memberof Popper.Utils
   * @param {Array} modifiers - list of modifiers
   * @param {String} requestingName - name of requesting modifier
   * @param {String} requestedName - name of requested modifier
   * @returns {Boolean}
   */
  function isModifierRequired(modifiers, requestingName, requestedName) {
    var requesting = find(modifiers, function (_ref) {
      var name = _ref.name;
      return name === requestingName;
    });
  
    var isRequired = !!requesting && modifiers.some(function (modifier) {
      return modifier.name === requestedName && modifier.enabled && modifier.order < requesting.order;
    });
  
    if (!isRequired) {
      var _requesting = '`' + requestingName + '`';
      var requested = '`' + requestedName + '`';
      console.warn(requested + ' modifier is required by ' + _requesting + ' modifier in order to work, be sure to include it before ' + _requesting + '!');
    }
    return isRequired;
  }
  
  /**
   * @function
   * @memberof Modifiers
   * @argument {Object} data - The data object generated by update method
   * @argument {Object} options - Modifiers configuration and options
   * @returns {Object} The data object, properly modified
   */
  function arrow(data, options) {
    var _data$offsets$arrow;
  
    // arrow depends on keepTogether in order to work
    if (!isModifierRequired(data.instance.modifiers, 'arrow', 'keepTogether')) {
      return data;
    }
  
    var arrowElement = options.element;
  
    // if arrowElement is a string, suppose it's a CSS selector
    if (typeof arrowElement === 'string') {
      arrowElement = data.instance.popper.querySelector(arrowElement);
  
      // if arrowElement is not found, don't run the modifier
      if (!arrowElement) {
        return data;
      }
    } else {
      // if the arrowElement isn't a query selector we must check that the
      // provided DOM node is child of its popper node
      if (!data.instance.popper.contains(arrowElement)) {
        console.warn('WARNING: `arrow.element` must be child of its popper element!');
        return data;
      }
    }
  
    var placement = data.placement.split('-')[0];
    var _data$offsets = data.offsets,
        popper = _data$offsets.popper,
        reference = _data$offsets.reference;
  
    var isVertical = ['left', 'right'].indexOf(placement) !== -1;
  
    var len = isVertical ? 'height' : 'width';
    var sideCapitalized = isVertical ? 'Top' : 'Left';
    var side = sideCapitalized.toLowerCase();
    var altSide = isVertical ? 'left' : 'top';
    var opSide = isVertical ? 'bottom' : 'right';
    var arrowElementSize = getOuterSizes(arrowElement)[len];
  
    //
    // extends keepTogether behavior making sure the popper and its
    // reference have enough pixels in conjunction
    //
  
    // top/left side
    if (reference[opSide] - arrowElementSize < popper[side]) {
      data.offsets.popper[side] -= popper[side] - (reference[opSide] - arrowElementSize);
    }
    // bottom/right side
    if (reference[side] + arrowElementSize > popper[opSide]) {
      data.offsets.popper[side] += reference[side] + arrowElementSize - popper[opSide];
    }
    data.offsets.popper = getClientRect(data.offsets.popper);
  
    // compute center of the popper
    var center = reference[side] + reference[len] / 2 - arrowElementSize / 2;
  
    // Compute the sideValue using the updated popper offsets
    // take popper margin in account because we don't have this info available
    var css = getStyleComputedProperty(data.instance.popper);
    var popperMarginSide = parseFloat(css['margin' + sideCapitalized], 10);
    var popperBorderSide = parseFloat(css['border' + sideCapitalized + 'Width'], 10);
    var sideValue = center - data.offsets.popper[side] - popperMarginSide - popperBorderSide;
  
    // prevent arrowElement from being placed not contiguously to its popper
    sideValue = Math.max(Math.min(popper[len] - arrowElementSize, sideValue), 0);
  
    data.arrowElement = arrowElement;
    data.offsets.arrow = (_data$offsets$arrow = {}, defineProperty(_data$offsets$arrow, side, Math.round(sideValue)), defineProperty(_data$offsets$arrow, altSide, ''), _data$offsets$arrow);
  
    return data;
  }
  
  /**
   * Get the opposite placement variation of the given one
   * @method
   * @memberof Popper.Utils
   * @argument {String} placement variation
   * @returns {String} flipped placement variation
   */
  function getOppositeVariation(variation) {
    if (variation === 'end') {
      return 'start';
    } else if (variation === 'start') {
      return 'end';
    }
    return variation;
  }
  
  /**
   * List of accepted placements to use as values of the `placement` option.<br />
   * Valid placements are:
   * - `auto`
   * - `top`
   * - `right`
   * - `bottom`
   * - `left`
   *
   * Each placement can have a variation from this list:
   * - `-start`
   * - `-end`
   *
   * Variations are interpreted easily if you think of them as the left to right
   * written languages. Horizontally (`top` and `bottom`), `start` is left and `end`
   * is right.<br />
   * Vertically (`left` and `right`), `start` is top and `end` is bottom.
   *
   * Some valid examples are:
   * - `top-end` (on top of reference, right aligned)
   * - `right-start` (on right of reference, top aligned)
   * - `bottom` (on bottom, centered)
   * - `auto-end` (on the side with more space available, alignment depends by placement)
   *
   * @static
   * @type {Array}
   * @enum {String}
   * @readonly
   * @method placements
   * @memberof Popper
   */
  var 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'];
  
  // Get rid of `auto` `auto-start` and `auto-end`
  var validPlacements = placements.slice(3);
  
  /**
   * Given an initial placement, returns all the subsequent placements
   * clockwise (or counter-clockwise).
   *
   * @method
   * @memberof Popper.Utils
   * @argument {String} placement - A valid placement (it accepts variations)
   * @argument {Boolean} counter - Set to true to walk the placements counterclockwise
   * @returns {Array} placements including their variations
   */
  function clockwise(placement) {
    var counter = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
  
    var index = validPlacements.indexOf(placement);
    var arr = validPlacements.slice(index + 1).concat(validPlacements.slice(0, index));
    return counter ? arr.reverse() : arr;
  }
  
  var BEHAVIORS = {
    FLIP: 'flip',
    CLOCKWISE: 'clockwise',
    COUNTERCLOCKWISE: 'counterclockwise'
  };
  
  /**
   * @function
   * @memberof Modifiers
   * @argument {Object} data - The data object generated by update method
   * @argument {Object} options - Modifiers configuration and options
   * @returns {Object} The data object, properly modified
   */
  function flip(data, options) {
    // if `inner` modifier is enabled, we can't use the `flip` modifier
    if (isModifierEnabled(data.instance.modifiers, 'inner')) {
      return data;
    }
  
    if (data.flipped && data.placement === data.originalPlacement) {
      // seems like flip is trying to loop, probably there's not enough space on any of the flippable sides
      return data;
    }
  
    var boundaries = getBoundaries(data.instance.popper, data.instance.reference, options.padding, options.boundariesElement, data.positionFixed);
  
    var placement = data.placement.split('-')[0];
    var placementOpposite = getOppositePlacement(placement);
    var variation = data.placement.split('-')[1] || '';
  
    var flipOrder = [];
  
    switch (options.behavior) {
      case BEHAVIORS.FLIP:
        flipOrder = [placement, placementOpposite];
        break;
      case BEHAVIORS.CLOCKWISE:
        flipOrder = clockwise(placement);
        break;
      case BEHAVIORS.COUNTERCLOCKWISE:
        flipOrder = clockwise(placement, true);
        break;
      default:
        flipOrder = options.behavior;
    }
  
    flipOrder.forEach(function (step, index) {
      if (placement !== step || flipOrder.length === index + 1) {
        return data;
      }
  
      placement = data.placement.split('-')[0];
      placementOpposite = getOppositePlacement(placement);
  
      var popperOffsets = data.offsets.popper;
      var refOffsets = data.offsets.reference;
  
      // using floor because the reference offsets may contain decimals we are not going to consider here
      var floor = Math.floor;
      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);
  
      var overflowsLeft = floor(popperOffsets.left) < floor(boundaries.left);
      var overflowsRight = floor(popperOffsets.right) > floor(boundaries.right);
      var overflowsTop = floor(popperOffsets.top) < floor(boundaries.top);
      var overflowsBottom = floor(popperOffsets.bottom) > floor(boundaries.bottom);
  
      var overflowsBoundaries = placement === 'left' && overflowsLeft || placement === 'right' && overflowsRight || placement === 'top' && overflowsTop || placement === 'bottom' && overflowsBottom;
  
      // flip the variation if required
      var isVertical = ['top', 'bottom'].indexOf(placement) !== -1;
      var flippedVariation = !!options.flipVariations && (isVertical && variation === 'start' && overflowsLeft || isVertical && variation === 'end' && overflowsRight || !isVertical && variation === 'start' && overflowsTop || !isVertical && variation === 'end' && overflowsBottom);
  
      if (overlapsRef || overflowsBoundaries || flippedVariation) {
        // this boolean to detect any flip loop
        data.flipped = true;
  
        if (overlapsRef || overflowsBoundaries) {
          placement = flipOrder[index + 1];
        }
  
        if (flippedVariation) {
          variation = getOppositeVariation(variation);
        }
  
        data.placement = placement + (variation ? '-' + variation : '');
  
        // this object contains `position`, we want to preserve it along with
        // any additional property we may add in the future
        data.offsets.popper = _extends({}, data.offsets.popper, getPopperOffsets(data.instance.popper, data.offsets.reference, data.placement));
  
        data = runModifiers(data.instance.modifiers, data, 'flip');
      }
    });
    return data;
  }
  
  /**
   * @function
   * @memberof Modifiers
   * @argument {Object} data - The data object generated by update method
   * @argument {Object} options - Modifiers configuration and options
   * @returns {Object} The data object, properly modified
   */
  function keepTogether(data) {
    var _data$offsets = data.offsets,
        popper = _data$offsets.popper,
        reference = _data$offsets.reference;
  
    var placement = data.placement.split('-')[0];
    var floor = Math.floor;
    var isVertical = ['top', 'bottom'].indexOf(placement) !== -1;
    var side = isVertical ? 'right' : 'bottom';
    var opSide = isVertical ? 'left' : 'top';
    var measurement = isVertical ? 'width' : 'height';
  
    if (popper[side] < floor(reference[opSide])) {
      data.offsets.popper[opSide] = floor(reference[opSide]) - popper[measurement];
    }
    if (popper[opSide] > floor(reference[side])) {
      data.offsets.popper[opSide] = floor(reference[side]);
    }
  
    return data;
  }
  
  /**
   * Converts a string containing value + unit into a px value number
   * @function
   * @memberof {modifiers~offset}
   * @private
   * @argument {String} str - Value + unit string
   * @argument {String} measurement - `height` or `width`
   * @argument {Object} popperOffsets
   * @argument {Object} referenceOffsets
   * @returns {Number|String}
   * Value in pixels, or original string if no values were extracted
   */
  function toValue(str, measurement, popperOffsets, referenceOffsets) {
    // separate value from unit
    var split = str.match(/((?:\-|\+)?\d*\.?\d*)(.*)/);
    var value = +split[1];
    var unit = split[2];
  
    // If it's not a number it's an operator, I guess
    if (!value) {
      return str;
    }
  
    if (unit.indexOf('%') === 0) {
      var element = void 0;
      switch (unit) {
        case '%p':
          element = popperOffsets;
          break;
        case '%':
        case '%r':
        default:
          element = referenceOffsets;
      }
  
      var rect = getClientRect(element);
      return rect[measurement] / 100 * value;
    } else if (unit === 'vh' || unit === 'vw') {
      // if is a vh or vw, we calculate the size based on the viewport
      var size = void 0;
      if (unit === 'vh') {
        size = Math.max(document.documentElement.clientHeight, window.innerHeight || 0);
      } else {
        size = Math.max(document.documentElement.clientWidth, window.innerWidth || 0);
      }
      return size / 100 * value;
    } else {
      // if is an explicit pixel unit, we get rid of the unit and keep the value
      // if is an implicit unit, it's px, and we return just the value
      return value;
    }
  }
  
  /**
   * Parse an `offset` string to extrapolate `x` and `y` numeric offsets.
   * @function
   * @memberof {modifiers~offset}
   * @private
   * @argument {String} offset
   * @argument {Object} popperOffsets
   * @argument {Object} referenceOffsets
   * @argument {String} basePlacement
   * @returns {Array} a two cells array with x and y offsets in numbers
   */
  function parseOffset(offset, popperOffsets, referenceOffsets, basePlacement) {
    var offsets = [0, 0];
  
    // Use height if placement is left or right and index is 0 otherwise use width
    // in this way the first offset will use an axis and the second one
    // will use the other one
    var useHeight = ['right', 'left'].indexOf(basePlacement) !== -1;
  
    // Split the offset string to obtain a list of values and operands
    // The regex addresses values with the plus or minus sign in front (+10, -20, etc)
    var fragments = offset.split(/(\+|\-)/).map(function (frag) {
      return frag.trim();
    });
  
    // Detect if the offset string contains a pair of values or a single one
    // they could be separated by comma or space
    var divider = fragments.indexOf(find(fragments, function (frag) {
      return frag.search(/,|\s/) !== -1;
    }));
  
    if (fragments[divider] && fragments[divider].indexOf(',') === -1) {
      console.warn('Offsets separated by white space(s) are deprecated, use a comma (,) instead.');
    }
  
    // If divider is found, we divide the list of values and operands to divide
    // them by ofset X and Y.
    var splitRegex = /\s*,\s*|\s+/;
    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];
  
    // Convert the values with units to absolute pixels to allow our computations
    ops = ops.map(function (op, index) {
      // Most of the units rely on the orientation of the popper
      var measurement = (index === 1 ? !useHeight : useHeight) ? 'height' : 'width';
      var mergeWithPrevious = false;
      return op
      // This aggregates any `+` or `-` sign that aren't considered operators
      // e.g.: 10 + +5 => [10, +, +5]
      .reduce(function (a, b) {
        if (a[a.length - 1] === '' && ['+', '-'].indexOf(b) !== -1) {
          a[a.length - 1] = b;
          mergeWithPrevious = true;
          return a;
        } else if (mergeWithPrevious) {
          a[a.length - 1] += b;
          mergeWithPrevious = false;
          return a;
        } else {
          return a.concat(b);
        }
      }, [])
      // Here we convert the string values into number values (in px)
      .map(function (str) {
        return toValue(str, measurement, popperOffsets, referenceOffsets);
      });
    });
  
    // Loop trough the offsets arrays and execute the operations
    ops.forEach(function (op, index) {
      op.forEach(function (frag, index2) {
        if (isNumeric(frag)) {
          offsets[index] += frag * (op[index2 - 1] === '-' ? -1 : 1);
        }
      });
    });
    return offsets;
  }
  
  /**
   * @function
   * @memberof Modifiers
   * @argument {Object} data - The data object generated by update method
   * @argument {Object} options - Modifiers configuration and options
   * @argument {Number|String} options.offset=0
   * The offset value as described in the modifier description
   * @returns {Object} The data object, properly modified
   */
  function offset(data, _ref) {
    var offset = _ref.offset;
    var placement = data.placement,
        _data$offsets = data.offsets,
        popper = _data$offsets.popper,
        reference = _data$offsets.reference;
  
    var basePlacement = placement.split('-')[0];
  
    var offsets = void 0;
    if (isNumeric(+offset)) {
      offsets = [+offset, 0];
    } else {
      offsets = parseOffset(offset, popper, reference, basePlacement);
    }
  
    if (basePlacement === 'left') {
      popper.top += offsets[0];
      popper.left -= offsets[1];
    } else if (basePlacement === 'right') {
      popper.top += offsets[0];
      popper.left += offsets[1];
    } else if (basePlacement === 'top') {
      popper.left += offsets[0];
      popper.top -= offsets[1];
    } else if (basePlacement === 'bottom') {
      popper.left += offsets[0];
      popper.top += offsets[1];
    }
  
    data.popper = popper;
    return data;
  }
  
  /**
   * @function
   * @memberof Modifiers
   * @argument {Object} data - The data object generated by `update` method
   * @argument {Object} options - Modifiers configuration and options
   * @returns {Object} The data object, properly modified
   */
  function preventOverflow(data, options) {
    var boundariesElement = options.boundariesElement || getOffsetParent(data.instance.popper);
  
    // If offsetParent is the reference element, we really want to
    // go one step up and use the next offsetParent as reference to
    // avoid to make this modifier completely useless and look like broken
    if (data.instance.reference === boundariesElement) {
      boundariesElement = getOffsetParent(boundariesElement);
    }
  
    // NOTE: DOM access here
    // resets the popper's position so that the document size can be calculated excluding
    // the size of the popper element itself
    var transformProp = getSupportedPropertyName('transform');
    var popperStyles = data.instance.popper.style; // assignment to help minification
    var top = popperStyles.top,
        left = popperStyles.left,
        transform = popperStyles[transformProp];
  
    popperStyles.top = '';
    popperStyles.left = '';
    popperStyles[transformProp] = '';
  
    var boundaries = getBoundaries(data.instance.popper, data.instance.reference, options.padding, boundariesElement, data.positionFixed);
  
    // NOTE: DOM access here
    // restores the original style properties after the offsets have been computed
    popperStyles.top = top;
    popperStyles.left = left;
    popperStyles[transformProp] = transform;
  
    options.boundaries = boundaries;
  
    var order = options.priority;
    var popper = data.offsets.popper;
  
    var check = {
      primary: function primary(placement) {
        var value = popper[placement];
        if (popper[placement] < boundaries[placement] && !options.escapeWithReference) {
          value = Math.max(popper[placement], boundaries[placement]);
        }
        return defineProperty({}, placement, value);
      },
      secondary: function secondary(placement) {
        var mainSide = placement === 'right' ? 'left' : 'top';
        var value = popper[mainSide];
        if (popper[placement] > boundaries[placement] && !options.escapeWithReference) {
          value = Math.min(popper[mainSide], boundaries[placement] - (placement === 'right' ? popper.width : popper.height));
        }
        return defineProperty({}, mainSide, value);
      }
    };
  
    order.forEach(function (placement) {
      var side = ['left', 'top'].indexOf(placement) !== -1 ? 'primary' : 'secondary';
      popper = _extends({}, popper, check[side](placement));
    });
  
    data.offsets.popper = popper;
  
    return data;
  }
  
  /**
   * @function
   * @memberof Modifiers
   * @argument {Object} data - The data object generated by `update` method
   * @argument {Object} options - Modifiers configuration and options
   * @returns {Object} The data object, properly modified
   */
  function shift(data) {
    var placement = data.placement;
    var basePlacement = placement.split('-')[0];
    var shiftvariation = placement.split('-')[1];
  
    // if shift shiftvariation is specified, run the modifier
    if (shiftvariation) {
      var _data$offsets = data.offsets,
          reference = _data$offsets.reference,
          popper = _data$offsets.popper;
  
      var isVertical = ['bottom', 'top'].indexOf(basePlacement) !== -1;
      var side = isVertical ? 'left' : 'top';
      var measurement = isVertical ? 'width' : 'height';
  
      var shiftOffsets = {
        start: defineProperty({}, side, reference[side]),
        end: defineProperty({}, side, reference[side] + reference[measurement] - popper[measurement])
      };
  
      data.offsets.popper = _extends({}, popper, shiftOffsets[shiftvariation]);
    }
  
    return data;
  }
  
  /**
   * @function
   * @memberof Modifiers
   * @argument {Object} data - The data object generated by update method
   * @argument {Object} options - Modifiers configuration and options
   * @returns {Object} The data object, properly modified
   */
  function hide(data) {
    if (!isModifierRequired(data.instance.modifiers, 'hide', 'preventOverflow')) {
      return data;
    }
  
    var refRect = data.offsets.reference;
    var bound = find(data.instance.modifiers, function (modifier) {
      return modifier.name === 'preventOverflow';
    }).boundaries;
  
    if (refRect.bottom < bound.top || refRect.left > bound.right || refRect.top > bound.bottom || refRect.right < bound.left) {
      // Avoid unnecessary DOM access if visibility hasn't changed
      if (data.hide === true) {
        return data;
      }
  
      data.hide = true;
      data.attributes['x-out-of-boundaries'] = '';
    } else {
      // Avoid unnecessary DOM access if visibility hasn't changed
      if (data.hide === false) {
        return data;
      }
  
      data.hide = false;
      data.attributes['x-out-of-boundaries'] = false;
    }
  
    return data;
  }
  
  /**
   * @function
   * @memberof Modifiers
   * @argument {Object} data - The data object generated by `update` method
   * @argument {Object} options - Modifiers configuration and options
   * @returns {Object} The data object, properly modified
   */
  function inner(data) {
    var placement = data.placement;
    var basePlacement = placement.split('-')[0];
    var _data$offsets = data.offsets,
        popper = _data$offsets.popper,
        reference = _data$offsets.reference;
  
    var isHoriz = ['left', 'right'].indexOf(basePlacement) !== -1;
  
    var subtractLength = ['top', 'left'].indexOf(basePlacement) === -1;
  
    popper[isHoriz ? 'left' : 'top'] = reference[basePlacement] - (subtractLength ? popper[isHoriz ? 'width' : 'height'] : 0);
  
    data.placement = getOppositePlacement(placement);
    data.offsets.popper = getClientRect(popper);
  
    return data;
  }
  
  /**
   * Modifier function, each modifier can have a function of this type assigned
   * to its `fn` property.<br />
   * These functions will be called on each update, this means that you must
   * make sure they are performant enough to avoid performance bottlenecks.
   *
   * @function ModifierFn
   * @argument {dataObject} data - The data object generated by `update` method
   * @argument {Object} options - Modifiers configuration and options
   * @returns {dataObject} The data object, properly modified
   */
  
  /**
   * Modifiers are plugins used to alter the behavior of your poppers.<br />
   * Popper.js uses a set of 9 modifiers to provide all the basic functionalities
   * needed by the library.
   *
   * Usually you don't want to override the `order`, `fn` and `onLoad` props.
   * All the other properties are configurations that could be tweaked.
   * @namespace modifiers
   */
  var modifiers = {
    /**
     * Modifier used to shift the popper on the start or end of its reference
     * element.<br />
     * It will read the variation of the `placement` property.<br />
     * It can be one either `-end` or `-start`.
     * @memberof modifiers
     * @inner
     */
    shift: {
      /** @prop {number} order=100 - Index used to define the order of execution */
      order: 100,
      /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */
      enabled: true,
      /** @prop {ModifierFn} */
      fn: shift
    },
  
    /**
     * The `offset` modifier can shift your popper on both its axis.
     *
     * It accepts the following units:
     * - `px` or unit-less, interpreted as pixels
     * - `%` or `%r`, percentage relative to the length of the reference element
     * - `%p`, percentage relative to the length of the popper element
     * - `vw`, CSS viewport width unit
     * - `vh`, CSS viewport height unit
     *
     * For length is intended the main axis relative to the placement of the popper.<br />
     * This means that if the placement is `top` or `bottom`, the length will be the
     * `width`. In case of `left` or `right`, it will be the `height`.
     *
     * You can provide a single value (as `Number` or `String`), or a pair of values
     * as `String` divided by a comma or one (or more) white spaces.<br />
     * The latter is a deprecated method because it leads to confusion and will be
     * removed in v2.<br />
     * Additionally, it accepts additions and subtractions between different units.
     * Note that multiplications and divisions aren't supported.
     *
     * Valid examples are:
     * ```
     * 10
     * '10%'
     * '10, 10'
     * '10%, 10'
     * '10 + 10%'
     * '10 - 5vh + 3%'
     * '-10px + 5vh, 5px - 6%'
     * ```
     * > **NB**: If you desire to apply offsets to your poppers in a way that may make them overlap
     * > with their reference element, unfortunately, you will have to disable the `flip` modifier.
     * > You can read more on this at this [issue](https://github.com/FezVrasta/popper.js/issues/373).
     *
     * @memberof modifiers
     * @inner
     */
    offset: {
      /** @prop {number} order=200 - Index used to define the order of execution */
      order: 200,
      /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */
      enabled: true,
      /** @prop {ModifierFn} */
      fn: offset,
      /** @prop {Number|String} offset=0
       * The offset value as described in the modifier description
       */
      offset: 0
    },
  
    /**
     * Modifier used to prevent the popper from being positioned outside the boundary.
     *
     * A scenario exists where the reference itself is not within the boundaries.<br />
     * We can say it has "escaped the boundaries" — or just "escaped".<br />
     * In this case we need to decide whether the popper should either:
     *
     * - detach from the reference and remain "trapped" in the boundaries, or
     * - if it should ignore the boundary and "escape with its reference"
     *
     * When `escapeWithReference` is set to`true` and reference is completely
     * outside its boundaries, the popper will overflow (or completely leave)
     * the boundaries in order to remain attached to the edge of the reference.
     *
     * @memberof modifiers
     * @inner
     */
    preventOverflow: {
      /** @prop {number} order=300 - Index used to define the order of execution */
      order: 300,
      /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */
      enabled: true,
      /** @prop {ModifierFn} */
      fn: preventOverflow,
      /**
       * @prop {Array} [priority=['left','right','top','bottom']]
       * Popper will try to prevent overflow following these priorities by default,
       * then, it could overflow on the left and on top of the `boundariesElement`
       */
      priority: ['left', 'right', 'top', 'bottom'],
      /**
       * @prop {number} padding=5
       * Amount of pixel used to define a minimum distance between the boundaries
       * and the popper. This makes sure the popper always has a little padding
       * between the edges of its container
       */
      padding: 5,
      /**
       * @prop {String|HTMLElement} boundariesElement='scrollParent'
       * Boundaries used by the modifier. Can be `scrollParent`, `window`,
       * `viewport` or any DOM element.
       */
      boundariesElement: 'scrollParent'
    },
  
    /**
     * Modifier used to make sure the reference and its popper stay near each other
     * without leaving any gap between the two. Especially useful when the arrow is
     * enabled and you want to ensure that it points to its reference element.
     * It cares only about the first axis. You can still have poppers with margin
     * between the popper and its reference element.
     * @memberof modifiers
     * @inner
     */
    keepTogether: {
      /** @prop {number} order=400 - Index used to define the order of execution */
      order: 400,
      /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */
      enabled: true,
      /** @prop {ModifierFn} */
      fn: keepTogether
    },
  
    /**
     * This modifier is used to move the `arrowElement` of the popper to make
     * sure it is positioned between the reference element and its popper element.
     * It will read the outer size of the `arrowElement` node to detect how many
     * pixels of conjunction are needed.
     *
     * It has no effect if no `arrowElement` is provided.
     * @memberof modifiers
     * @inner
     */
    arrow: {
      /** @prop {number} order=500 - Index used to define the order of execution */
      order: 500,
      /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */
      enabled: true,
      /** @prop {ModifierFn} */
      fn: arrow,
      /** @prop {String|HTMLElement} element='[x-arrow]' - Selector or node used as arrow */
      element: '[x-arrow]'
    },
  
    /**
     * Modifier used to flip the popper's placement when it starts to overlap its
     * reference element.
     *
     * Requires the `preventOverflow` modifier before it in order to work.
     *
     * **NOTE:** this modifier will interrupt the current update cycle and will
     * restart it if it detects the need to flip the placement.
     * @memberof modifiers
     * @inner
     */
    flip: {
      /** @prop {number} order=600 - Index used to define the order of execution */
      order: 600,
      /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */
      enabled: true,
      /** @prop {ModifierFn} */
      fn: flip,
      /**
       * @prop {String|Array} behavior='flip'
       * The behavior used to change the popper's placement. It can be one of
       * `flip`, `clockwise`, `counterclockwise` or an array with a list of valid
       * placements (with optional variations)
       */
      behavior: 'flip',
      /**
       * @prop {number} padding=5
       * The popper will flip if it hits the edges of the `boundariesElement`
       */
      padding: 5,
      /**
       * @prop {String|HTMLElement} boundariesElement='viewport'
       * The element which will define the boundaries of the popper position.
       * The popper will never be placed outside of the defined boundaries
       * (except if `keepTogether` is enabled)
       */
      boundariesElement: 'viewport'
    },
  
    /**
     * Modifier used to make the popper flow toward the inner of the reference element.
     * By default, when this modifier is disabled, the popper will be placed outside
     * the reference element.
     * @memberof modifiers
     * @inner
     */
    inner: {
      /** @prop {number} order=700 - Index used to define the order of execution */
      order: 700,
      /** @prop {Boolean} enabled=false - Whether the modifier is enabled or not */
      enabled: false,
      /** @prop {ModifierFn} */
      fn: inner
    },
  
    /**
     * Modifier used to hide the popper when its reference element is outside of the
     * popper boundaries. It will set a `x-out-of-boundaries` attribute which can
     * be used to hide with a CSS selector the popper when its reference is
     * out of boundaries.
     *
     * Requires the `preventOverflow` modifier before it in order to work.
     * @memberof modifiers
     * @inner
     */
    hide: {
      /** @prop {number} order=800 - Index used to define the order of execution */
      order: 800,
      /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */
      enabled: true,
      /** @prop {ModifierFn} */
      fn: hide
    },
  
    /**
     * Computes the style that will be applied to the popper element to gets
     * properly positioned.
     *
     * Note that this modifier will not touch the DOM, it just prepares the styles
     * so that `applyStyle` modifier can apply it. This separation is useful
     * in case you need to replace `applyStyle` with a custom implementation.
     *
     * This modifier has `850` as `order` value to maintain backward compatibility
     * with previous versions of Popper.js. Expect the modifiers ordering method
     * to change in future major versions of the library.
     *
     * @memberof modifiers
     * @inner
     */
    computeStyle: {
      /** @prop {number} order=850 - Index used to define the order of execution */
      order: 850,
      /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */
      enabled: true,
      /** @prop {ModifierFn} */
      fn: computeStyle,
      /**
       * @prop {Boolean} gpuAcceleration=true
       * If true, it uses the CSS 3D transformation to position the popper.
       * Otherwise, it will use the `top` and `left` properties
       */
      gpuAcceleration: true,
      /**
       * @prop {string} [x='bottom']
       * Where to anchor the X axis (`bottom` or `top`). AKA X offset origin.
       * Change this if your popper should grow in a direction different from `bottom`
       */
      x: 'bottom',
      /**
       * @prop {string} [x='left']
       * Where to anchor the Y axis (`left` or `right`). AKA Y offset origin.
       * Change this if your popper should grow in a direction different from `right`
       */
      y: 'right'
    },
  
    /**
     * Applies the computed styles to the popper element.
     *
     * All the DOM manipulations are limited to this modifier. This is useful in case
     * you want to integrate Popper.js inside a framework or view library and you
     * want to delegate all the DOM manipulations to it.
     *
     * Note that if you disable this modifier, you must make sure the popper element
     * has its position set to `absolute` before Popper.js can do its work!
     *
     * Just disable this modifier and define your own to achieve the desired effect.
     *
     * @memberof modifiers
     * @inner
     */
    applyStyle: {
      /** @prop {number} order=900 - Index used to define the order of execution */
      order: 900,
      /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */
      enabled: true,
      /** @prop {ModifierFn} */
      fn: applyStyle,
      /** @prop {Function} */
      onLoad: applyStyleOnLoad,
      /**
       * @deprecated since version 1.10.0, the property moved to `computeStyle` modifier
       * @prop {Boolean} gpuAcceleration=true
       * If true, it uses the CSS 3D transformation to position the popper.
       * Otherwise, it will use the `top` and `left` properties
       */
      gpuAcceleration: undefined
    }
  };
  
  /**
   * The `dataObject` is an object containing all the information used by Popper.js.
   * This object is passed to modifiers and to the `onCreate` and `onUpdate` callbacks.
   * @name dataObject
   * @property {Object} data.instance The Popper.js instance
   * @property {String} data.placement Placement applied to popper
   * @property {String} data.originalPlacement Placement originally defined on init
   * @property {Boolean} data.flipped True if popper has been flipped by flip modifier
   * @property {Boolean} data.hide True if the reference element is out of boundaries, useful to know when to hide the popper
   * @property {HTMLElement} data.arrowElement Node used as arrow by arrow modifier
   * @property {Object} data.styles Any CSS property defined here will be applied to the popper. It expects the JavaScript nomenclature (eg. `marginBottom`)
   * @property {Object} data.arrowStyles Any CSS property defined here will be applied to the popper arrow. It expects the JavaScript nomenclature (eg. `marginBottom`)
   * @property {Object} data.boundaries Offsets of the popper boundaries
   * @property {Object} data.offsets The measurements of popper, reference and arrow elements
   * @property {Object} data.offsets.popper `top`, `left`, `width`, `height` values
   * @property {Object} data.offsets.reference `top`, `left`, `width`, `height` values
   * @property {Object} data.offsets.arrow] `top` and `left` offsets, only one of them will be different from 0
   */
  
  /**
   * Default options provided to Popper.js constructor.<br />
   * These can be overridden using the `options` argument of Popper.js.<br />
   * To override an option, simply pass an object with the same
   * structure of the `options` object, as the 3rd argument. For example:
   * ```
   * new Popper(ref, pop, {
   *   modifiers: {
   *     preventOverflow: { enabled: false }
   *   }
   * })
   * ```
   * @type {Object}
   * @static
   * @memberof Popper
   */
  var Defaults = {
    /**
     * Popper's placement.
     * @prop {Popper.placements} placement='bottom'
     */
    placement: 'bottom',
  
    /**
     * Set this to true if you want popper to position it self in 'fixed' mode
     * @prop {Boolean} positionFixed=false
     */
    positionFixed: false,
  
    /**
     * Whether events (resize, scroll) are initially enabled.
     * @prop {Boolean} eventsEnabled=true
     */
    eventsEnabled: true,
  
    /**
     * Set to true if you want to automatically remove the popper when
     * you call the `destroy` method.
     * @prop {Boolean} removeOnDestroy=false
     */
    removeOnDestroy: false,
  
    /**
     * Callback called when the popper is created.<br />
     * By default, it is set to no-op.<br />
     * Access Popper.js instance with `data.instance`.
     * @prop {onCreate}
     */
    onCreate: function onCreate() {},
  
    /**
     * Callback called when the popper is updated. This callback is not called
     * on the initialization/creation of the popper, but only on subsequent
     * updates.<br />
     * By default, it is set to no-op.<br />
     * Access Popper.js instance with `data.instance`.
     * @prop {onUpdate}
     */
    onUpdate: function onUpdate() {},
  
    /**
     * List of modifiers used to modify the offsets before they are applied to the popper.
     * They provide most of the functionalities of Popper.js.
     * @prop {modifiers}
     */
    modifiers: modifiers
  };
  
  /**
   * @callback onCreate
   * @param {dataObject} data
   */
  
  /**
   * @callback onUpdate
   * @param {dataObject} data
   */
  
  // Utils
  // Methods
  var Popper = function () {
    /**
     * Creates a new Popper.js instance.
     * @class Popper
     * @param {HTMLElement|referenceObject} reference - The reference element used to position the popper
     * @param {HTMLElement} popper - The HTML element used as the popper
     * @param {Object} options - Your custom options to override the ones defined in [Defaults](#defaults)
     * @return {Object} instance - The generated Popper.js instance
     */
    function Popper(reference, popper) {
      var _this = this;
  
      var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
      classCallCheck(this, Popper);
  
      this.scheduleUpdate = function () {
        return requestAnimationFrame(_this.update);
      };
  
      // make update() debounced, so that it only runs at most once-per-tick
      this.update = debounce(this.update.bind(this));
  
      // with {} we create a new object with the options inside it
      this.options = _extends({}, Popper.Defaults, options);
  
      // init state
      this.state = {
        isDestroyed: false,
        isCreated: false,
        scrollParents: []
      };
  
      // get reference and popper elements (allow jQuery wrappers)
      this.reference = reference && reference.jquery ? reference[0] : reference;
      this.popper = popper && popper.jquery ? popper[0] : popper;
  
      // Deep merge modifiers options
      this.options.modifiers = {};
      Object.keys(_extends({}, Popper.Defaults.modifiers, options.modifiers)).forEach(function (name) {
        _this.options.modifiers[name] = _extends({}, Popper.Defaults.modifiers[name] || {}, options.modifiers ? options.modifiers[name] : {});
      });
  
      // Refactoring modifiers' list (Object => Array)
      this.modifiers = Object.keys(this.options.modifiers).map(function (name) {
        return _extends({
          name: name
        }, _this.options.modifiers[name]);
      })
      // sort the modifiers by order
      .sort(function (a, b) {
        return a.order - b.order;
      });
  
      // modifiers have the ability to execute arbitrary code when Popper.js get inited
      // such code is executed in the same order of its modifier
      // they could add new properties to their options configuration
      // BE AWARE: don't add options to `options.modifiers.name` but to `modifierOptions`!
      this.modifiers.forEach(function (modifierOptions) {
        if (modifierOptions.enabled && isFunction(modifierOptions.onLoad)) {
          modifierOptions.onLoad(_this.reference, _this.popper, _this.options, modifierOptions, _this.state);
        }
      });
  
      // fire the first update to position the popper in the right place
      this.update();
  
      var eventsEnabled = this.options.eventsEnabled;
      if (eventsEnabled) {
        // setup event listeners, they will take care of update the position in specific situations
        this.enableEventListeners();
      }
  
      this.state.eventsEnabled = eventsEnabled;
    }
  
    // We can't use class properties because they don't get listed in the
    // class prototype and break stuff like Sinon stubs
  
  
    createClass(Popper, [{
      key: 'update',
      value: function update$$1() {
        return update.call(this);
      }
    }, {
      key: 'destroy',
      value: function destroy$$1() {
        return destroy.call(this);
      }
    }, {
      key: 'enableEventListeners',
      value: function enableEventListeners$$1() {
        return enableEventListeners.call(this);
      }
    }, {
      key: 'disableEventListeners',
      value: function disableEventListeners$$1() {
        return disableEventListeners.call(this);
      }
  
      /**
       * Schedules an update. It will run on the next UI update available.
       * @method scheduleUpdate
       * @memberof Popper
       */
  
  
      /**
       * Collection of utilities useful when writing custom modifiers.
       * Starting from version 1.7, this method is available only if you
       * include `popper-utils.js` before `popper.js`.
       *
       * **DEPRECATION**: This way to access PopperUtils is deprecated
       * and will be removed in v2! Use the PopperUtils module directly instead.
       * Due to the high instability of the methods contained in Utils, we can't
       * guarantee them to follow semver. Use them at your own risk!
       * @static
       * @private
       * @type {Object}
       * @deprecated since version 1.8
       * @member Utils
       * @memberof Popper
       */
  
    }]);
    return Popper;
  }();
  
  /**
   * The `referenceObject` is an object that provides an interface compatible with Popper.js
   * and lets you use it as replacement of a real DOM node.<br />
   * You can use this method to position a popper relatively to a set of coordinates
   * in case you don't have a DOM node to use as reference.
   *
   * ```
   * new Popper(referenceObject, popperNode);
   * ```
   *
   * NB: This feature isn't supported in Internet Explorer 10.
   * @name referenceObject
   * @property {Function} data.getBoundingClientRect
   * A function that returns a set of coordinates compatible with the native `getBoundingClientRect` method.
   * @property {number} data.clientWidth
   * An ES6 getter that will return the width of the virtual reference element.
   * @property {number} data.clientHeight
   * An ES6 getter that will return the height of the virtual reference element.
   */
  
  
  Popper.Utils = (typeof window !== 'undefined' ? window : global).PopperUtils;
  Popper.placements = placements;
  Popper.Defaults = Defaults;
  
  /* harmony default export */ __webpack_exports__["a"] = Popper;
  //# sourceMappingURL=popper.js.map
  
  /* WEBPACK VAR INJECTION */}.call(__webpack_exports__, __webpack_require__(18)))
  
  /***/ }),
  
  /***/ 22:
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  var render = function () {var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;
    return _c(_vm.tag, {
      tag: "component",
      staticClass: "ui-focus-container"
    }, [(_vm.renderRedirector) ? _c('span', {
      staticClass: "ui-focus-container__focus-redirector",
      attrs: {
        "tabindex": "0"
      },
      on: {
        "focus": function($event) {
          _vm.redirectFocus($event, {
            isTabbingForward: false
          })
        }
      }
    }) : _vm._e(), _vm._v(" "), _c('div', {
      ref: "content",
      staticClass: "ui-focus-container__content",
      attrs: {
        "tabindex": "-1"
      }
    }, [_vm._t("default")], 2), _vm._v(" "), (!_vm.disabled && _vm.containFocus) ? _c('span', {
      ref: "lastFocusable",
      staticClass: "ui-focus-container__last-focusable",
      attrs: {
        "tabindex": "-1"
      }
    }) : _vm._e(), _vm._v(" "), (_vm.renderRedirector) ? _c('span', {
      staticClass: "ui-focus-container__focus-redirector",
      attrs: {
        "tabindex": "0"
      },
      on: {
        "focus": function($event) {
          _vm.redirectFocus($event, {
            isTabbingForward: true
          })
        }
      }
    }) : _vm._e()])
  }
  var staticRenderFns = []
  render._withStripped = true
  var esExports = { render: render, staticRenderFns: staticRenderFns }
  /* harmony default export */ __webpack_exports__["a"] = esExports;
  if (false) {
    module.hot.accept()
    if (module.hot.data) {
       require("vue-hot-reload-api").rerender("data-v-6c26f987", esExports)
    }
  }
  
  /***/ }),
  
  /***/ 228:
  /***/ (function(module, exports, __webpack_require__) {
  
  // style-loader: Adds some css to the DOM by adding a <style> tag
  
  // load the styles
  var content = __webpack_require__(175);
  if(typeof content === 'string') content = [[module.i, content, '']];
  if(content.locals) module.exports = content.locals;
  // add the styles to the DOM
  var update = __webpack_require__(2)("b65ecf60", content, false);
  // Hot Module Replacement
  if(false) {
   // When the styles change, update the <style> tags
   if(!content.locals) {
     module.hot.accept("!!../node_modules/css-loader/index.js!../node_modules/vue-loader/lib/style-compiler/index.js?{\"vue\":true,\"id\":\"data-v-b19a1326\",\"scoped\":false,\"hasInlineConfig\":true}!../node_modules/sass-loader/index.js!../node_modules/vue-loader/lib/selector.js?type=styles&index=0!./UiToolbar.vue", function() {
       var newContent = require("!!../node_modules/css-loader/index.js!../node_modules/vue-loader/lib/style-compiler/index.js?{\"vue\":true,\"id\":\"data-v-b19a1326\",\"scoped\":false,\"hasInlineConfig\":true}!../node_modules/sass-loader/index.js!../node_modules/vue-loader/lib/selector.js?type=styles&index=0!./UiToolbar.vue");
       if(typeof newContent === 'string') newContent = [[module.id, newContent, '']];
       update(newContent);
     });
   }
   // When the module is disposed, remove the <style> tags
   module.hot.dispose(function() { update(); });
  }
  
  /***/ }),
  
  /***/ 23:
  /***/ (function(module, exports, __webpack_require__) {
  
  // style-loader: Adds some css to the DOM by adding a <style> tag
  
  // load the styles
  var content = __webpack_require__(20);
  if(typeof content === 'string') content = [[module.i, content, '']];
  if(content.locals) module.exports = content.locals;
  // add the styles to the DOM
  var update = __webpack_require__(2)("c8ba9ecc", content, false);
  // Hot Module Replacement
  if(false) {
   // When the styles change, update the <style> tags
   if(!content.locals) {
     module.hot.accept("!!../node_modules/css-loader/index.js!../node_modules/vue-loader/lib/style-compiler/index.js?{\"vue\":true,\"id\":\"data-v-6c26f987\",\"scoped\":false,\"hasInlineConfig\":true}!../node_modules/sass-loader/index.js!../node_modules/vue-loader/lib/selector.js?type=styles&index=0!./UiFocusContainer.vue", function() {
       var newContent = require("!!../node_modules/css-loader/index.js!../node_modules/vue-loader/lib/style-compiler/index.js?{\"vue\":true,\"id\":\"data-v-6c26f987\",\"scoped\":false,\"hasInlineConfig\":true}!../node_modules/sass-loader/index.js!../node_modules/vue-loader/lib/selector.js?type=styles&index=0!./UiFocusContainer.vue");
       if(typeof newContent === 'string') newContent = [[module.id, newContent, '']];
       update(newContent);
     });
   }
   // When the module is disposed, remove the <style> tags
   module.hot.dispose(function() { update(); });
  }
  
  /***/ }),
  
  /***/ 24:
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  Object.defineProperty(__webpack_exports__, "__esModule", { value: true });
  /* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__babel_loader_node_modules_vue_loader_lib_selector_type_script_index_0_UiPopover_vue__ = __webpack_require__(28);
  /* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__node_modules_vue_loader_lib_template_compiler_index_id_data_v_48582497_hasScoped_false_node_modules_vue_loader_lib_selector_type_template_index_0_UiPopover_vue__ = __webpack_require__(34);
  var disposed = false
  function injectStyle (ssrContext) {
    if (disposed) return
    __webpack_require__(37)
  }
  var normalizeComponent = __webpack_require__(1)
  /* script */
  
  /* template */
  
  /* styles */
  var __vue_styles__ = injectStyle
  /* scopeId */
  var __vue_scopeId__ = null
  /* moduleIdentifier (server only) */
  var __vue_module_identifier__ = null
  var Component = normalizeComponent(
    __WEBPACK_IMPORTED_MODULE_0__babel_loader_node_modules_vue_loader_lib_selector_type_script_index_0_UiPopover_vue__["a" /* default */],
    __WEBPACK_IMPORTED_MODULE_1__node_modules_vue_loader_lib_template_compiler_index_id_data_v_48582497_hasScoped_false_node_modules_vue_loader_lib_selector_type_template_index_0_UiPopover_vue__["a" /* default */],
    __vue_styles__,
    __vue_scopeId__,
    __vue_module_identifier__
  )
  Component.options.__file = "src\\UiPopover.vue"
  if (Component.esModule && Object.keys(Component.esModule).some(function (key) {return key !== "default" && key.substr(0, 2) !== "__"})) {console.error("named exports are not supported in *.vue files.")}
  if (Component.options.functional) {console.error("[vue-loader] UiPopover.vue: functional components are not supported with templates, they should use render functions.")}
  
  /* hot reload */
  if (false) {(function () {
    var hotAPI = require("vue-hot-reload-api")
    hotAPI.install(require("vue"), false)
    if (!hotAPI.compatible) return
    module.hot.accept()
    if (!module.hot.data) {
      hotAPI.createRecord("data-v-48582497", Component.options)
    } else {
      hotAPI.reload("data-v-48582497", Component.options)
    }
    module.hot.dispose(function (data) {
      disposed = true
    })
  })()}
  
  /* harmony default export */ __webpack_exports__["default"] = Component.exports;
  
  
  /***/ }),
  
  /***/ 25:
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  /* unused harmony export on */
  /* unused harmony export onKeydown */
  /* unused harmony export onKeyup */
  /* unused harmony export onKeypress */
  function on(event, target, callback) {
      var options = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : { passive: true };
  
      target.addEventListener(event, callback, options);
  
      return function () {
          target.removeEventListener(event, callback, options);
      };
  }
  
  function onKey(key, event, target, callback, options) {
      return on(event, target, function (e) {
          if (!key) {
              callback(e);
          } else if (key === e.key || key === e.keyCode) {
              callback(e);
          }
      }, options);
  }
  
  function onKeydown(keys, target, callback, options) {
      return onKey(keys, 'keydown', target, callback, options);
  }
  
  function onKeyup(keys, target, callback, options) {
      return onKey(keys, 'keyup', target, callback, options);
  }
  
  function onKeypress(keys, target, callback, options) {
      return onKey(keys, 'keypress', target, callback, options);
  }
  
  /* harmony default export */ __webpack_exports__["a"] = {
      on: on,
      onKeydown: onKeydown,
      onKeyup: onKeyup,
      onKeypress: onKeypress
  };
  
  /***/ }),
  
  /***/ 26:
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  Object.defineProperty(__webpack_exports__, "__esModule", { value: true });
  /* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__babel_loader_node_modules_vue_loader_lib_selector_type_script_index_0_UiProgressCircular_vue__ = __webpack_require__(29);
  /* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__node_modules_vue_loader_lib_template_compiler_index_id_data_v_7bea93ea_hasScoped_false_node_modules_vue_loader_lib_selector_type_template_index_0_UiProgressCircular_vue__ = __webpack_require__(36);
  var disposed = false
  function injectStyle (ssrContext) {
    if (disposed) return
    __webpack_require__(39)
  }
  var normalizeComponent = __webpack_require__(1)
  /* script */
  
  /* template */
  
  /* styles */
  var __vue_styles__ = injectStyle
  /* scopeId */
  var __vue_scopeId__ = null
  /* moduleIdentifier (server only) */
  var __vue_module_identifier__ = null
  var Component = normalizeComponent(
    __WEBPACK_IMPORTED_MODULE_0__babel_loader_node_modules_vue_loader_lib_selector_type_script_index_0_UiProgressCircular_vue__["a" /* default */],
    __WEBPACK_IMPORTED_MODULE_1__node_modules_vue_loader_lib_template_compiler_index_id_data_v_7bea93ea_hasScoped_false_node_modules_vue_loader_lib_selector_type_template_index_0_UiProgressCircular_vue__["a" /* default */],
    __vue_styles__,
    __vue_scopeId__,
    __vue_module_identifier__
  )
  Component.options.__file = "src\\UiProgressCircular.vue"
  if (Component.esModule && Object.keys(Component.esModule).some(function (key) {return key !== "default" && key.substr(0, 2) !== "__"})) {console.error("named exports are not supported in *.vue files.")}
  if (Component.options.functional) {console.error("[vue-loader] UiProgressCircular.vue: functional components are not supported with templates, they should use render functions.")}
  
  /* hot reload */
  if (false) {(function () {
    var hotAPI = require("vue-hot-reload-api")
    hotAPI.install(require("vue"), false)
    if (!hotAPI.compatible) return
    module.hot.accept()
    if (!module.hot.data) {
      hotAPI.createRecord("data-v-7bea93ea", Component.options)
    } else {
      hotAPI.reload("data-v-7bea93ea", Component.options)
    }
    module.hot.dispose(function (data) {
      disposed = true
    })
  })()}
  
  /* harmony default export */ __webpack_exports__["default"] = Component.exports;
  
  
  /***/ }),
  
  /***/ 263:
  /***/ (function(module, exports, __webpack_require__) {
  
  module.exports = __webpack_require__(126);
  
  
  /***/ }),
  
  /***/ 27:
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  Object.defineProperty(__webpack_exports__, "__esModule", { value: true });
  /* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__babel_loader_node_modules_vue_loader_lib_selector_type_script_index_0_UiTooltip_vue__ = __webpack_require__(30);
  /* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__node_modules_vue_loader_lib_template_compiler_index_id_data_v_6cedb6f5_hasScoped_false_node_modules_vue_loader_lib_selector_type_template_index_0_UiTooltip_vue__ = __webpack_require__(35);
  var disposed = false
  function injectStyle (ssrContext) {
    if (disposed) return
    __webpack_require__(38)
  }
  var normalizeComponent = __webpack_require__(1)
  /* script */
  
  /* template */
  
  /* styles */
  var __vue_styles__ = injectStyle
  /* scopeId */
  var __vue_scopeId__ = null
  /* moduleIdentifier (server only) */
  var __vue_module_identifier__ = null
  var Component = normalizeComponent(
    __WEBPACK_IMPORTED_MODULE_0__babel_loader_node_modules_vue_loader_lib_selector_type_script_index_0_UiTooltip_vue__["a" /* default */],
    __WEBPACK_IMPORTED_MODULE_1__node_modules_vue_loader_lib_template_compiler_index_id_data_v_6cedb6f5_hasScoped_false_node_modules_vue_loader_lib_selector_type_template_index_0_UiTooltip_vue__["a" /* default */],
    __vue_styles__,
    __vue_scopeId__,
    __vue_module_identifier__
  )
  Component.options.__file = "src\\UiTooltip.vue"
  if (Component.esModule && Object.keys(Component.esModule).some(function (key) {return key !== "default" && key.substr(0, 2) !== "__"})) {console.error("named exports are not supported in *.vue files.")}
  if (Component.options.functional) {console.error("[vue-loader] UiTooltip.vue: functional components are not supported with templates, they should use render functions.")}
  
  /* hot reload */
  if (false) {(function () {
    var hotAPI = require("vue-hot-reload-api")
    hotAPI.install(require("vue"), false)
    if (!hotAPI.compatible) return
    module.hot.accept()
    if (!module.hot.data) {
      hotAPI.createRecord("data-v-6cedb6f5", Component.options)
    } else {
      hotAPI.reload("data-v-6cedb6f5", Component.options)
    }
    module.hot.dispose(function (data) {
      disposed = true
    })
  })()}
  
  /* harmony default export */ __webpack_exports__["default"] = Component.exports;
  
  
  /***/ }),
  
  /***/ 28:
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  /* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_tippy_js_esm__ = __webpack_require__(16);
  /* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__helpers_classlist__ = __webpack_require__(5);
  /* harmony import */ var __WEBPACK_IMPORTED_MODULE_2__helpers_element_ref__ = __webpack_require__(4);
  /* harmony import */ var __WEBPACK_IMPORTED_MODULE_3__helpers_events__ = __webpack_require__(25);
  /* harmony import */ var __WEBPACK_IMPORTED_MODULE_4__UiFocusContainer_vue__ = __webpack_require__(17);
  
  
  
  
  
  
  
  
  
  /* harmony default export */ __webpack_exports__["a"] = {
      name: 'ui-popover',
  
      props: {
          animation: {
              type: String,
              default: 'fade' },
          appendToBody: {
              type: Boolean,
              default: true
          },
          closeOnScroll: {
              type: Boolean,
              default: true
          },
          constrainToScrollParent: {
              type: Boolean,
              default: true
          },
          containFocus: {
              type: Boolean,
              default: false
          },
          disabled: {
              type: Boolean,
              default: false
          },
          focusRedirector: Function,
          openOn: {
              type: String,
              default: 'click' },
          position: {
              type: String,
              default: 'bottom-start'
          },
          raised: {
              type: Boolean,
              default: true
          },
          trigger: {
              validator: function validator(value) {
                  return __WEBPACK_IMPORTED_MODULE_2__helpers_element_ref__["a" /* default */].validate(value, '[UiPopover]: Invalid prop: "trigger". Expected Element, VueComponent or CSS selector string which matches an existing element.');
              }
          },
          zIndex: Number
      },
  
      data: function data() {
          return {
              returnFocus: true
          };
      },
  
  
      watch: {
          disabled: function disabled(value) {
              if (this.tip) {
                  if (value === true) {
                      this.tip.disable();
                  } else {
                      this.tip.enable();
                  }
              }
          }
      },
  
      created: function created() {
          this.tip = null;
      },
      mounted: function mounted() {
          this.setupPopover();
      },
      beforeDestroy: function beforeDestroy() {
          this.destroyPopover();
      },
  
  
      methods: {
          setupPopover: function setupPopover() {
              this.triggerEl = __WEBPACK_IMPORTED_MODULE_2__helpers_element_ref__["a" /* default */].resolve(this.trigger, this.$el.parentElement);
  
              if (!this.triggerEl) {
                  console.error('[UiPopover]: Trigger element not found.');
                  return;
              }
  
              var options = {
                  animateFill: false,
  
                  animation: this.animation === 'none' ? 'fade' : this.animation,
                  appendTo: this.appendToBody ? document.body : this.triggerEl.parentElement,
                  arrow: false,
                  content: this.$el,
                  delay: [0, 0],
                  distance: 0,
                  duration: this.animation === 'none' ? 0 : [250, 200],
                  hideOnClick: false,
                  ignoreAttributes: true,
                  interactive: true,
                  lazy: true,
                  maxWidth: '100%',
                  multiple: true,
                  onHidden: this.onHidden,
                  onHide: this.onClose,
                  onShow: this.onOpen,
                  onShown: this.onShown,
                  placement: this.position,
                  role: 'dialog',
                  theme: 'ui-popover',
                  trigger: this.openOn.replace('hover', 'mouseenter'),
                  zIndex: this.zIndex,
                  popperOptions: {
                      modifiers: {
                          computeStyle: {
                              gpuAcceleration: !(window.devicePixelRatio < 1.5 && /Win/.test(navigator.platform))
                          }
                      }
                  }
              };
  
              if (!this.constrainToScrollParent) {
                  options.popperOptions.modifiers.preventOverflow = { enabled: false };
                  options.popperOptions.modifiers.hide = { enabled: false };
              }
  
              this.tip = __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_0_tippy_js_esm__["a" /* default */])(this.triggerEl, options);
  
              if (this.disabled) {
                  this.tip.disable();
              }
          },
          destroyPopover: function destroyPopover() {
              if (this.tip) {
                  this.removeCloseEventListeners();
                  this.tip.destroy();
                  this.tip = null;
              }
          },
          isOpen: function isOpen() {
              return this.tip && this.tip.state.isVisible;
          },
          open: function open() {
              if (this.tip) {
                  this.tip.show();
              }
          },
          close: function close() {
              var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : { returnFocus: true };
  
              if (this.tip) {
                  this.returnFocus = options.returnFocus;
                  this.tip.hide();
              }
          },
          toggle: function toggle() {
              var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : { returnFocus: true };
  
              if (this.tip) {
                  this.returnFocus = options.returnFocus;
                  this.tip[this.isOpen() ? 'hide' : 'show']();
              }
          },
          scheduleUpdate: function scheduleUpdate() {
              if (this.tip) {
                  this.tip.popperInstance.scheduleUpdate();
              }
          },
          onOpen: function onOpen() {
              this.addCloseEventListeners();
  
              __WEBPACK_IMPORTED_MODULE_1__helpers_classlist__["a" /* default */].add(this.triggerEl, 'has-dropdown-open');
  
              this.$emit('open');
          },
          onClose: function onClose() {
              if (this.returnFocus && this.lastFocusedElement) {
                  this.lastFocusedElement.focus();
              }
  
              this.removeCloseEventListeners();
  
              __WEBPACK_IMPORTED_MODULE_1__helpers_classlist__["a" /* default */].remove(this.triggerEl, 'has-dropdown-open');
  
              this.$emit('close');
  
              this.returnFocus = true;
          },
          onShown: function onShown() {
              this.lastFocusedElement = document.activeElement;
              this.$refs.focusContainer.focus();
              this.$emit('reveal');
          },
          onHidden: function onHidden() {
              this.$emit('hide');
          },
          closeOnExternal: function closeOnExternal(event, closeOptions) {
              if (!this.$el.contains(event.target)) {
                  this.close(closeOptions);
              }
          },
          addCloseEventListeners: function addCloseEventListeners() {
              var _this = this;
  
              this.removeCloseEventListeners();
  
              setTimeout(function () {
                  _this.removeExternalClickListener = __WEBPACK_IMPORTED_MODULE_3__helpers_events__["a" /* default */].on('click', document, function (e) {
                      _this.closeOnExternal(e, { returnFocus: false });
                  });
  
                  _this.removeEscListener = __WEBPACK_IMPORTED_MODULE_3__helpers_events__["a" /* default */].onKeydown(27, document, function () {
                      _this.close({ returnFocus: true });
                  });
  
                  if (_this.closeOnScroll) {
                      _this.removeScrollListener = __WEBPACK_IMPORTED_MODULE_3__helpers_events__["a" /* default */].on('scroll', document, function (e) {
                          _this.closeOnExternal(e, { returnFocus: true });
                      });
                  }
              }, 0);
          },
          removeCloseEventListeners: function removeCloseEventListeners() {
              if (this.removeExternalClickListener) {
                  this.removeExternalClickListener();
                  this.removeExternalClickListener = null;
              }
  
              if (this.removeEscListener) {
                  this.removeEscListener();
                  this.removeEscListener = null;
              }
  
              if (this.removeScrollListener) {
                  this.removeScrollListener();
                  this.removeScrollListener = null;
              }
          }
      },
  
      components: {
          UiFocusContainer: __WEBPACK_IMPORTED_MODULE_4__UiFocusContainer_vue__["a" /* default */]
      }
  };
  
  /***/ }),
  
  /***/ 29:
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  
  
  /* harmony default export */ __webpack_exports__["a"] = {
      name: 'ui-progress-circular',
  
      props: {
          type: {
              type: String,
              default: 'indeterminate' },
          color: {
              type: String,
              default: 'primary' },
          progress: {
              type: Number,
              default: 0
          },
          size: {
              type: Number,
              default: 32
          },
          stroke: Number,
          autoStroke: {
              type: Boolean,
              default: true
          },
          disableTransition: {
              type: Boolean,
              default: false
          }
      },
  
      computed: {
          classes: function classes() {
              return ['ui-progress-circular--color-' + this.color, 'ui-progress-circular--type-' + this.type];
          },
          strokeDashArray: function strokeDashArray() {
              var circumference = 2 * Math.PI * this.radius;
  
              return Math.round(circumference * 1000) / 1000;
          },
          strokeDashOffset: function strokeDashOffset() {
              var progress = this.moderateProgress(this.progress);
              var circumference = 2 * Math.PI * this.radius;
  
              return (100 - progress) / 100 * circumference;
          },
          radius: function radius() {
              var stroke = this.stroke ? this.stroke : 4;
              return (this.size - stroke) / 2;
          },
          calculatedStroke: function calculatedStroke() {
              if (this.stroke) {
                  return this.stroke;
              }
  
              if (this.autoStroke) {
                  return parseInt(this.size / 8, 10);
              }
  
              return 4;
          }
      },
  
      methods: {
          moderateProgress: function moderateProgress(progress) {
              if (isNaN(progress) || progress < 0) {
                  return 0;
              }
  
              if (progress > 100) {
                  return 100;
              }
  
              return progress;
          }
      }
  };
  
  /***/ }),
  
  /***/ 3:
  /***/ (function(module, exports) {
  
  /**
   * Translates the list format produced by css-loader into something
   * easier to manipulate.
   */
  module.exports = function listToStyles (parentId, list) {
    var styles = []
    var newStyles = {}
    for (var i = 0; i < list.length; i++) {
      var item = list[i]
      var id = item[0]
      var css = item[1]
      var media = item[2]
      var sourceMap = item[3]
      var part = {
        id: parentId + ':' + i,
        css: css,
        media: media,
        sourceMap: sourceMap
      }
      if (!newStyles[id]) {
        styles.push(newStyles[id] = { id: id, parts: [part] })
      } else {
        newStyles[id].parts.push(part)
      }
    }
    return styles
  }
  
  
  /***/ }),
  
  /***/ 30:
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  /* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_tippy_js_esm__ = __webpack_require__(16);
  /* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__helpers_element_ref__ = __webpack_require__(4);
  
  
  
  
  
  /* harmony default export */ __webpack_exports__["a"] = {
      name: 'ui-tooltip',
  
      props: {
          animation: {
              type: String,
              default: 'fade' },
          appendToBody: {
              type: Boolean,
              default: true
          },
          openDelay: {
              type: Number,
              default: 0
          },
          openOn: {
              type: String,
              default: 'mouseenter focus' },
          position: {
              type: String,
              default: 'bottom' },
          trigger: {
              validator: function validator(value) {
                  return __WEBPACK_IMPORTED_MODULE_1__helpers_element_ref__["a" /* default */].validate(value, '[UiTooltip]: Invalid prop: "trigger". Expected Element, VueComponent or CSS selector string.');
              }
          },
          zIndex: Number
      },
  
      mounted: function mounted() {
          this.triggerEl = __WEBPACK_IMPORTED_MODULE_1__helpers_element_ref__["a" /* default */].resolve(this.trigger, this.$el.parentElement);
  
          if (!this.triggerEl) {
              console.error('[UiTooltip]: Trigger element not found.');
              return;
          }
  
          var options = {
              animateFill: this.animation !== 'fade',
  
              animation: this.animation === 'none' ? 'fade' : this.animation,
              arrow: false,
              content: this.$el,
              delay: [this.openDelay, 0],
              distance: 4,
              duration: this.animation === 'none' ? 0 : [250, 200],
              ignoreAttributes: true,
              lazy: true,
              multiple: true,
              placement: this.position,
              theme: 'ui-tooltip',
              trigger: this.openOn.replace('hover', 'mouseenter'),
              zIndex: this.zIndex,
              popperOptions: {
                  modifiers: {
                      computeStyle: {
                          gpuAcceleration: !(window.devicePixelRatio < 1.5 && /Win/.test(navigator.platform))
                      }
                  }
              }
          };
  
          if (!this.appendToBody) {
              options.appendTo = this.triggerEl.parentElement;
          }
  
          this.tip = __webpack_require__.i(__WEBPACK_IMPORTED_MODULE_0_tippy_js_esm__["a" /* default */])(this.triggerEl, options);
      },
      beforeDestroy: function beforeDestroy() {
          if (this.tip) {
              this.tip.destroy();
              this.tip = null;
          }
      }
  };
  
  /***/ }),
  
  /***/ 31:
  /***/ (function(module, exports, __webpack_require__) {
  
  exports = module.exports = __webpack_require__(0)();
  // imports
  
  
  // module
  exports.push([module.i, "\n.tippy-iOS {\n  cursor: pointer !important;\n  -webkit-tap-highlight-color: transparent;\n}\n.tippy-popper {\n  max-height: 100%;\n  max-width: 100%;\n  outline: 0;\n  pointer-events: none;\n  -webkit-transition-timing-function: cubic-bezier(0.165, 0.84, 0.44, 1);\n          transition-timing-function: cubic-bezier(0.165, 0.84, 0.44, 1);\n  z-index: 60;\n}\n.tippy-popper[x-placement^='top'] .tippy-backdrop {\n    border-radius: 40% 40% 0 0;\n}\n.tippy-popper[x-placement^='top'] .tippy-backdrop {\n    -webkit-transform-origin: 0% 25%;\n            transform-origin: 0% 25%;\n}\n.tippy-popper[x-placement^='top'] .tippy-backdrop[data-state='visible'] {\n      -webkit-transform: scale(1) translate(-50%, -55%);\n              transform: scale(1) translate(-50%, -55%);\n}\n.tippy-popper[x-placement^='top'] .tippy-backdrop[data-state='hidden'] {\n      -webkit-transform: scale(0.2) translate(-50%, -45%);\n              transform: scale(0.2) translate(-50%, -45%);\n      opacity: 0;\n}\n.tippy-popper[x-placement^='top'] [data-animation='fade'][data-state='visible'] {\n    -webkit-transform: translateY(-10px);\n            transform: translateY(-10px);\n}\n.tippy-popper[x-placement^='top'] [data-animation='fade'][data-state='hidden'] {\n    opacity: 0;\n    -webkit-transform: translateY(-10px);\n            transform: translateY(-10px);\n}\n.tippy-popper[x-placement^='top'] [data-animation='shift-away'][data-state='visible'] {\n    -webkit-transform: translateY(-10px);\n            transform: translateY(-10px);\n}\n.tippy-popper[x-placement^='top'] [data-animation='shift-away'][data-state='hidden'] {\n    opacity: 0;\n    -webkit-transform: translateY(0);\n            transform: translateY(0);\n}\n.tippy-popper[x-placement^='top'] [data-animation='scale'] {\n    -webkit-transform-origin: bottom;\n            transform-origin: bottom;\n}\n.tippy-popper[x-placement^='top'] [data-animation='scale'][data-state='visible'] {\n      -webkit-transform: translateY(-10px) scale(1);\n              transform: translateY(-10px) scale(1);\n}\n.tippy-popper[x-placement^='top'] [data-animation='scale'][data-state='hidden'] {\n      opacity: 0;\n      -webkit-transform: translateY(-10px) scale(0.5);\n              transform: translateY(-10px) scale(0.5);\n}\n.tippy-popper[x-placement^='bottom'] .tippy-backdrop {\n    border-radius: 0 0 30% 30%;\n}\n.tippy-popper[x-placement^='bottom'] .tippy-backdrop {\n    -webkit-transform-origin: 0% -50%;\n            transform-origin: 0% -50%;\n}\n.tippy-popper[x-placement^='bottom'] .tippy-backdrop[data-state='visible'] {\n      -webkit-transform: scale(1) translate(-50%, -45%);\n              transform: scale(1) translate(-50%, -45%);\n}\n.tippy-popper[x-placement^='bottom'] .tippy-backdrop[data-state='hidden'] {\n      -webkit-transform: scale(0.2) translate(-50%, 0);\n              transform: scale(0.2) translate(-50%, 0);\n      opacity: 0;\n}\n.tippy-popper[x-placement^='bottom'] [data-animation='fade'][data-state='visible'] {\n    -webkit-transform: translateY(10px);\n            transform: translateY(10px);\n}\n.tippy-popper[x-placement^='bottom'] [data-animation='fade'][data-state='hidden'] {\n    opacity: 0;\n    -webkit-transform: translateY(10px);\n            transform: translateY(10px);\n}\n.tippy-popper[x-placement^='bottom'] [data-animation='shift-away'][data-state='visible'] {\n    -webkit-transform: translateY(10px);\n            transform: translateY(10px);\n}\n.tippy-popper[x-placement^='bottom'] [data-animation='shift-away'][data-state='hidden'] {\n    opacity: 0;\n    -webkit-transform: translateY(0);\n            transform: translateY(0);\n}\n.tippy-popper[x-placement^='bottom'] [data-animation='scale'] {\n    -webkit-transform-origin: top;\n            transform-origin: top;\n}\n.tippy-popper[x-placement^='bottom'] [data-animation='scale'][data-state='visible'] {\n      -webkit-transform: translateY(10px) scale(1);\n              transform: translateY(10px) scale(1);\n}\n.tippy-popper[x-placement^='bottom'] [data-animation='scale'][data-state='hidden'] {\n      opacity: 0;\n      -webkit-transform: translateY(10px) scale(0.5);\n              transform: translateY(10px) scale(0.5);\n}\n.tippy-popper[x-placement^='left'] .tippy-backdrop {\n    border-radius: 50% 0 0 50%;\n}\n.tippy-popper[x-placement^='left'] .tippy-backdrop {\n    -webkit-transform-origin: 50% 0%;\n            transform-origin: 50% 0%;\n}\n.tippy-popper[x-placement^='left'] .tippy-backdrop[data-state='visible'] {\n      -webkit-transform: scale(1) translate(-50%, -50%);\n              transform: scale(1) translate(-50%, -50%);\n}\n.tippy-popper[x-placement^='left'] .tippy-backdrop[data-state='hidden'] {\n      -webkit-transform: scale(0.2) translate(-75%, -50%);\n              transform: scale(0.2) translate(-75%, -50%);\n      opacity: 0;\n}\n.tippy-popper[x-placement^='left'] [data-animation='fade'][data-state='visible'] {\n    -webkit-transform: translateX(-10px);\n            transform: translateX(-10px);\n}\n.tippy-popper[x-placement^='left'] [data-animation='fade'][data-state='hidden'] {\n    opacity: 0;\n    -webkit-transform: translateX(-10px);\n            transform: translateX(-10px);\n}\n.tippy-popper[x-placement^='left'] [data-animation='shift-away'][data-state='visible'] {\n    -webkit-transform: translateX(-10px);\n            transform: translateX(-10px);\n}\n.tippy-popper[x-placement^='left'] [data-animation='shift-away'][data-state='hidden'] {\n    opacity: 0;\n    -webkit-transform: translateX(0);\n            transform: translateX(0);\n}\n.tippy-popper[x-placement^='left'] [data-animation='scale'] {\n    -webkit-transform-origin: right;\n            transform-origin: right;\n}\n.tippy-popper[x-placement^='left'] [data-animation='scale'][data-state='visible'] {\n      -webkit-transform: translateX(-10px) scale(1);\n              transform: translateX(-10px) scale(1);\n}\n.tippy-popper[x-placement^='left'] [data-animation='scale'][data-state='hidden'] {\n      opacity: 0;\n      -webkit-transform: translateX(-10px) scale(0.5);\n              transform: translateX(-10px) scale(0.5);\n}\n.tippy-popper[x-placement^='right'] .tippy-backdrop {\n    border-radius: 0 50% 50% 0;\n}\n.tippy-popper[x-placement^='right'] .tippy-backdrop {\n    -webkit-transform-origin: -50% 0%;\n            transform-origin: -50% 0%;\n}\n.tippy-popper[x-placement^='right'] .tippy-backdrop[data-state='visible'] {\n      -webkit-transform: scale(1) translate(-50%, -50%);\n              transform: scale(1) translate(-50%, -50%);\n}\n.tippy-popper[x-placement^='right'] .tippy-backdrop[data-state='hidden'] {\n      -webkit-transform: scale(0.2) translate(-25%, -50%);\n              transform: scale(0.2) translate(-25%, -50%);\n      opacity: 0;\n}\n.tippy-popper[x-placement^='right'] [data-animation='fade'][data-state='visible'] {\n    -webkit-transform: translateX(10px);\n            transform: translateX(10px);\n}\n.tippy-popper[x-placement^='right'] [data-animation='fade'][data-state='hidden'] {\n    opacity: 0;\n    -webkit-transform: translateX(10px);\n            transform: translateX(10px);\n}\n.tippy-popper[x-placement^='right'] [data-animation='shift-away'][data-state='visible'] {\n    -webkit-transform: translateX(10px);\n            transform: translateX(10px);\n}\n.tippy-popper[x-placement^='right'] [data-animation='shift-away'][data-state='hidden'] {\n    opacity: 0;\n    -webkit-transform: translateX(0);\n            transform: translateX(0);\n}\n.tippy-popper[x-placement^='right'] [data-animation='scale'] {\n    -webkit-transform-origin: left;\n            transform-origin: left;\n}\n.tippy-popper[x-placement^='right'] [data-animation='scale'][data-state='visible'] {\n      -webkit-transform: translateX(10px) scale(1);\n              transform: translateX(10px) scale(1);\n}\n.tippy-popper[x-placement^='right'] [data-animation='scale'][data-state='hidden'] {\n      opacity: 0;\n      -webkit-transform: translateX(10px) scale(0.5);\n              transform: translateX(10px) scale(0.5);\n}\n.tippy-tooltip {\n  position: relative;\n  -webkit-font-smoothing: antialiased;\n  -moz-osx-font-smoothing: grayscale;\n}\n.tippy-tooltip[data-animatefill] {\n    overflow: hidden;\n    background-color: transparent;\n}\n.tippy-tooltip[data-interactive] {\n    pointer-events: auto;\n}\n.tippy-tooltip[data-interactive] path {\n      pointer-events: auto;\n}\n.tippy-backdrop {\n  position: absolute;\n  border-radius: 50%;\n  width: calc(110% + 2rem);\n  left: 50%;\n  top: 50%;\n  z-index: -1;\n  -webkit-transition: all cubic-bezier(0.46, 0.1, 0.52, 0.98);\n  transition: all cubic-bezier(0.46, 0.1, 0.52, 0.98);\n  -webkit-backface-visibility: hidden;\n          backface-visibility: hidden;\n}\n.tippy-backdrop::after {\n    content: '';\n    float: left;\n    padding-top: 100%;\n}\n.tippy-backdrop + .tippy-content {\n  -webkit-transition-property: opacity;\n  transition-property: opacity;\n  will-change: opacity;\n}\n.tippy-backdrop + .tippy-content[data-state='visible'] {\n    opacity: 1;\n}\n.tippy-backdrop + .tippy-content[data-state='hidden'] {\n    opacity: 0;\n}\n.ui-popover.is-raised {\n  box-shadow: 0 2px 4px -1px rgba(0, 0, 0, 0.2), 0 4px 5px 0 rgba(0, 0, 0, 0.14), 0 1px 10px 0 rgba(0, 0, 0, 0.12);\n}\n.ui-popover .ui-menu {\n  border: none;\n}\n.ui-popover-theme {\n  background-color: white;\n}\n", ""]);
  
  // exports
  
  
  /***/ }),
  
  /***/ 32:
  /***/ (function(module, exports, __webpack_require__) {
  
  exports = module.exports = __webpack_require__(0)();
  // imports
  
  
  // module
  exports.push([module.i, "\n.tippy-iOS {\n  cursor: pointer !important;\n  -webkit-tap-highlight-color: transparent;\n}\n.tippy-popper {\n  max-height: 100%;\n  max-width: 100%;\n  outline: 0;\n  pointer-events: none;\n  -webkit-transition-timing-function: cubic-bezier(0.165, 0.84, 0.44, 1);\n          transition-timing-function: cubic-bezier(0.165, 0.84, 0.44, 1);\n  z-index: 60;\n}\n.tippy-popper[x-placement^='top'] .tippy-backdrop {\n    border-radius: 40% 40% 0 0;\n}\n.tippy-popper[x-placement^='top'] .tippy-backdrop {\n    -webkit-transform-origin: 0% 25%;\n            transform-origin: 0% 25%;\n}\n.tippy-popper[x-placement^='top'] .tippy-backdrop[data-state='visible'] {\n      -webkit-transform: scale(1) translate(-50%, -55%);\n              transform: scale(1) translate(-50%, -55%);\n}\n.tippy-popper[x-placement^='top'] .tippy-backdrop[data-state='hidden'] {\n      -webkit-transform: scale(0.2) translate(-50%, -45%);\n              transform: scale(0.2) translate(-50%, -45%);\n      opacity: 0;\n}\n.tippy-popper[x-placement^='top'] [data-animation='fade'][data-state='visible'] {\n    -webkit-transform: translateY(-10px);\n            transform: translateY(-10px);\n}\n.tippy-popper[x-placement^='top'] [data-animation='fade'][data-state='hidden'] {\n    opacity: 0;\n    -webkit-transform: translateY(-10px);\n            transform: translateY(-10px);\n}\n.tippy-popper[x-placement^='top'] [data-animation='shift-away'][data-state='visible'] {\n    -webkit-transform: translateY(-10px);\n            transform: translateY(-10px);\n}\n.tippy-popper[x-placement^='top'] [data-animation='shift-away'][data-state='hidden'] {\n    opacity: 0;\n    -webkit-transform: translateY(0);\n            transform: translateY(0);\n}\n.tippy-popper[x-placement^='top'] [data-animation='scale'] {\n    -webkit-transform-origin: bottom;\n            transform-origin: bottom;\n}\n.tippy-popper[x-placement^='top'] [data-animation='scale'][data-state='visible'] {\n      -webkit-transform: translateY(-10px) scale(1);\n              transform: translateY(-10px) scale(1);\n}\n.tippy-popper[x-placement^='top'] [data-animation='scale'][data-state='hidden'] {\n      opacity: 0;\n      -webkit-transform: translateY(-10px) scale(0.5);\n              transform: translateY(-10px) scale(0.5);\n}\n.tippy-popper[x-placement^='bottom'] .tippy-backdrop {\n    border-radius: 0 0 30% 30%;\n}\n.tippy-popper[x-placement^='bottom'] .tippy-backdrop {\n    -webkit-transform-origin: 0% -50%;\n            transform-origin: 0% -50%;\n}\n.tippy-popper[x-placement^='bottom'] .tippy-backdrop[data-state='visible'] {\n      -webkit-transform: scale(1) translate(-50%, -45%);\n              transform: scale(1) translate(-50%, -45%);\n}\n.tippy-popper[x-placement^='bottom'] .tippy-backdrop[data-state='hidden'] {\n      -webkit-transform: scale(0.2) translate(-50%, 0);\n              transform: scale(0.2) translate(-50%, 0);\n      opacity: 0;\n}\n.tippy-popper[x-placement^='bottom'] [data-animation='fade'][data-state='visible'] {\n    -webkit-transform: translateY(10px);\n            transform: translateY(10px);\n}\n.tippy-popper[x-placement^='bottom'] [data-animation='fade'][data-state='hidden'] {\n    opacity: 0;\n    -webkit-transform: translateY(10px);\n            transform: translateY(10px);\n}\n.tippy-popper[x-placement^='bottom'] [data-animation='shift-away'][data-state='visible'] {\n    -webkit-transform: translateY(10px);\n            transform: translateY(10px);\n}\n.tippy-popper[x-placement^='bottom'] [data-animation='shift-away'][data-state='hidden'] {\n    opacity: 0;\n    -webkit-transform: translateY(0);\n            transform: translateY(0);\n}\n.tippy-popper[x-placement^='bottom'] [data-animation='scale'] {\n    -webkit-transform-origin: top;\n            transform-origin: top;\n}\n.tippy-popper[x-placement^='bottom'] [data-animation='scale'][data-state='visible'] {\n      -webkit-transform: translateY(10px) scale(1);\n              transform: translateY(10px) scale(1);\n}\n.tippy-popper[x-placement^='bottom'] [data-animation='scale'][data-state='hidden'] {\n      opacity: 0;\n      -webkit-transform: translateY(10px) scale(0.5);\n              transform: translateY(10px) scale(0.5);\n}\n.tippy-popper[x-placement^='left'] .tippy-backdrop {\n    border-radius: 50% 0 0 50%;\n}\n.tippy-popper[x-placement^='left'] .tippy-backdrop {\n    -webkit-transform-origin: 50% 0%;\n            transform-origin: 50% 0%;\n}\n.tippy-popper[x-placement^='left'] .tippy-backdrop[data-state='visible'] {\n      -webkit-transform: scale(1) translate(-50%, -50%);\n              transform: scale(1) translate(-50%, -50%);\n}\n.tippy-popper[x-placement^='left'] .tippy-backdrop[data-state='hidden'] {\n      -webkit-transform: scale(0.2) translate(-75%, -50%);\n              transform: scale(0.2) translate(-75%, -50%);\n      opacity: 0;\n}\n.tippy-popper[x-placement^='left'] [data-animation='fade'][data-state='visible'] {\n    -webkit-transform: translateX(-10px);\n            transform: translateX(-10px);\n}\n.tippy-popper[x-placement^='left'] [data-animation='fade'][data-state='hidden'] {\n    opacity: 0;\n    -webkit-transform: translateX(-10px);\n            transform: translateX(-10px);\n}\n.tippy-popper[x-placement^='left'] [data-animation='shift-away'][data-state='visible'] {\n    -webkit-transform: translateX(-10px);\n            transform: translateX(-10px);\n}\n.tippy-popper[x-placement^='left'] [data-animation='shift-away'][data-state='hidden'] {\n    opacity: 0;\n    -webkit-transform: translateX(0);\n            transform: translateX(0);\n}\n.tippy-popper[x-placement^='left'] [data-animation='scale'] {\n    -webkit-transform-origin: right;\n            transform-origin: right;\n}\n.tippy-popper[x-placement^='left'] [data-animation='scale'][data-state='visible'] {\n      -webkit-transform: translateX(-10px) scale(1);\n              transform: translateX(-10px) scale(1);\n}\n.tippy-popper[x-placement^='left'] [data-animation='scale'][data-state='hidden'] {\n      opacity: 0;\n      -webkit-transform: translateX(-10px) scale(0.5);\n              transform: translateX(-10px) scale(0.5);\n}\n.tippy-popper[x-placement^='right'] .tippy-backdrop {\n    border-radius: 0 50% 50% 0;\n}\n.tippy-popper[x-placement^='right'] .tippy-backdrop {\n    -webkit-transform-origin: -50% 0%;\n            transform-origin: -50% 0%;\n}\n.tippy-popper[x-placement^='right'] .tippy-backdrop[data-state='visible'] {\n      -webkit-transform: scale(1) translate(-50%, -50%);\n              transform: scale(1) translate(-50%, -50%);\n}\n.tippy-popper[x-placement^='right'] .tippy-backdrop[data-state='hidden'] {\n      -webkit-transform: scale(0.2) translate(-25%, -50%);\n              transform: scale(0.2) translate(-25%, -50%);\n      opacity: 0;\n}\n.tippy-popper[x-placement^='right'] [data-animation='fade'][data-state='visible'] {\n    -webkit-transform: translateX(10px);\n            transform: translateX(10px);\n}\n.tippy-popper[x-placement^='right'] [data-animation='fade'][data-state='hidden'] {\n    opacity: 0;\n    -webkit-transform: translateX(10px);\n            transform: translateX(10px);\n}\n.tippy-popper[x-placement^='right'] [data-animation='shift-away'][data-state='visible'] {\n    -webkit-transform: translateX(10px);\n            transform: translateX(10px);\n}\n.tippy-popper[x-placement^='right'] [data-animation='shift-away'][data-state='hidden'] {\n    opacity: 0;\n    -webkit-transform: translateX(0);\n            transform: translateX(0);\n}\n.tippy-popper[x-placement^='right'] [data-animation='scale'] {\n    -webkit-transform-origin: left;\n            transform-origin: left;\n}\n.tippy-popper[x-placement^='right'] [data-animation='scale'][data-state='visible'] {\n      -webkit-transform: translateX(10px) scale(1);\n              transform: translateX(10px) scale(1);\n}\n.tippy-popper[x-placement^='right'] [data-animation='scale'][data-state='hidden'] {\n      opacity: 0;\n      -webkit-transform: translateX(10px) scale(0.5);\n              transform: translateX(10px) scale(0.5);\n}\n.tippy-tooltip {\n  position: relative;\n  -webkit-font-smoothing: antialiased;\n  -moz-osx-font-smoothing: grayscale;\n}\n.tippy-tooltip[data-animatefill] {\n    overflow: hidden;\n    background-color: transparent;\n}\n.tippy-tooltip[data-interactive] {\n    pointer-events: auto;\n}\n.tippy-tooltip[data-interactive] path {\n      pointer-events: auto;\n}\n.tippy-backdrop {\n  position: absolute;\n  border-radius: 50%;\n  width: calc(110% + 2rem);\n  left: 50%;\n  top: 50%;\n  z-index: -1;\n  -webkit-transition: all cubic-bezier(0.46, 0.1, 0.52, 0.98);\n  transition: all cubic-bezier(0.46, 0.1, 0.52, 0.98);\n  -webkit-backface-visibility: hidden;\n          backface-visibility: hidden;\n}\n.tippy-backdrop::after {\n    content: '';\n    float: left;\n    padding-top: 100%;\n}\n.tippy-backdrop + .tippy-content {\n  -webkit-transition-property: opacity;\n  transition-property: opacity;\n  will-change: opacity;\n}\n.tippy-backdrop + .tippy-content[data-state='visible'] {\n    opacity: 1;\n}\n.tippy-backdrop + .tippy-content[data-state='hidden'] {\n    opacity: 0;\n}\n.ui-tooltip-theme {\n  background-color: rgba(33, 33, 33, 0.9);\n  border-radius: 0.125rem;\n  color: white;\n  font-size: 0.8125rem;\n  line-height: 1.4;\n  padding: 0.3rem 0.5rem;\n  text-align: center;\n}\n.ui-tooltip-theme .tippy-backdrop {\n    background-color: rgba(33, 33, 33, 0.9);\n}\n", ""]);
  
  // exports
  
  
  /***/ }),
  
  /***/ 33:
  /***/ (function(module, exports, __webpack_require__) {
  
  exports = module.exports = __webpack_require__(0)();
  // imports
  
  
  // module
  exports.push([module.i, "\n.ui-progress-circular {\n  position: relative;\n}\n.ui-progress-circular__determinate {\n  -webkit-transform: rotate(270deg);\n          transform: rotate(270deg);\n}\n.ui-progress-circular__determinate-path {\n  stroke-dashoffset: 0;\n  -webkit-transition: stroke-dashoffset 0.3s;\n  transition: stroke-dashoffset 0.3s;\n}\n.ui-progress-circular__indeterminate {\n  -webkit-animation: ui-progress-circular-rotate 0.7s linear infinite;\n          animation: ui-progress-circular-rotate 0.7s linear infinite;\n  bottom: 0;\n  height: 100%;\n  left: 0;\n  margin: auto;\n  position: absolute;\n  right: 0;\n  top: 0;\n  -webkit-transform-origin: center center;\n          transform-origin: center center;\n  width: 100%;\n}\n.ui-progress-circular__indeterminate-path {\n  stroke-dasharray: 89,200;\n  stroke-dashoffset: -35px;\n  stroke-linecap: round;\n}\n.ui-progress-circular--color-multi-color .ui-progress-circular__determinate-path {\n  stroke: #2196f3;\n}\n.ui-progress-circular--color-multi-color .ui-progress-circular__indeterminate-path {\n  -webkit-animation: ui-progress-circular-color 6s ease-in-out infinite;\n          animation: ui-progress-circular-color 6s ease-in-out infinite;\n}\n.ui-progress-circular--color-primary .ui-progress-circular__determinate-path,\n.ui-progress-circular--color-primary .ui-progress-circular__indeterminate-path {\n  stroke: #2196f3;\n}\n.ui-progress-circular--color-accent .ui-progress-circular__determinate-path,\n.ui-progress-circular--color-accent .ui-progress-circular__indeterminate-path {\n  stroke: #d500f9;\n}\n.ui-progress-circular--color-black .ui-progress-circular__determinate-path,\n.ui-progress-circular--color-black .ui-progress-circular__indeterminate-path {\n  stroke: #212121;\n}\n.ui-progress-circular--color-white .ui-progress-circular__determinate-path,\n.ui-progress-circular--color-white .ui-progress-circular__indeterminate-path {\n  stroke: white;\n}\n.ui-progress-circular--transition-fade-enter-active,\n.ui-progress-circular--transition-fade-leave-active {\n  -webkit-transition: opacity 0.3s ease, -webkit-transform 0.3s ease;\n  transition: opacity 0.3s ease, -webkit-transform 0.3s ease;\n  transition: opacity 0.3s ease, transform 0.3s ease;\n  transition: opacity 0.3s ease, transform 0.3s ease, -webkit-transform 0.3s ease;\n}\n.ui-progress-circular--transition-fade-enter,\n.ui-progress-circular--transition-fade-leave-active {\n  opacity: 0;\n  -webkit-transform: scale(0);\n          transform: scale(0);\n}\n@-webkit-keyframes ui-progress-circular-rotate {\n100% {\n    -webkit-transform: rotate(360deg);\n            transform: rotate(360deg);\n}\n}\n@keyframes ui-progress-circular-rotate {\n100% {\n    -webkit-transform: rotate(360deg);\n            transform: rotate(360deg);\n}\n}\n@-webkit-keyframes ui-progress-circular-color {\n0%,\n  100% {\n    stroke: #f44336;\n}\n40% {\n    stroke: #2196f3;\n}\n66% {\n    stroke: #4caf50;\n}\n80%,\n  90% {\n    stroke: #ff9800;\n}\n}\n@keyframes ui-progress-circular-color {\n0%,\n  100% {\n    stroke: #f44336;\n}\n40% {\n    stroke: #2196f3;\n}\n66% {\n    stroke: #4caf50;\n}\n80%,\n  90% {\n    stroke: #ff9800;\n}\n}\n", ""]);
  
  // exports
  
  
  /***/ }),
  
  /***/ 34:
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  var render = function () {var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;
    return _c('ui-focus-container', {
      ref: "focusContainer",
      staticClass: "ui-popover",
      class: {
        'is-raised': _vm.raised
      },
      attrs: {
        "role": "dialog",
        "contain-focus": _vm.containFocus,
        "focus-redirector": _vm.focusRedirector
      },
      on: {
        "focus-overflow": function($event) {
          _vm.close()
        }
      }
    }, [_vm._t("default")], 2)
  }
  var staticRenderFns = []
  render._withStripped = true
  var esExports = { render: render, staticRenderFns: staticRenderFns }
  /* harmony default export */ __webpack_exports__["a"] = esExports;
  if (false) {
    module.hot.accept()
    if (module.hot.data) {
       require("vue-hot-reload-api").rerender("data-v-48582497", esExports)
    }
  }
  
  /***/ }),
  
  /***/ 35:
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  var render = function () {var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;
    return _c('div', {
      staticClass: "ui-tooltip"
    }, [_vm._t("default")], 2)
  }
  var staticRenderFns = []
  render._withStripped = true
  var esExports = { render: render, staticRenderFns: staticRenderFns }
  /* harmony default export */ __webpack_exports__["a"] = esExports;
  if (false) {
    module.hot.accept()
    if (module.hot.data) {
       require("vue-hot-reload-api").rerender("data-v-6cedb6f5", esExports)
    }
  }
  
  /***/ }),
  
  /***/ 36:
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  var render = function () {var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;
    return _c('transition', {
      attrs: {
        "name": _vm.disableTransition ? null : 'ui-progress-circular--transition-fade'
      }
    }, [_c('div', {
      staticClass: "ui-progress-circular",
      class: _vm.classes,
      style: ({
        'width': _vm.size + 'px',
        'height': _vm.size + 'px'
      })
    }, [(_vm.type === 'determinate') ? _c('svg', {
      staticClass: "ui-progress-circular__determinate",
      attrs: {
        "role": "progressbar",
        "aria-valuemax": 100,
        "aria-valuemin": 0,
        "aria-valuenow": _vm.progress,
        "height": _vm.size,
        "width": _vm.size
      }
    }, [_c('circle', {
      staticClass: "ui-progress-circular__determinate-path",
      style: ({
        'stroke-dashoffset': _vm.strokeDashOffset,
        'stroke-width': _vm.calculatedStroke
      }),
      attrs: {
        "fill": "transparent",
        "stroke-dashoffset": "0",
        "cx": _vm.size / 2,
        "cy": _vm.size / 2,
        "r": _vm.radius,
        "stroke-dasharray": _vm.strokeDashArray
      }
    })]) : _c('svg', {
      staticClass: "ui-progress-circular__indeterminate",
      attrs: {
        "role": "progressbar",
        "viewBox": "25 25 50 50",
        "aria-valuemax": 100,
        "aria-valuemin": 0
      }
    }, [_c('circle', {
      staticClass: "ui-progress-circular__indeterminate-path",
      attrs: {
        "cx": "50",
        "cy": "50",
        "fill": "none",
        "r": "20",
        "stroke-miterlimit": "10",
        "stroke-width": _vm.calculatedStroke
      }
    })])])])
  }
  var staticRenderFns = []
  render._withStripped = true
  var esExports = { render: render, staticRenderFns: staticRenderFns }
  /* harmony default export */ __webpack_exports__["a"] = esExports;
  if (false) {
    module.hot.accept()
    if (module.hot.data) {
       require("vue-hot-reload-api").rerender("data-v-7bea93ea", esExports)
    }
  }
  
  /***/ }),
  
  /***/ 37:
  /***/ (function(module, exports, __webpack_require__) {
  
  // style-loader: Adds some css to the DOM by adding a <style> tag
  
  // load the styles
  var content = __webpack_require__(31);
  if(typeof content === 'string') content = [[module.i, content, '']];
  if(content.locals) module.exports = content.locals;
  // add the styles to the DOM
  var update = __webpack_require__(2)("4ef68e70", content, false);
  // Hot Module Replacement
  if(false) {
   // When the styles change, update the <style> tags
   if(!content.locals) {
     module.hot.accept("!!../node_modules/css-loader/index.js!../node_modules/vue-loader/lib/style-compiler/index.js?{\"vue\":true,\"id\":\"data-v-48582497\",\"scoped\":false,\"hasInlineConfig\":true}!../node_modules/sass-loader/index.js!../node_modules/vue-loader/lib/selector.js?type=styles&index=0!./UiPopover.vue", function() {
       var newContent = require("!!../node_modules/css-loader/index.js!../node_modules/vue-loader/lib/style-compiler/index.js?{\"vue\":true,\"id\":\"data-v-48582497\",\"scoped\":false,\"hasInlineConfig\":true}!../node_modules/sass-loader/index.js!../node_modules/vue-loader/lib/selector.js?type=styles&index=0!./UiPopover.vue");
       if(typeof newContent === 'string') newContent = [[module.id, newContent, '']];
       update(newContent);
     });
   }
   // When the module is disposed, remove the <style> tags
   module.hot.dispose(function() { update(); });
  }
  
  /***/ }),
  
  /***/ 38:
  /***/ (function(module, exports, __webpack_require__) {
  
  // style-loader: Adds some css to the DOM by adding a <style> tag
  
  // load the styles
  var content = __webpack_require__(32);
  if(typeof content === 'string') content = [[module.i, content, '']];
  if(content.locals) module.exports = content.locals;
  // add the styles to the DOM
  var update = __webpack_require__(2)("f692fb8c", content, false);
  // Hot Module Replacement
  if(false) {
   // When the styles change, update the <style> tags
   if(!content.locals) {
     module.hot.accept("!!../node_modules/css-loader/index.js!../node_modules/vue-loader/lib/style-compiler/index.js?{\"vue\":true,\"id\":\"data-v-6cedb6f5\",\"scoped\":false,\"hasInlineConfig\":true}!../node_modules/sass-loader/index.js!../node_modules/vue-loader/lib/selector.js?type=styles&index=0!./UiTooltip.vue", function() {
       var newContent = require("!!../node_modules/css-loader/index.js!../node_modules/vue-loader/lib/style-compiler/index.js?{\"vue\":true,\"id\":\"data-v-6cedb6f5\",\"scoped\":false,\"hasInlineConfig\":true}!../node_modules/sass-loader/index.js!../node_modules/vue-loader/lib/selector.js?type=styles&index=0!./UiTooltip.vue");
       if(typeof newContent === 'string') newContent = [[module.id, newContent, '']];
       update(newContent);
     });
   }
   // When the module is disposed, remove the <style> tags
   module.hot.dispose(function() { update(); });
  }
  
  /***/ }),
  
  /***/ 39:
  /***/ (function(module, exports, __webpack_require__) {
  
  // style-loader: Adds some css to the DOM by adding a <style> tag
  
  // load the styles
  var content = __webpack_require__(33);
  if(typeof content === 'string') content = [[module.i, content, '']];
  if(content.locals) module.exports = content.locals;
  // add the styles to the DOM
  var update = __webpack_require__(2)("ad140786", content, false);
  // Hot Module Replacement
  if(false) {
   // When the styles change, update the <style> tags
   if(!content.locals) {
     module.hot.accept("!!../node_modules/css-loader/index.js!../node_modules/vue-loader/lib/style-compiler/index.js?{\"vue\":true,\"id\":\"data-v-7bea93ea\",\"scoped\":false,\"hasInlineConfig\":true}!../node_modules/sass-loader/index.js!../node_modules/vue-loader/lib/selector.js?type=styles&index=0!./UiProgressCircular.vue", function() {
       var newContent = require("!!../node_modules/css-loader/index.js!../node_modules/vue-loader/lib/style-compiler/index.js?{\"vue\":true,\"id\":\"data-v-7bea93ea\",\"scoped\":false,\"hasInlineConfig\":true}!../node_modules/sass-loader/index.js!../node_modules/vue-loader/lib/selector.js?type=styles&index=0!./UiProgressCircular.vue");
       if(typeof newContent === 'string') newContent = [[module.id, newContent, '']];
       update(newContent);
     });
   }
   // When the module is disposed, remove the <style> tags
   module.hot.dispose(function() { update(); });
  }
  
  /***/ }),
  
  /***/ 4:
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  /* unused harmony export validate */
  /* unused harmony export resolve */
  function validate(ref, warning) {
      var isValid = ref instanceof Element || ref && ref._isVue || typeof ref === 'string';
  
      if (!isValid && warning) {
          console.warn(warning);
      }
  
      return isValid;
  }
  
  function resolve(ref, fallback) {
      if (ref instanceof Element) {
          return ref;
      } else if (ref && ref._isVue) {
          return ref.$el;
      } else if (typeof ref === 'string') {
          return document.querySelector(ref);
      }
  
      return fallback;
  }
  
  /* harmony default export */ __webpack_exports__["a"] = {
      validate: validate,
      resolve: resolve
  };
  
  /***/ }),
  
  /***/ 43:
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  Object.defineProperty(__webpack_exports__, "__esModule", { value: true });
  /* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__babel_loader_node_modules_vue_loader_lib_selector_type_script_index_0_UiIconButton_vue__ = __webpack_require__(46);
  /* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__node_modules_vue_loader_lib_template_compiler_index_id_data_v_9db4dbee_hasScoped_false_node_modules_vue_loader_lib_selector_type_template_index_0_UiIconButton_vue__ = __webpack_require__(52);
  var disposed = false
  function injectStyle (ssrContext) {
    if (disposed) return
    __webpack_require__(55)
  }
  var normalizeComponent = __webpack_require__(1)
  /* script */
  
  /* template */
  
  /* styles */
  var __vue_styles__ = injectStyle
  /* scopeId */
  var __vue_scopeId__ = null
  /* moduleIdentifier (server only) */
  var __vue_module_identifier__ = null
  var Component = normalizeComponent(
    __WEBPACK_IMPORTED_MODULE_0__babel_loader_node_modules_vue_loader_lib_selector_type_script_index_0_UiIconButton_vue__["a" /* default */],
    __WEBPACK_IMPORTED_MODULE_1__node_modules_vue_loader_lib_template_compiler_index_id_data_v_9db4dbee_hasScoped_false_node_modules_vue_loader_lib_selector_type_template_index_0_UiIconButton_vue__["a" /* default */],
    __vue_styles__,
    __vue_scopeId__,
    __vue_module_identifier__
  )
  Component.options.__file = "src\\UiIconButton.vue"
  if (Component.esModule && Object.keys(Component.esModule).some(function (key) {return key !== "default" && key.substr(0, 2) !== "__"})) {console.error("named exports are not supported in *.vue files.")}
  if (Component.options.functional) {console.error("[vue-loader] UiIconButton.vue: functional components are not supported with templates, they should use render functions.")}
  
  /* hot reload */
  if (false) {(function () {
    var hotAPI = require("vue-hot-reload-api")
    hotAPI.install(require("vue"), false)
    if (!hotAPI.compatible) return
    module.hot.accept()
    if (!module.hot.data) {
      hotAPI.createRecord("data-v-9db4dbee", Component.options)
    } else {
      hotAPI.reload("data-v-9db4dbee", Component.options)
    }
    module.hot.dispose(function (data) {
      disposed = true
    })
  })()}
  
  /* harmony default export */ __webpack_exports__["default"] = Component.exports;
  
  
  /***/ }),
  
  /***/ 46:
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  /* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__UiIcon_vue__ = __webpack_require__(6);
  /* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__UiPopover_vue__ = __webpack_require__(24);
  /* harmony import */ var __WEBPACK_IMPORTED_MODULE_2__UiProgressCircular_vue__ = __webpack_require__(26);
  /* harmony import */ var __WEBPACK_IMPORTED_MODULE_3__UiRippleInk_vue__ = __webpack_require__(11);
  /* harmony import */ var __WEBPACK_IMPORTED_MODULE_4__UiTooltip_vue__ = __webpack_require__(27);
  
  
  
  
  
  
  
  
  /* harmony default export */ __webpack_exports__["a"] = {
      name: 'ui-icon-button',
  
      props: {
          type: {
              type: String,
              default: 'primary' },
          buttonType: String,
          href: String,
          color: {
              type: String,
              default: 'default' },
          size: {
              type: String,
              default: 'normal' },
          icon: String,
          ariaLabel: String,
          loading: {
              type: Boolean,
              default: false
          },
          hasDropdown: {
              type: Boolean,
              default: false
          },
          dropdownPosition: {
              type: String,
              default: 'bottom-start'
          },
          appendDropdownToBody: {
              type: Boolean,
              default: true
          },
          constrainDropdownToScrollParent: {
              type: Boolean,
              default: true
          },
          openDropdownOn: {
              type: String,
              default: 'click' },
          tooltip: String,
          openTooltipOn: String,
          tooltipPosition: String,
          disableRipple: {
              type: Boolean,
              default: false
          },
          disabled: {
              type: Boolean,
              default: false
          }
      },
  
      computed: {
          classes: function classes() {
              return ['ui-icon-button--type-' + this.type, 'ui-icon-button--color-' + this.color, 'ui-icon-button--size-' + this.size, { 'is-anchor': this.isAnchor }, { 'is-loading': this.loading }, { 'is-disabled': this.disabled || this.loading }, { 'has-dropdown': this.hasDropdown }];
          },
          isAnchor: function isAnchor() {
              return this.href !== undefined;
          },
          progressColor: function progressColor() {
              if (this.type === 'primary') {
                  if (this.color === 'default' || this.color === 'black') {
                      return 'black';
                  }
  
                  return 'white';
              }
  
              if (this.color === 'white') {
                  return 'white';
              }
  
              return 'black';
          }
      },
  
      methods: {
          onClick: function onClick(e) {
              this.$emit('click', e);
          },
          onDropdownOpen: function onDropdownOpen() {
              this.$emit('dropdown-open');
          },
          onDropdownClose: function onDropdownClose() {
              this.$emit('dropdown-close');
          },
          openDropdown: function openDropdown() {
              if (this.$refs.dropdown) {
                  this.$refs.dropdown.open();
              }
          },
          closeDropdown: function closeDropdown() {
              if (this.$refs.dropdown) {
                  this.$refs.dropdown.close();
              }
          },
          toggleDropdown: function toggleDropdown() {
              if (this.$refs.dropdown) {
                  this.$refs.dropdown.toggle();
              }
          }
      },
  
      components: {
          UiIcon: __WEBPACK_IMPORTED_MODULE_0__UiIcon_vue__["default"],
          UiPopover: __WEBPACK_IMPORTED_MODULE_1__UiPopover_vue__["default"],
          UiProgressCircular: __WEBPACK_IMPORTED_MODULE_2__UiProgressCircular_vue__["default"],
          UiRippleInk: __WEBPACK_IMPORTED_MODULE_3__UiRippleInk_vue__["default"],
          UiTooltip: __WEBPACK_IMPORTED_MODULE_4__UiTooltip_vue__["default"]
      }
  };
  
  /***/ }),
  
  /***/ 49:
  /***/ (function(module, exports, __webpack_require__) {
  
  exports = module.exports = __webpack_require__(0)();
  // imports
  
  
  // module
  exports.push([module.i, "\n.ui-icon-button {\n  -webkit-box-align: center;\n      -ms-flex-align: center;\n          align-items: center;\n  background: none;\n  border-radius: 50%;\n  border: none;\n  cursor: default;\n  display: -webkit-inline-box;\n  display: -ms-inline-flexbox;\n  display: inline-flex;\n  -webkit-box-pack: center;\n      -ms-flex-pack: center;\n          justify-content: center;\n  margin: 0;\n  outline: none;\n  overflow: hidden;\n  padding: 0;\n  position: relative;\n  -webkit-mask-image: -webkit-radial-gradient(circle, white, black);\n}\n.ui-icon-button,\n  .ui-icon-button .ui-icon-button__focus-ring {\n    height: 2.25rem;\n    width: 2.25rem;\n}\nbody[modality=\"keyboard\"] .ui-icon-button:focus .ui-icon-button__focus-ring {\n    opacity: 1;\n    -webkit-transform: scale(1);\n            transform: scale(1);\n}\n.ui-icon-button::-moz-focus-inner {\n    border: 0;\n}\n.ui-icon-button.is-anchor {\n    cursor: pointer;\n    text-decoration: none;\n}\n.ui-icon-button.is-anchor.is-disabled {\n      cursor: default;\n}\n.ui-icon-button.is-loading .ui-icon-button__icon {\n    opacity: 0;\n}\n.ui-icon-button.is-disabled {\n    opacity: 0.6;\n}\n.ui-icon-button__icon {\n  -webkit-box-align: center;\n      -ms-flex-align: center;\n          align-items: center;\n  color: currentColor;\n  display: -webkit-box;\n  display: -ms-flexbox;\n  display: flex;\n  height: initial;\n  -webkit-box-pack: center;\n      -ms-flex-pack: center;\n          justify-content: center;\n  opacity: 1;\n  position: relative;\n  -webkit-transition-delay: 0.1s;\n          transition-delay: 0.1s;\n  -webkit-transition: opacity 0.2s ease;\n  transition: opacity 0.2s ease;\n  width: 100%;\n  z-index: 1;\n}\n.ui-icon-button__icon .ui-icon {\n    display: block;\n}\n.ui-icon-button__focus-ring {\n  border-radius: 50%;\n  height: 2.25rem;\n  left: 0;\n  opacity: 0;\n  position: absolute;\n  top: 0;\n  -webkit-transform-origin: center;\n          transform-origin: center;\n  -webkit-transform: scale(0);\n          transform: scale(0);\n  -webkit-transition: opacity 0.3s ease, -webkit-transform 0.3s ease;\n  transition: opacity 0.3s ease, -webkit-transform 0.3s ease;\n  transition: transform 0.3s ease, opacity 0.3s ease;\n  transition: transform 0.3s ease, opacity 0.3s ease, -webkit-transform 0.3s ease;\n  width: 2.25rem;\n}\n.ui-progress-circular.ui-icon-button__progress {\n  left: 50%;\n  position: absolute;\n  top: 50%;\n  -webkit-transform: translate(-50%, -50%);\n          transform: translate(-50%, -50%);\n}\n.ui-icon-button--size-mini,\n.ui-icon-button--size-mini .ui-icon-button__focus-ring {\n  height: 1.5rem;\n  width: 1.5rem;\n}\n.ui-icon-button--size-mini .ui-icon {\n  font-size: 1.125rem;\n}\n.ui-icon-button--size-small,\n.ui-icon-button--size-small .ui-icon-button__focus-ring {\n  height: 2rem;\n  width: 2rem;\n}\n.ui-icon-button--size-small .ui-icon {\n  font-size: 1.125rem;\n}\n.ui-icon-button--size-large,\n.ui-icon-button--size-large .ui-icon-button__focus-ring {\n  height: 3rem;\n  width: 3rem;\n}\n.ui-icon-button--color-black,\n.ui-icon-button--color-white {\n  background-color: transparent;\n}\n.ui-icon-button--color-black:hover:not(.is-disabled), .ui-icon-button--color-black.has-dropdown-open,\n  .ui-icon-button--color-white:hover:not(.is-disabled),\n  .ui-icon-button--color-white.has-dropdown-open {\n    background-color: rgba(0, 0, 0, 0.1);\n}\n.ui-icon-button--color-black .ui-icon-button__focus-ring,\n  .ui-icon-button--color-white .ui-icon-button__focus-ring {\n    background-color: rgba(0, 0, 0, 0.12);\n}\n.ui-icon-button--color-black {\n  color: rgba(0, 0, 0, 0.54);\n}\n.ui-icon-button--color-white {\n  color: white;\n}\n.ui-icon-button--type-primary.ui-icon-button--color-default {\n  color: rgba(0, 0, 0, 0.87);\n  background-color: #eeeeee;\n}\n.ui-icon-button--type-primary.ui-icon-button--color-default:hover:not(.is-disabled), .ui-icon-button--type-primary.ui-icon-button--color-default.has-dropdown-open {\n    background-color: #dbdbdb;\n}\n.ui-icon-button--type-primary.ui-icon-button--color-default .ui-icon-button__focus-ring {\n    background-color: #cfcfcf;\n}\n.ui-icon-button--type-primary.ui-icon-button--color-default .ui-ripple-ink__ink {\n    opacity: 0.2;\n}\n.ui-icon-button--type-primary.ui-icon-button--color-primary, .ui-icon-button--type-primary.ui-icon-button--color-accent, .ui-icon-button--type-primary.ui-icon-button--color-green, .ui-icon-button--type-primary.ui-icon-button--color-orange, .ui-icon-button--type-primary.ui-icon-button--color-red {\n  color: white;\n}\n.ui-icon-button--type-primary.ui-icon-button--color-primary .ui-ripple-ink__ink, .ui-icon-button--type-primary.ui-icon-button--color-accent .ui-ripple-ink__ink, .ui-icon-button--type-primary.ui-icon-button--color-green .ui-ripple-ink__ink, .ui-icon-button--type-primary.ui-icon-button--color-orange .ui-ripple-ink__ink, .ui-icon-button--type-primary.ui-icon-button--color-red .ui-ripple-ink__ink {\n    opacity: 0.4;\n}\n.ui-icon-button--type-primary.ui-icon-button--color-primary {\n  background-color: #2196f3;\n}\n.ui-icon-button--type-primary.ui-icon-button--color-primary:hover:not(.is-disabled), .ui-icon-button--type-primary.ui-icon-button--color-primary.has-dropdown-open {\n    background-color: #0c7cd5;\n}\n.ui-icon-button--type-primary.ui-icon-button--color-primary .ui-icon-button__focus-ring {\n    background-color: #0b76cc;\n}\n.ui-icon-button--type-primary.ui-icon-button--color-accent {\n  background-color: #d500f9;\n}\n.ui-icon-button--type-primary.ui-icon-button--color-accent:hover:not(.is-disabled), .ui-icon-button--type-primary.ui-icon-button--color-accent.has-dropdown-open {\n    background-color: #a900c6;\n}\n.ui-icon-button--type-primary.ui-icon-button--color-accent .ui-icon-button__focus-ring {\n    background-color: #a100bc;\n}\n.ui-icon-button--type-primary.ui-icon-button--color-green {\n  background-color: #4caf50;\n}\n.ui-icon-button--type-primary.ui-icon-button--color-green:hover:not(.is-disabled), .ui-icon-button--type-primary.ui-icon-button--color-green.has-dropdown-open {\n    background-color: #3d8b40;\n}\n.ui-icon-button--type-primary.ui-icon-button--color-green .ui-icon-button__focus-ring {\n    background-color: #39843c;\n}\n.ui-icon-button--type-primary.ui-icon-button--color-orange {\n  background-color: #ff9800;\n}\n.ui-icon-button--type-primary.ui-icon-button--color-orange:hover:not(.is-disabled), .ui-icon-button--type-primary.ui-icon-button--color-orange.has-dropdown-open {\n    background-color: #cc7a00;\n}\n.ui-icon-button--type-primary.ui-icon-button--color-orange .ui-icon-button__focus-ring {\n    background-color: #c27400;\n}\n.ui-icon-button--type-primary.ui-icon-button--color-red {\n  background-color: #f44336;\n}\n.ui-icon-button--type-primary.ui-icon-button--color-red:hover:not(.is-disabled), .ui-icon-button--type-primary.ui-icon-button--color-red.has-dropdown-open {\n    background-color: #ea1c0d;\n}\n.ui-icon-button--type-primary.ui-icon-button--color-red .ui-icon-button__focus-ring {\n    background-color: #e11b0c;\n}\n.ui-icon-button--type-secondary.ui-icon-button--color-default {\n  color: rgba(0, 0, 0, 0.54);\n}\n.ui-icon-button--type-secondary.ui-icon-button--color-default:hover:not(.is-disabled), .ui-icon-button--type-secondary.ui-icon-button--color-default.has-dropdown-open, .ui-icon-button--type-secondary.ui-icon-button--color-default.has-focus-ring:focus,\n  body[modality=\"keyboard\"] .ui-icon-button--type-secondary.ui-icon-button--color-default:focus {\n    color: rgba(0, 0, 0, 0.87);\n}\n.ui-icon-button--type-secondary.ui-icon-button--color-default:hover:not(.is-disabled), .ui-icon-button--type-secondary.ui-icon-button--color-default.has-dropdown-open {\n    background-color: rgba(0, 0, 0, 0.1);\n}\n.ui-icon-button--type-secondary.ui-icon-button--color-default .ui-icon-button__focus-ring {\n    background-color: rgba(0, 0, 0, 0.26);\n}\n.ui-icon-button--type-secondary.ui-icon-button--color-primary {\n  color: #2196f3;\n}\n.ui-icon-button--type-secondary.ui-icon-button--color-primary:hover:not(.is-disabled), .ui-icon-button--type-secondary.ui-icon-button--color-primary.has-dropdown-open {\n    background-color: rgba(33, 150, 243, 0.12);\n}\n.ui-icon-button--type-secondary.ui-icon-button--color-primary .ui-icon-button__focus-ring {\n    background-color: rgba(33, 150, 243, 0.26);\n}\n.ui-icon-button--type-secondary.ui-icon-button--color-accent {\n  color: #d500f9;\n}\n.ui-icon-button--type-secondary.ui-icon-button--color-accent:hover:not(.is-disabled), .ui-icon-button--type-secondary.ui-icon-button--color-accent.has-dropdown-open {\n    background-color: rgba(213, 0, 249, 0.12);\n}\n.ui-icon-button--type-secondary.ui-icon-button--color-accent .ui-icon-button__focus-ring {\n    background-color: rgba(213, 0, 249, 0.26);\n}\n.ui-icon-button--type-secondary.ui-icon-button--color-green {\n  color: #43a047;\n}\n.ui-icon-button--type-secondary.ui-icon-button--color-green:hover:not(.is-disabled), .ui-icon-button--type-secondary.ui-icon-button--color-green.has-dropdown-open {\n    background-color: rgba(67, 160, 71, 0.12);\n}\n.ui-icon-button--type-secondary.ui-icon-button--color-green .ui-icon-button__focus-ring {\n    background-color: rgba(67, 160, 71, 0.26);\n}\n.ui-icon-button--type-secondary.ui-icon-button--color-orange {\n  color: #ff9800;\n}\n.ui-icon-button--type-secondary.ui-icon-button--color-orange:hover:not(.is-disabled), .ui-icon-button--type-secondary.ui-icon-button--color-orange.has-dropdown-open {\n    background-color: rgba(255, 152, 0, 0.12);\n}\n.ui-icon-button--type-secondary.ui-icon-button--color-orange .ui-icon-button__focus-ring {\n    background-color: rgba(255, 152, 0, 0.26);\n}\n.ui-icon-button--type-secondary.ui-icon-button--color-red {\n  color: #f44336;\n}\n.ui-icon-button--type-secondary.ui-icon-button--color-red:hover:not(.is-disabled), .ui-icon-button--type-secondary.ui-icon-button--color-red.has-dropdown-open {\n    background-color: rgba(244, 67, 54, 0.12);\n}\n.ui-icon-button--type-secondary.ui-icon-button--color-red .ui-icon-button__focus-ring {\n    background-color: rgba(244, 67, 54, 0.26);\n}\n", ""]);
  
  // exports
  
  
  /***/ }),
  
  /***/ 5:
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
  
  var trim = /^\s+|\s+$/g;
  var whitespace = /\s+/g;
  
  function interpret(input) {
      return typeof input === 'string' ? input.replace(trim, '').split(whitespace) : input;
  }
  
  function classes(el) {
      if (isElement(el)) {
          return (el.getAttribute('class') || '').replace(trim, '').split(whitespace);
      }
  
      return [];
  }
  
  function set(el, input) {
      if (isElement(el)) {
          el.setAttribute('class', interpret(input).join(' '));
      }
  }
  
  function add(el, input) {
      var current = remove(el, input);
      var values = interpret(input);
  
      current.push.apply(current, values);
      set(el, current);
  
      return current;
  }
  
  function remove(el, input) {
      var current = classes(el);
      var values = interpret(input);
  
      values.forEach(function (value) {
          var i = current.indexOf(value);
          if (i !== -1) {
              current.splice(i, 1);
          }
      });
  
      set(el, current);
  
      return current;
  }
  
  function contains(el, input) {
      var current = classes(el);
      var values = interpret(input);
  
      return values.every(function (value) {
          return current.indexOf(value) !== -1;
      });
  }
  
  function isElement(o) {
      var elementObjects = (typeof HTMLElement === 'undefined' ? 'undefined' : _typeof(HTMLElement)) === 'object';
      return elementObjects ? o instanceof HTMLElement : isElementObject(o);
  }
  
  function isElementObject(o) {
      return o && (typeof o === 'undefined' ? 'undefined' : _typeof(o)) === 'object' && typeof o.nodeName === 'string' && o.nodeType === 1;
  }
  
  /* harmony default export */ __webpack_exports__["a"] = {
      add: add,
      remove: remove,
      contains: contains,
      has: contains,
      set: set,
      get: classes
  };
  
  /***/ }),
  
  /***/ 52:
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  var render = function () {var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;
    return _c(_vm.isAnchor ? 'a' : 'button', {
      tag: "component",
      staticClass: "ui-icon-button",
      class: _vm.classes,
      attrs: {
        "aria-label": _vm.ariaLabel || _vm.tooltip,
        "disabled": _vm.disabled || _vm.loading,
        "href": _vm.isAnchor ? (_vm.disabled ? null : _vm.href) : null,
        "type": _vm.isAnchor ? null : _vm.buttonType
      },
      on: {
        "click": _vm.onClick
      }
    }, [(_vm.icon || _vm.$slots.default) ? _c('div', {
      staticClass: "ui-icon-button__icon"
    }, [_vm._t("default", [_c('ui-icon', {
      attrs: {
        "icon": _vm.icon
      }
    })])], 2) : _vm._e(), _vm._v(" "), _c('div', {
      staticClass: "ui-icon-button__focus-ring"
    }), _vm._v(" "), (_vm.loading) ? _c('ui-progress-circular', {
      staticClass: "ui-icon-button__progress",
      attrs: {
        "color": _vm.progressColor,
        "size": _vm.size === 'large' ? 24 : 18,
        "stroke": 4.5
      }
    }) : _vm._e(), _vm._v(" "), (!_vm.disableRipple && !_vm.disabled) ? _c('ui-ripple-ink') : _vm._e(), _vm._v(" "), (_vm.hasDropdown) ? _c('ui-popover', {
      ref: "dropdown",
      attrs: {
        "constain-focus": "",
        "append-to-body": _vm.appendDropdownToBody,
        "constrain-to-scroll-parent": _vm.constrainDropdownToScrollParent,
        "position": _vm.dropdownPosition,
        "open-on": _vm.openDropdownOn
      },
      on: {
        "close": _vm.onDropdownClose,
        "open": _vm.onDropdownOpen
      }
    }, [_vm._t("dropdown")], 2) : _vm._e(), _vm._v(" "), (_vm.tooltip) ? _c('ui-tooltip', {
      attrs: {
        "open-on": _vm.openTooltipOn,
        "position": _vm.tooltipPosition
      }
    }, [_vm._v(_vm._s(_vm.tooltip))]) : _vm._e()], 1)
  }
  var staticRenderFns = []
  render._withStripped = true
  var esExports = { render: render, staticRenderFns: staticRenderFns }
  /* harmony default export */ __webpack_exports__["a"] = esExports;
  if (false) {
    module.hot.accept()
    if (module.hot.data) {
       require("vue-hot-reload-api").rerender("data-v-9db4dbee", esExports)
    }
  }
  
  /***/ }),
  
  /***/ 55:
  /***/ (function(module, exports, __webpack_require__) {
  
  // style-loader: Adds some css to the DOM by adding a <style> tag
  
  // load the styles
  var content = __webpack_require__(49);
  if(typeof content === 'string') content = [[module.i, content, '']];
  if(content.locals) module.exports = content.locals;
  // add the styles to the DOM
  var update = __webpack_require__(2)("56bdf360", content, false);
  // Hot Module Replacement
  if(false) {
   // When the styles change, update the <style> tags
   if(!content.locals) {
     module.hot.accept("!!../node_modules/css-loader/index.js!../node_modules/vue-loader/lib/style-compiler/index.js?{\"vue\":true,\"id\":\"data-v-9db4dbee\",\"scoped\":false,\"hasInlineConfig\":true}!../node_modules/sass-loader/index.js!../node_modules/vue-loader/lib/selector.js?type=styles&index=0!./UiIconButton.vue", function() {
       var newContent = require("!!../node_modules/css-loader/index.js!../node_modules/vue-loader/lib/style-compiler/index.js?{\"vue\":true,\"id\":\"data-v-9db4dbee\",\"scoped\":false,\"hasInlineConfig\":true}!../node_modules/sass-loader/index.js!../node_modules/vue-loader/lib/selector.js?type=styles&index=0!./UiIconButton.vue");
       if(typeof newContent === 'string') newContent = [[module.id, newContent, '']];
       update(newContent);
     });
   }
   // When the module is disposed, remove the <style> tags
   module.hot.dispose(function() { update(); });
  }
  
  /***/ }),
  
  /***/ 6:
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  Object.defineProperty(__webpack_exports__, "__esModule", { value: true });
  /* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__babel_loader_node_modules_vue_loader_lib_selector_type_script_index_0_UiIcon_vue__ = __webpack_require__(7);
  /* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__node_modules_vue_loader_lib_template_compiler_index_id_data_v_39a27af7_hasScoped_false_node_modules_vue_loader_lib_selector_type_template_index_0_UiIcon_vue__ = __webpack_require__(9);
  var disposed = false
  function injectStyle (ssrContext) {
    if (disposed) return
    __webpack_require__(10)
  }
  var normalizeComponent = __webpack_require__(1)
  /* script */
  
  /* template */
  
  /* styles */
  var __vue_styles__ = injectStyle
  /* scopeId */
  var __vue_scopeId__ = null
  /* moduleIdentifier (server only) */
  var __vue_module_identifier__ = null
  var Component = normalizeComponent(
    __WEBPACK_IMPORTED_MODULE_0__babel_loader_node_modules_vue_loader_lib_selector_type_script_index_0_UiIcon_vue__["a" /* default */],
    __WEBPACK_IMPORTED_MODULE_1__node_modules_vue_loader_lib_template_compiler_index_id_data_v_39a27af7_hasScoped_false_node_modules_vue_loader_lib_selector_type_template_index_0_UiIcon_vue__["a" /* default */],
    __vue_styles__,
    __vue_scopeId__,
    __vue_module_identifier__
  )
  Component.options.__file = "src\\UiIcon.vue"
  if (Component.esModule && Object.keys(Component.esModule).some(function (key) {return key !== "default" && key.substr(0, 2) !== "__"})) {console.error("named exports are not supported in *.vue files.")}
  if (Component.options.functional) {console.error("[vue-loader] UiIcon.vue: functional components are not supported with templates, they should use render functions.")}
  
  /* hot reload */
  if (false) {(function () {
    var hotAPI = require("vue-hot-reload-api")
    hotAPI.install(require("vue"), false)
    if (!hotAPI.compatible) return
    module.hot.accept()
    if (!module.hot.data) {
      hotAPI.createRecord("data-v-39a27af7", Component.options)
    } else {
      hotAPI.reload("data-v-39a27af7", Component.options)
    }
    module.hot.dispose(function (data) {
      disposed = true
    })
  })()}
  
  /* harmony default export */ __webpack_exports__["default"] = Component.exports;
  
  
  /***/ }),
  
  /***/ 7:
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  
  
  /* harmony default export */ __webpack_exports__["a"] = {
      name: 'ui-icon',
  
      props: {
          icon: String,
          iconSet: {
              type: String,
              default: 'material-icons'
          },
          ariaLabel: String,
          removeText: {
              type: Boolean,
              default: false
          },
          useSvg: {
              type: Boolean,
              default: false
          }
      }
  };
  
  /***/ }),
  
  /***/ 8:
  /***/ (function(module, exports, __webpack_require__) {
  
  exports = module.exports = __webpack_require__(0)();
  // imports
  
  
  // module
  exports.push([module.i, "\n.ui-icon {\n  cursor: inherit;\n  display: inline-block;\n  font-size: 1.5rem;\n  height: 1em;\n  -webkit-user-select: none;\n     -moz-user-select: none;\n      -ms-user-select: none;\n          user-select: none;\n  vertical-align: middle;\n  width: 1em;\n}\n.ui-icon svg {\n    display: block;\n    fill: currentColor;\n    height: 1em;\n    margin: 0;\n    padding: 0;\n    width: 1em;\n}\n", ""]);
  
  // exports
  
  
  /***/ }),
  
  /***/ 80:
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  Object.defineProperty(__webpack_exports__, "__esModule", { value: true });
  /* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__babel_loader_node_modules_vue_loader_lib_selector_type_script_index_0_UiProgressLinear_vue__ = __webpack_require__(85);
  /* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__node_modules_vue_loader_lib_template_compiler_index_id_data_v_22995a30_hasScoped_false_node_modules_vue_loader_lib_selector_type_template_index_0_UiProgressLinear_vue__ = __webpack_require__(98);
  var disposed = false
  function injectStyle (ssrContext) {
    if (disposed) return
    __webpack_require__(103)
  }
  var normalizeComponent = __webpack_require__(1)
  /* script */
  
  /* template */
  
  /* styles */
  var __vue_styles__ = injectStyle
  /* scopeId */
  var __vue_scopeId__ = null
  /* moduleIdentifier (server only) */
  var __vue_module_identifier__ = null
  var Component = normalizeComponent(
    __WEBPACK_IMPORTED_MODULE_0__babel_loader_node_modules_vue_loader_lib_selector_type_script_index_0_UiProgressLinear_vue__["a" /* default */],
    __WEBPACK_IMPORTED_MODULE_1__node_modules_vue_loader_lib_template_compiler_index_id_data_v_22995a30_hasScoped_false_node_modules_vue_loader_lib_selector_type_template_index_0_UiProgressLinear_vue__["a" /* default */],
    __vue_styles__,
    __vue_scopeId__,
    __vue_module_identifier__
  )
  Component.options.__file = "src\\UiProgressLinear.vue"
  if (Component.esModule && Object.keys(Component.esModule).some(function (key) {return key !== "default" && key.substr(0, 2) !== "__"})) {console.error("named exports are not supported in *.vue files.")}
  if (Component.options.functional) {console.error("[vue-loader] UiProgressLinear.vue: functional components are not supported with templates, they should use render functions.")}
  
  /* hot reload */
  if (false) {(function () {
    var hotAPI = require("vue-hot-reload-api")
    hotAPI.install(require("vue"), false)
    if (!hotAPI.compatible) return
    module.hot.accept()
    if (!module.hot.data) {
      hotAPI.createRecord("data-v-22995a30", Component.options)
    } else {
      hotAPI.reload("data-v-22995a30", Component.options)
    }
    module.hot.dispose(function (data) {
      disposed = true
    })
  })()}
  
  /* harmony default export */ __webpack_exports__["default"] = Component.exports;
  
  
  /***/ }),
  
  /***/ 85:
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  
  
  /* harmony default export */ __webpack_exports__["a"] = {
      name: 'ui-progress-linear',
  
      props: {
          type: {
              type: String,
              default: 'indeterminate' },
          color: {
              type: String,
              default: 'primary' },
          progress: {
              type: Number,
              default: 0
          }
      },
  
      computed: {
          classes: function classes() {
              return ['ui-progress-linear--color-' + this.color, 'ui-progress-linear--type-' + this.type];
          },
          moderatedProgress: function moderatedProgress() {
              if (this.progress < 0) {
                  return 0;
              }
  
              if (this.progress > 100) {
                  return 100;
              }
  
              return this.progress;
          }
      }
  };
  
  /***/ }),
  
  /***/ 9:
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  var render = function () {var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;
    return _c('span', {
      staticClass: "ui-icon",
      class: [_vm.iconSet, _vm.icon],
      attrs: {
        "aria-label": _vm.ariaLabel
      }
    }, [(_vm.useSvg) ? _c('svg', {
      staticClass: "ui-icon__svg"
    }, [_c('use', {
      attrs: {
        "xmlns:xlink": "http://www.w3.org/1999/xlink",
        "xlink:href": '#' + _vm.icon
      }
    })]) : _vm._t("default", [_vm._v(_vm._s(_vm.removeText ? null : _vm.icon))])], 2)
  }
  var staticRenderFns = []
  render._withStripped = true
  var esExports = { render: render, staticRenderFns: staticRenderFns }
  /* harmony default export */ __webpack_exports__["a"] = esExports;
  if (false) {
    module.hot.accept()
    if (module.hot.data) {
       require("vue-hot-reload-api").rerender("data-v-39a27af7", esExports)
    }
  }
  
  /***/ }),
  
  /***/ 92:
  /***/ (function(module, exports, __webpack_require__) {
  
  exports = module.exports = __webpack_require__(0)();
  // imports
  
  
  // module
  exports.push([module.i, "\n.ui-progress-linear {\n  display: block;\n  height: 0.25rem;\n  overflow: hidden;\n  position: relative;\n  -webkit-transition-duration: 0.3s;\n          transition-duration: 0.3s;\n  -webkit-transition-property: height, opacity;\n  transition-property: height, opacity;\n  -webkit-transition-timing-function: ease;\n          transition-timing-function: ease;\n  width: 100%;\n}\n.ui-progress-linear__progress-bar {\n  height: 0.25rem;\n  left: 0;\n  position: absolute;\n  top: 0;\n  -webkit-transform-origin: left;\n          transform-origin: left;\n  width: 100%;\n}\n.ui-progress-linear__progress-bar.is-determinate {\n    -webkit-transition: -webkit-transform 0.2s ease;\n    transition: -webkit-transform 0.2s ease;\n    transition: transform 0.2s ease;\n    transition: transform 0.2s ease, -webkit-transform 0.2s ease;\n}\n.ui-progress-linear__progress-bar.is-indeterminate {\n    -webkit-animation: ui-progress-linear-indeterminate 2.1s linear infinite;\n            animation: ui-progress-linear-indeterminate 2.1s linear infinite;\n    -webkit-transform: translateX(0) scaleX(0);\n            transform: translateX(0) scaleX(0);\n    -webkit-transition: -webkit-transform 0.2s cubic-bezier(0.4, 0, 0.2, 1);\n    transition: -webkit-transform 0.2s cubic-bezier(0.4, 0, 0.2, 1);\n    transition: transform 0.2s cubic-bezier(0.4, 0, 0.2, 1);\n    transition: transform 0.2s cubic-bezier(0.4, 0, 0.2, 1), -webkit-transform 0.2s cubic-bezier(0.4, 0, 0.2, 1);\n}\n@-webkit-keyframes ui-progress-linear-indeterminate {\n0% {\n    -webkit-transform: translateX(0) scaleX(0);\n            transform: translateX(0) scaleX(0);\n}\n25% {\n    -webkit-transform: translateX(50%) scaleX(0.6);\n            transform: translateX(50%) scaleX(0.6);\n}\n49% {\n    -webkit-transform: translateX(110%) scaleX(0);\n            transform: translateX(110%) scaleX(0);\n}\n50% {\n    -webkit-transform: translateX(0) scaleX(0);\n            transform: translateX(0) scaleX(0);\n}\n75% {\n    -webkit-transform: translateX(0) scaleX(0.6);\n            transform: translateX(0) scaleX(0.6);\n}\n100% {\n    -webkit-transform: translateX(110%) scaleX(0);\n            transform: translateX(110%) scaleX(0);\n}\n}\n@keyframes ui-progress-linear-indeterminate {\n0% {\n    -webkit-transform: translateX(0) scaleX(0);\n            transform: translateX(0) scaleX(0);\n}\n25% {\n    -webkit-transform: translateX(50%) scaleX(0.6);\n            transform: translateX(50%) scaleX(0.6);\n}\n49% {\n    -webkit-transform: translateX(110%) scaleX(0);\n            transform: translateX(110%) scaleX(0);\n}\n50% {\n    -webkit-transform: translateX(0) scaleX(0);\n            transform: translateX(0) scaleX(0);\n}\n75% {\n    -webkit-transform: translateX(0) scaleX(0.6);\n            transform: translateX(0) scaleX(0.6);\n}\n100% {\n    -webkit-transform: translateX(110%) scaleX(0);\n            transform: translateX(110%) scaleX(0);\n}\n}\n.ui-progress-linear--transition-fade-enter-active,\n.ui-progress-linear--transition-fade-leave-active {\n  -webkit-transition: opacity 0.3s ease;\n  transition: opacity 0.3s ease;\n}\n.ui-progress-linear--transition-fade-enter,\n.ui-progress-linear--transition-fade-leave-active {\n  opacity: 0;\n}\n.ui-progress-linear--color-primary {\n  background-color: rgba(33, 150, 243, 0.4);\n}\n.ui-progress-linear--color-primary .ui-progress-linear__progress-bar {\n    background-color: #2196f3;\n}\n.ui-progress-linear--color-accent {\n  background-color: rgba(213, 0, 249, 0.4);\n}\n.ui-progress-linear--color-accent .ui-progress-linear__progress-bar {\n    background-color: #d500f9;\n}\n.ui-progress-linear--color-black {\n  background-color: rgba(97, 97, 97, 0.4);\n}\n.ui-progress-linear--color-black .ui-progress-linear__progress-bar {\n    background-color: #616161;\n}\n.ui-progress-linear--color-white {\n  background-color: rgba(255, 255, 255, 0.4);\n}\n.ui-progress-linear--color-white .ui-progress-linear__progress-bar {\n    background-color: white;\n}\n", ""]);
  
  // exports
  
  
  /***/ }),
  
  /***/ 98:
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  var render = function () {var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;
    return _c('transition', {
      attrs: {
        "name": "ui-progress-linear--transition-fade"
      }
    }, [_c('div', {
      staticClass: "ui-progress-linear",
      class: _vm.classes
    }, [(_vm.type === 'determinate') ? _c('div', {
      staticClass: "ui-progress-linear__progress-bar is-determinate",
      style: ({
        'transform': ("scaleX(" + (_vm.moderatedProgress / 100) + ")")
      }),
      attrs: {
        "role": "progressbar",
        "aria-valuemax": 100,
        "aria-valuemin": 0,
        "aria-valuenow": _vm.moderatedProgress
      }
    }) : _c('div', {
      staticClass: "ui-progress-linear__progress-bar is-indeterminate",
      attrs: {
        "role": "progressbar",
        "aria-valuemax": 100,
        "aria-valuemin": 0
      }
    })])])
  }
  var staticRenderFns = []
  render._withStripped = true
  var esExports = { render: render, staticRenderFns: staticRenderFns }
  /* harmony default export */ __webpack_exports__["a"] = esExports;
  if (false) {
    module.hot.accept()
    if (module.hot.data) {
       require("vue-hot-reload-api").rerender("data-v-22995a30", esExports)
    }
  }
  
  /***/ })
  
  /******/ });
  });