buefy 0.9.26 → 0.9.28

package/dist/components/slider/index.js

@@ -0,0 +1,1264 @@
+/*! Buefy v0.9.28 | MIT License | github.com/buefy/buefy */
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+  typeof define === 'function' && define.amd ? define(['exports'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.Slider = {}));
+})(this, (function (exports) { 'use strict';
+
+  function _toPrimitive(t, r) {
+    if ("object" != typeof t || !t) return t;
+    var e = t[Symbol.toPrimitive];
+    if (void 0 !== e) {
+      var i = e.call(t, r || "default");
+      if ("object" != typeof i) return i;
+      throw new TypeError("@@toPrimitive must return a primitive value.");
+    }
+    return ("string" === r ? String : Number)(t);
+  }
+  function _toPropertyKey(t) {
+    var i = _toPrimitive(t, "string");
+    return "symbol" == typeof i ? i : String(i);
+  }
+  function _typeof(o) {
+    "@babel/helpers - typeof";
+
+    return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) {
+      return typeof o;
+    } : function (o) {
+      return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
+    }, _typeof(o);
+  }
+  function _defineProperty(obj, key, value) {
+    key = _toPropertyKey(key);
+    if (key in obj) {
+      Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+      });
+    } else {
+      obj[key] = value;
+    }
+    return obj;
+  }
+  function _toConsumableArray(arr) {
+    return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
+  }
+  function _arrayWithoutHoles(arr) {
+    if (Array.isArray(arr)) return _arrayLikeToArray(arr);
+  }
+  function _iterableToArray(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+  }
+  function _unsupportedIterableToArray(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(o);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+  }
+  function _arrayLikeToArray(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
+    return arr2;
+  }
+  function _nonIterableSpread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+  }
+  function _createForOfIteratorHelper(o, allowArrayLike) {
+    var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
+    if (!it) {
+      if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") {
+        if (it) o = it;
+        var i = 0;
+        var F = function () {};
+        return {
+          s: F,
+          n: function () {
+            if (i >= o.length) return {
+              done: true
+            };
+            return {
+              done: false,
+              value: o[i++]
+            };
+          },
+          e: function (e) {
+            throw e;
+          },
+          f: F
+        };
+      }
+      throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+    }
+    var normalCompletion = true,
+      didErr = false,
+      err;
+    return {
+      s: function () {
+        it = it.call(o);
+      },
+      n: function () {
+        var step = it.next();
+        normalCompletion = step.done;
+        return step;
+      },
+      e: function (e) {
+        didErr = true;
+        err = e;
+      },
+      f: function () {
+        try {
+          if (!normalCompletion && it.return != null) it.return();
+        } finally {
+          if (didErr) throw err;
+        }
+      }
+    };
+  }
+
+  var config = {
+    defaultContainerElement: null,
+    defaultIconPack: 'mdi',
+    defaultIconComponent: null,
+    defaultIconPrev: 'chevron-left',
+    defaultIconNext: 'chevron-right',
+    defaultLocale: undefined,
+    defaultDialogConfirmText: null,
+    defaultDialogCancelText: null,
+    defaultSnackbarDuration: 3500,
+    defaultSnackbarPosition: null,
+    defaultToastDuration: 2000,
+    defaultToastPosition: null,
+    defaultNotificationDuration: 2000,
+    defaultNotificationPosition: null,
+    defaultTooltipType: 'is-primary',
+    defaultTooltipDelay: null,
+    defaultTooltipCloseDelay: null,
+    defaultSidebarDelay: null,
+    defaultInputAutocomplete: 'on',
+    defaultDateFormatter: null,
+    defaultDateParser: null,
+    defaultDateCreator: null,
+    defaultTimeCreator: null,
+    defaultDayNames: null,
+    defaultMonthNames: null,
+    defaultFirstDayOfWeek: null,
+    defaultUnselectableDaysOfWeek: null,
+    defaultTimeFormatter: null,
+    defaultTimeParser: null,
+    defaultModalCanCancel: ['escape', 'x', 'outside', 'button'],
+    defaultModalScroll: null,
+    defaultDatepickerMobileNative: true,
+    defaultTimepickerMobileNative: true,
+    defaultTimepickerMobileModal: true,
+    defaultNoticeQueue: true,
+    defaultInputHasCounter: true,
+    defaultTaginputHasCounter: true,
+    defaultUseHtml5Validation: true,
+    defaultDropdownMobileModal: true,
+    defaultFieldLabelPosition: null,
+    defaultDatepickerYearsRange: [-100, 10],
+    defaultDatepickerNearbyMonthDays: true,
+    defaultDatepickerNearbySelectableMonthDays: false,
+    defaultDatepickerShowWeekNumber: false,
+    defaultDatepickerWeekNumberClickable: false,
+    defaultDatepickerMobileModal: true,
+    defaultTrapFocus: true,
+    defaultAutoFocus: true,
+    defaultButtonRounded: false,
+    defaultSwitchRounded: true,
+    defaultCarouselInterval: 3500,
+    defaultTabsExpanded: false,
+    defaultTabsAnimated: true,
+    defaultTabsType: null,
+    defaultStatusIcon: true,
+    defaultProgrammaticPromise: false,
+    defaultLinkTags: ['a', 'button', 'input', 'router-link', 'nuxt-link', 'n-link', 'RouterLink', 'NuxtLink', 'NLink'],
+    defaultImageWebpFallback: null,
+    defaultImageLazy: true,
+    defaultImageResponsive: true,
+    defaultImageRatio: null,
+    defaultImageSrcsetFormatter: null,
+    defaultBreadcrumbTag: 'a',
+    defaultBreadcrumbAlign: 'is-left',
+    defaultBreadcrumbSeparator: '',
+    defaultBreadcrumbSize: 'is-medium',
+    customIconPacks: null
+  };
+
+  /**
+   * Asserts a value is beetween min and max
+   * @param val
+   * @param min
+   * @param max
+   * @returns {number}
+   */
+  function bound(val, min, max) {
+    return Math.max(min, Math.min(max, val));
+  }
+  function removeElement(el) {
+    if (typeof el.remove !== 'undefined') {
+      el.remove();
+    } else if (typeof el.parentNode !== 'undefined' && el.parentNode !== null) {
+      el.parentNode.removeChild(el);
+    }
+  }
+  function createAbsoluteElement(el) {
+    var root = document.createElement('div');
+    root.style.position = 'absolute';
+    root.style.left = '0px';
+    root.style.top = '0px';
+    root.style.width = '100%';
+    var wrapper = document.createElement('div');
+    root.appendChild(wrapper);
+    wrapper.appendChild(el);
+    document.body.appendChild(root);
+    return root;
+  }
+
+  var script$3 = {
+    name: 'BTooltip',
+    props: {
+      active: {
+        type: Boolean,
+        default: true
+      },
+      type: {
+        type: String,
+        default: function _default() {
+          return config.defaultTooltipType;
+        }
+      },
+      label: String,
+      delay: {
+        type: Number,
+        default: function _default() {
+          return config.defaultTooltipDelay;
+        }
+      },
+      closeDelay: {
+        type: Number,
+        default: function _default() {
+          return config.defaultTooltipCloseDelay;
+        }
+      },
+      position: {
+        type: String,
+        default: 'is-top',
+        validator: function validator(value) {
+          return ['is-top', 'is-bottom', 'is-left', 'is-right'].indexOf(value) > -1;
+        }
+      },
+      triggers: {
+        type: Array,
+        default: function _default() {
+          return ['hover'];
+        }
+      },
+      always: Boolean,
+      square: Boolean,
+      dashed: Boolean,
+      multilined: Boolean,
+      size: {
+        type: String,
+        default: 'is-medium'
+      },
+      appendToBody: Boolean,
+      animated: {
+        type: Boolean,
+        default: true
+      },
+      animation: {
+        type: String,
+        default: 'fade'
+      },
+      contentClass: String,
+      autoClose: {
+        type: [Array, Boolean],
+        default: true
+      }
+    },
+    data: function data() {
+      return {
+        isActive: false,
+        triggerStyle: {},
+        timer: null,
+        _bodyEl: undefined,
+        // Used to append to body
+        resizeObserver: undefined,
+        resizeListener: undefined,
+        timeOutID: null
+      };
+    },
+    computed: {
+      rootClasses: function rootClasses() {
+        return ['b-tooltip', this.type, this.position, this.size, {
+          'is-square': this.square,
+          'is-always': this.always,
+          'is-multiline': this.multilined,
+          'is-dashed': this.dashed
+        }];
+      },
+      newAnimation: function newAnimation() {
+        return this.animated ? this.animation : undefined;
+      }
+    },
+    watch: {
+      isActive: function isActive() {
+        this.$emit(this.isActive ? 'open' : 'close');
+        if (this.appendToBody) {
+          this.updateAppendToBody();
+        }
+      }
+    },
+    methods: {
+      updateAppendToBody: function updateAppendToBody() {
+        var tooltip = this.$refs.tooltip;
+        var trigger = this.$refs.trigger;
+        if (tooltip && trigger) {
+          // update wrapper tooltip
+          var tooltipEl = this.$data._bodyEl.children[0];
+          tooltipEl.classList.forEach(function (item) {
+            return tooltipEl.classList.remove(item);
+          });
+          if (this.$vnode && this.$vnode.data && this.$vnode.data.staticClass) {
+            tooltipEl.classList.add(this.$vnode.data.staticClass);
+          }
+          this.rootClasses.forEach(function (item) {
+            if (_typeof(item) === 'object') {
+              for (var key in item) {
+                if (item[key]) {
+                  tooltipEl.classList.add(key);
+                }
+              }
+            } else {
+              tooltipEl.classList.add(item);
+            }
+          });
+          var rect = trigger.getBoundingClientRect();
+          var top = rect.top + window.scrollY;
+          var left = rect.left + window.scrollX;
+
+          // `tooltipEl` will be placed relative to `wrapper`
+          // because `wrapper` should create a stacking context
+          // as its z-index is non-auto
+          tooltipEl.style.position = 'absolute';
+          switch (this.position) {
+            case 'is-top':
+              tooltipEl.style.width = "".concat(trigger.clientWidth, "px");
+              tooltipEl.style.height = '0px';
+              tooltipEl.style.top = '0px';
+              tooltipEl.style.left = '0px';
+              break;
+            case 'is-bottom':
+              tooltipEl.style.width = "".concat(trigger.clientWidth, "px");
+              tooltipEl.style.height = '0px';
+              tooltipEl.style.top = "".concat(trigger.clientHeight, "px");
+              tooltipEl.style.left = '0px';
+              break;
+            case 'is-left':
+              tooltipEl.style.width = '0px';
+              tooltipEl.style.height = "".concat(trigger.clientHeight, "px");
+              tooltipEl.style.top = '0px';
+              tooltipEl.style.left = '0px';
+              break;
+            case 'is-right':
+              tooltipEl.style.width = '0px';
+              tooltipEl.style.height = "".concat(trigger.clientHeight, "px");
+              tooltipEl.style.top = '0px';
+              tooltipEl.style.left = "".concat(trigger.clientWidth, "px");
+              break;
+          }
+          var wrapper = this.$data._bodyEl;
+          wrapper.style.position = 'absolute';
+          wrapper.style.top = "".concat(top, "px");
+          wrapper.style.left = "".concat(left, "px");
+          wrapper.style.width = '0px';
+          wrapper.style.zIndex = this.isActive || this.always ? '99' : '-1';
+          this.triggerStyle = {
+            zIndex: this.isActive || this.always ? '100' : undefined
+          };
+        }
+      },
+      onClick: function onClick() {
+        var _this = this;
+        if (this.triggers.indexOf('click') < 0) return;
+        // if not active, toggle after clickOutside event
+        // this fixes toggling programmatic
+        this.$nextTick(function () {
+          _this.timeOutID = setTimeout(function () {
+            return _this.open();
+          });
+        });
+      },
+      onHover: function onHover() {
+        if (this.triggers.indexOf('hover') < 0) return;
+        this.open();
+      },
+      onContextMenu: function onContextMenu(e) {
+        if (this.triggers.indexOf('contextmenu') < 0) return;
+        e.preventDefault();
+        this.open();
+      },
+      onFocus: function onFocus() {
+        if (this.triggers.indexOf('focus') < 0) return;
+        this.open();
+      },
+      open: function open() {
+        var _this2 = this;
+        if (this.delay) {
+          this.timer = setTimeout(function () {
+            _this2.isActive = true;
+            _this2.timer = null;
+          }, this.delay);
+        } else {
+          this.isActive = true;
+        }
+      },
+      close: function close() {
+        var _this3 = this;
+        if (typeof this.autoClose === 'boolean') {
+          if (this.autoClose && this.timer) clearTimeout(this.timer);
+          if (this.closeDelay) {
+            this.timer = setTimeout(function () {
+              _this3.isActive = !_this3.autoClose;
+              _this3.timer = null;
+            }, this.closeDelay);
+          } else {
+            this.isActive = !this.autoClose;
+          }
+        }
+      },
+      /**
+      * Close tooltip if clicked outside.
+      */
+      clickedOutside: function clickedOutside(event) {
+        if (this.isActive) {
+          if (Array.isArray(this.autoClose)) {
+            if (this.autoClose.includes('outside')) {
+              if (!this.isInWhiteList(event.target)) {
+                this.isActive = false;
+                return;
+              }
+            }
+            if (this.autoClose.includes('inside')) {
+              if (this.isInWhiteList(event.target)) this.isActive = false;
+            }
+          }
+        }
+      },
+      /**
+       * Keypress event that is bound to the document
+       */
+      keyPress: function keyPress(_ref) {
+        var key = _ref.key;
+        if (this.isActive && (key === 'Escape' || key === 'Esc')) {
+          if (Array.isArray(this.autoClose)) {
+            if (this.autoClose.indexOf('escape') >= 0) this.isActive = false;
+          }
+        }
+      },
+      /**
+      * White-listed items to not close when clicked.
+      */
+      isInWhiteList: function isInWhiteList(el) {
+        if (el === this.$refs.content) return true;
+        // All chidren from content
+        if (this.$refs.content !== undefined) {
+          var children = this.$refs.content.querySelectorAll('*');
+          var _iterator = _createForOfIteratorHelper(children),
+            _step;
+          try {
+            for (_iterator.s(); !(_step = _iterator.n()).done;) {
+              var child = _step.value;
+              if (el === child) {
+                return true;
+              }
+            }
+          } catch (err) {
+            _iterator.e(err);
+          } finally {
+            _iterator.f();
+          }
+        }
+        return false;
+      }
+    },
+    mounted: function mounted() {
+      var _this4 = this;
+      this.controller = new window.AbortController();
+      if (this.appendToBody && typeof window !== 'undefined') {
+        this.$data._bodyEl = createAbsoluteElement(this.$refs.content);
+        this.updateAppendToBody();
+        // updates the tooltip position if the tooltip is inside
+        // `.animation-content`
+        var animation = this.$el.closest('.animation-content');
+        if (animation != null) {
+          var listener = function listener() {
+            _this4.updateAppendToBody();
+            animation.removeEventListener('transitionend', listener);
+          };
+          animation.addEventListener('transitionend', listener, {
+            signal: this.controller.signal
+          });
+        }
+        // observes changes in the window size
+        this.resizeListener = function () {
+          return _this4.updateAppendToBody();
+        };
+        window.addEventListener('resize', this.resizeListener);
+        // observes changes in the size of the immediate parent
+        this.resizeObserver = new ResizeObserver(this.resizeListener);
+        if (this.$el.parentNode != null && this.$el.parentNode.nodeType === Node.ELEMENT_NODE) {
+          this.resizeObserver.observe(this.$el.parentNode);
+        }
+      }
+    },
+    created: function created() {
+      if (typeof window !== 'undefined') {
+        document.addEventListener('click', this.clickedOutside);
+        document.addEventListener('keyup', this.keyPress);
+      }
+    },
+    beforeDestroy: function beforeDestroy() {
+      if (typeof window !== 'undefined') {
+        document.removeEventListener('click', this.clickedOutside);
+        document.removeEventListener('keyup', this.keyPress);
+      }
+      if (this.resizeListener != null) {
+        window.removeEventListener('resize', this.resizeListener);
+      }
+      if (this.resizeObserver != null) {
+        this.resizeObserver.disconnect();
+      }
+      if (this.appendToBody) {
+        removeElement(this.$data._bodyEl);
+      }
+      this.controller.abort();
+      clearTimeout(this.timer);
+      clearTimeout(this.timeOutID);
+    }
+  };
+
+  function normalizeComponent(template, style, script, scopeId, isFunctionalTemplate, moduleIdentifier /* server only */, shadowMode, createInjector, createInjectorSSR, createInjectorShadow) {
+      if (typeof shadowMode !== 'boolean') {
+          createInjectorSSR = createInjector;
+          createInjector = shadowMode;
+          shadowMode = false;
+      }
+      // Vue.extend constructor export interop.
+      const options = typeof script === 'function' ? script.options : script;
+      // render functions
+      if (template && template.render) {
+          options.render = template.render;
+          options.staticRenderFns = template.staticRenderFns;
+          options._compiled = true;
+          // functional template
+          if (isFunctionalTemplate) {
+              options.functional = true;
+          }
+      }
+      // scopedId
+      if (scopeId) {
+          options._scopeId = scopeId;
+      }
+      let 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 (style) {
+                  style.call(this, createInjectorSSR(context));
+              }
+              // register component module identifier for async chunk inference
+              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 (style) {
+          hook = shadowMode
+              ? function (context) {
+                  style.call(this, createInjectorShadow(context, this.$root.$options.shadowRoot));
+              }
+              : function (context) {
+                  style.call(this, createInjector(context));
+              };
+      }
+      if (hook) {
+          if (options.functional) {
+              // register for functional component in vue file
+              const originalRender = options.render;
+              options.render = function renderWithStyleInjection(h, context) {
+                  hook.call(context);
+                  return originalRender(h, context);
+              };
+          }
+          else {
+              // inject component registration as beforeCreate hook
+              const existing = options.beforeCreate;
+              options.beforeCreate = existing ? [].concat(existing, hook) : [hook];
+          }
+      }
+      return script;
+  }
+
+  /* script */
+  const __vue_script__$3 = script$3;
+
+  /* template */
+  var __vue_render__$3 = function () {var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;return _c('div',{ref:"tooltip",class:_vm.rootClasses},[_c('transition',{attrs:{"name":_vm.newAnimation}},[_c('div',{directives:[{name:"show",rawName:"v-show",value:(_vm.active && (_vm.isActive || _vm.always)),expression:"active && (isActive || always)"}],ref:"content",class:['tooltip-content', _vm.contentClass]},[(_vm.label)?[_vm._v(_vm._s(_vm.label))]:(_vm.$slots.content)?[_vm._t("content")]:_vm._e()],2)]),_c('div',{ref:"trigger",staticClass:"tooltip-trigger",style:(_vm.triggerStyle),on:{"click":_vm.onClick,"contextmenu":_vm.onContextMenu,"mouseenter":_vm.onHover,"!focus":function($event){return _vm.onFocus($event)},"!blur":function($event){return _vm.close($event)},"mouseleave":_vm.close}},[_vm._t("default")],2)],1)};
+  var __vue_staticRenderFns__$3 = [];
+
+    /* style */
+    const __vue_inject_styles__$3 = undefined;
+    /* scoped */
+    const __vue_scope_id__$3 = undefined;
+    /* module identifier */
+    const __vue_module_identifier__$3 = undefined;
+    /* functional template */
+    const __vue_is_functional_template__$3 = false;
+    /* style inject */
+    
+    /* style inject SSR */
+    
+    /* style inject shadow dom */
+    
+
+    
+    const __vue_component__$3 = /*#__PURE__*/normalizeComponent(
+      { render: __vue_render__$3, staticRenderFns: __vue_staticRenderFns__$3 },
+      __vue_inject_styles__$3,
+      __vue_script__$3,
+      __vue_scope_id__$3,
+      __vue_is_functional_template__$3,
+      __vue_module_identifier__$3,
+      false,
+      undefined,
+      undefined,
+      undefined
+    );
+
+    var Tooltip = __vue_component__$3;
+
+  var script$2 = {
+    name: 'BSliderThumb',
+    components: _defineProperty({}, Tooltip.name, Tooltip),
+    inheritAttrs: false,
+    props: {
+      value: {
+        type: Number,
+        default: 0
+      },
+      type: {
+        type: String,
+        default: ''
+      },
+      tooltip: {
+        type: Boolean,
+        default: true
+      },
+      indicator: {
+        type: Boolean,
+        default: false
+      },
+      customFormatter: Function,
+      format: {
+        type: String,
+        default: 'raw',
+        validator: function validator(value) {
+          return ['raw', 'percent'].indexOf(value) >= 0;
+        }
+      },
+      locale: {
+        type: [String, Array],
+        default: function _default() {
+          return config.defaultLocale;
+        }
+      },
+      tooltipAlways: {
+        type: Boolean,
+        default: false
+      }
+    },
+    data: function data() {
+      return {
+        isFocused: false,
+        dragging: false,
+        startX: 0,
+        startPosition: 0,
+        newPosition: null,
+        oldValue: this.value
+      };
+    },
+    computed: {
+      disabled: function disabled() {
+        return this.$parent.disabled;
+      },
+      max: function max() {
+        return this.$parent.max;
+      },
+      min: function min() {
+        return this.$parent.min;
+      },
+      step: function step() {
+        return this.$parent.step;
+      },
+      precision: function precision() {
+        return this.$parent.precision;
+      },
+      currentPosition: function currentPosition() {
+        return "".concat((this.value - this.min) / (this.max - this.min) * 100, "%");
+      },
+      wrapperStyle: function wrapperStyle() {
+        return {
+          left: this.currentPosition
+        };
+      },
+      formattedValue: function formattedValue() {
+        if (typeof this.customFormatter !== 'undefined') {
+          return this.customFormatter(this.value);
+        }
+        if (this.format === 'percent') {
+          return new Intl.NumberFormat(this.locale, {
+            style: 'percent'
+          }).format((this.value - this.min) / (this.max - this.min));
+        }
+        return new Intl.NumberFormat(this.locale).format(this.value);
+      }
+    },
+    methods: {
+      onFocus: function onFocus() {
+        this.isFocused = true;
+      },
+      onBlur: function onBlur() {
+        this.isFocused = false;
+      },
+      onButtonDown: function onButtonDown(event) {
+        if (this.disabled) return;
+        event.preventDefault();
+        this.onDragStart(event);
+        if (typeof window !== 'undefined') {
+          document.addEventListener('mousemove', this.onDragging);
+          document.addEventListener('touchmove', this.onDragging);
+          document.addEventListener('mouseup', this.onDragEnd);
+          document.addEventListener('touchend', this.onDragEnd);
+          document.addEventListener('contextmenu', this.onDragEnd);
+        }
+      },
+      onLeftKeyDown: function onLeftKeyDown() {
+        if (this.disabled || this.value === this.min) return;
+        this.newPosition = parseFloat(this.currentPosition) - this.step / (this.max - this.min) * 100;
+        this.setPosition(this.newPosition);
+        this.$parent.emitValue('change');
+      },
+      onRightKeyDown: function onRightKeyDown() {
+        if (this.disabled || this.value === this.max) return;
+        this.newPosition = parseFloat(this.currentPosition) + this.step / (this.max - this.min) * 100;
+        this.setPosition(this.newPosition);
+        this.$parent.emitValue('change');
+      },
+      onHomeKeyDown: function onHomeKeyDown() {
+        if (this.disabled || this.value === this.min) return;
+        this.newPosition = 0;
+        this.setPosition(this.newPosition);
+        this.$parent.emitValue('change');
+      },
+      onEndKeyDown: function onEndKeyDown() {
+        if (this.disabled || this.value === this.max) return;
+        this.newPosition = 100;
+        this.setPosition(this.newPosition);
+        this.$parent.emitValue('change');
+      },
+      onDragStart: function onDragStart(event) {
+        this.dragging = true;
+        this.$emit('dragstart');
+        if (event.type === 'touchstart') {
+          event.clientX = event.touches[0].clientX;
+        }
+        this.startX = event.clientX;
+        this.startPosition = parseFloat(this.currentPosition);
+        this.newPosition = this.startPosition;
+      },
+      onDragging: function onDragging(event) {
+        if (this.dragging) {
+          if (event.type === 'touchmove') {
+            event.clientX = event.touches[0].clientX;
+          }
+          var diff = (event.clientX - this.startX) / this.$parent.sliderSize() * 100;
+          this.newPosition = this.startPosition + diff;
+          this.setPosition(this.newPosition);
+        }
+      },
+      onDragEnd: function onDragEnd() {
+        this.dragging = false;
+        this.$emit('dragend');
+        if (this.value !== this.oldValue) {
+          this.$parent.emitValue('change');
+        }
+        this.setPosition(this.newPosition);
+        if (typeof window !== 'undefined') {
+          document.removeEventListener('mousemove', this.onDragging);
+          document.removeEventListener('touchmove', this.onDragging);
+          document.removeEventListener('mouseup', this.onDragEnd);
+          document.removeEventListener('touchend', this.onDragEnd);
+          document.removeEventListener('contextmenu', this.onDragEnd);
+        }
+      },
+      setPosition: function setPosition(percent) {
+        if (percent === null || isNaN(percent)) return;
+        if (percent < 0) {
+          percent = 0;
+        } else if (percent > 100) {
+          percent = 100;
+        }
+        var stepLength = 100 / ((this.max - this.min) / this.step);
+        var steps = Math.round(percent / stepLength);
+        var value = steps * stepLength / 100 * (this.max - this.min) + this.min;
+        value = parseFloat(value.toFixed(this.precision));
+        this.$emit('input', value);
+        if (!this.dragging && value !== this.oldValue) {
+          this.oldValue = value;
+        }
+      }
+    },
+    beforeDestroy: function beforeDestroy() {
+      document.removeEventListener('mousemove', this.onDragging);
+      document.removeEventListener('touchmove', this.onDragging);
+      document.removeEventListener('mouseup', this.onDragEnd);
+      document.removeEventListener('touchend', this.onDragEnd);
+      document.removeEventListener('contextmenu', this.onDragEnd);
+    }
+  };
+
+  /* script */
+  const __vue_script__$2 = script$2;
+
+  /* template */
+  var __vue_render__$2 = function () {var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;return _c('div',{staticClass:"b-slider-thumb-wrapper",class:{ 'is-dragging': _vm.dragging, 'has-indicator': _vm.indicator},style:(_vm.wrapperStyle)},[_c('b-tooltip',{attrs:{"label":_vm.formattedValue,"type":_vm.type,"always":_vm.dragging || _vm.isFocused || _vm.tooltipAlways,"active":!_vm.disabled && _vm.tooltip}},[_c('div',_vm._b({staticClass:"b-slider-thumb",attrs:{"tabindex":_vm.disabled ? false : 0},on:{"mousedown":_vm.onButtonDown,"touchstart":_vm.onButtonDown,"focus":_vm.onFocus,"blur":_vm.onBlur,"keydown":[function($event){if(!$event.type.indexOf('key')&&_vm._k($event.keyCode,"left",37,$event.key,["Left","ArrowLeft"])){ return null; }if('button' in $event && $event.button !== 0){ return null; }$event.preventDefault();return _vm.onLeftKeyDown($event)},function($event){if(!$event.type.indexOf('key')&&_vm._k($event.keyCode,"right",39,$event.key,["Right","ArrowRight"])){ return null; }if('button' in $event && $event.button !== 2){ return null; }$event.preventDefault();return _vm.onRightKeyDown($event)},function($event){if(!$event.type.indexOf('key')&&_vm._k($event.keyCode,"down",40,$event.key,["Down","ArrowDown"])){ return null; }$event.preventDefault();return _vm.onLeftKeyDown($event)},function($event){if(!$event.type.indexOf('key')&&_vm._k($event.keyCode,"up",38,$event.key,["Up","ArrowUp"])){ return null; }$event.preventDefault();return _vm.onRightKeyDown($event)},function($event){if(!$event.type.indexOf('key')&&_vm._k($event.keyCode,"home",undefined,$event.key,undefined)){ return null; }$event.preventDefault();return _vm.onHomeKeyDown($event)},function($event){if(!$event.type.indexOf('key')&&_vm._k($event.keyCode,"end",undefined,$event.key,undefined)){ return null; }$event.preventDefault();return _vm.onEndKeyDown($event)}]}},'div',_vm.$attrs,false),[(_vm.indicator)?_c('span',[_vm._v(_vm._s(_vm.formattedValue))]):_vm._e()])])],1)};
+  var __vue_staticRenderFns__$2 = [];
+
+    /* style */
+    const __vue_inject_styles__$2 = undefined;
+    /* scoped */
+    const __vue_scope_id__$2 = undefined;
+    /* module identifier */
+    const __vue_module_identifier__$2 = undefined;
+    /* functional template */
+    const __vue_is_functional_template__$2 = false;
+    /* style inject */
+    
+    /* style inject SSR */
+    
+    /* style inject shadow dom */
+    
+
+    
+    const __vue_component__$2 = /*#__PURE__*/normalizeComponent(
+      { render: __vue_render__$2, staticRenderFns: __vue_staticRenderFns__$2 },
+      __vue_inject_styles__$2,
+      __vue_script__$2,
+      __vue_scope_id__$2,
+      __vue_is_functional_template__$2,
+      __vue_module_identifier__$2,
+      false,
+      undefined,
+      undefined,
+      undefined
+    );
+
+    var SliderThumb = __vue_component__$2;
+
+  //
+  //
+  //
+  //
+  //
+  //
+  //
+  //
+  //
+  //
+  //
+
+  var script$1 = {
+    name: 'BSliderTick',
+    props: {
+      value: {
+        type: Number,
+        default: 0
+      }
+    },
+    computed: {
+      position: function position() {
+        var pos = (this.value - this.$parent.min) / (this.$parent.max - this.$parent.min) * 100;
+        return pos >= 0 && pos <= 100 ? pos : 0;
+      },
+      hidden: function hidden() {
+        return this.value === this.$parent.min || this.value === this.$parent.max;
+      }
+    },
+    methods: {
+      getTickStyle: function getTickStyle(position) {
+        return {
+          'left': position + '%'
+        };
+      }
+    },
+    created: function created() {
+      if (!this.$parent.$data._isSlider) {
+        this.$destroy();
+        throw new Error('You should wrap bSliderTick on a bSlider');
+      }
+    }
+  };
+
+  /* script */
+  const __vue_script__$1 = script$1;
+
+  /* template */
+  var __vue_render__$1 = function () {var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;return _c('div',{staticClass:"b-slider-tick",class:{ 'is-tick-hidden': _vm.hidden },style:(_vm.getTickStyle(_vm.position))},[(_vm.$slots.default)?_c('span',{staticClass:"b-slider-tick-label"},[_vm._t("default")],2):_vm._e()])};
+  var __vue_staticRenderFns__$1 = [];
+
+    /* style */
+    const __vue_inject_styles__$1 = undefined;
+    /* scoped */
+    const __vue_scope_id__$1 = undefined;
+    /* module identifier */
+    const __vue_module_identifier__$1 = undefined;
+    /* functional template */
+    const __vue_is_functional_template__$1 = false;
+    /* style inject */
+    
+    /* style inject SSR */
+    
+    /* style inject shadow dom */
+    
+
+    
+    const __vue_component__$1 = /*#__PURE__*/normalizeComponent(
+      { render: __vue_render__$1, staticRenderFns: __vue_staticRenderFns__$1 },
+      __vue_inject_styles__$1,
+      __vue_script__$1,
+      __vue_scope_id__$1,
+      __vue_is_functional_template__$1,
+      __vue_module_identifier__$1,
+      false,
+      undefined,
+      undefined,
+      undefined
+    );
+
+    var SliderTick = __vue_component__$1;
+
+  var script = {
+    name: 'BSlider',
+    components: _defineProperty(_defineProperty({}, SliderThumb.name, SliderThumb), SliderTick.name, SliderTick),
+    props: {
+      value: {
+        type: [Number, Array],
+        default: 0
+      },
+      min: {
+        type: Number,
+        default: 0
+      },
+      max: {
+        type: Number,
+        default: 100
+      },
+      step: {
+        type: Number,
+        default: 1
+      },
+      type: {
+        type: String,
+        default: 'is-primary'
+      },
+      size: String,
+      ticks: {
+        type: Boolean,
+        default: false
+      },
+      tooltip: {
+        type: Boolean,
+        default: true
+      },
+      tooltipType: String,
+      rounded: {
+        type: Boolean,
+        default: false
+      },
+      disabled: {
+        type: Boolean,
+        default: false
+      },
+      lazy: {
+        type: Boolean,
+        default: false
+      },
+      customFormatter: Function,
+      ariaLabel: [String, Array],
+      biggerSliderFocus: {
+        type: Boolean,
+        default: false
+      },
+      indicator: {
+        type: Boolean,
+        default: false
+      },
+      format: {
+        type: String,
+        default: 'raw',
+        validator: function validator(value) {
+          return ['raw', 'percent'].indexOf(value) >= 0;
+        }
+      },
+      locale: {
+        type: [String, Array],
+        default: function _default() {
+          return config.defaultLocale;
+        }
+      },
+      tooltipAlways: {
+        type: Boolean,
+        default: false
+      }
+    },
+    data: function data() {
+      return {
+        value1: null,
+        value2: null,
+        dragging: false,
+        isRange: false,
+        _isSlider: true,
+        // Used by Thumb and Tick
+        timeOutID: null
+      };
+    },
+    computed: {
+      newTooltipType: function newTooltipType() {
+        return this.tooltipType ? this.tooltipType : this.type;
+      },
+      tickValues: function tickValues() {
+        if (!this.ticks || this.min > this.max || this.step === 0) return [];
+        var result = [];
+        for (var i = this.min + this.step; i < this.max; i = i + this.step) {
+          result.push(i);
+        }
+        return result;
+      },
+      minValue: function minValue() {
+        return Math.min(this.value1, this.value2);
+      },
+      maxValue: function maxValue() {
+        return Math.max(this.value1, this.value2);
+      },
+      barSize: function barSize() {
+        return this.isRange ? "".concat(100 * (this.maxValue - this.minValue) / (this.max - this.min), "%") : "".concat(100 * (this.value1 - this.min) / (this.max - this.min), "%");
+      },
+      barStart: function barStart() {
+        return this.isRange ? "".concat(100 * (this.minValue - this.min) / (this.max - this.min), "%") : '0%';
+      },
+      precision: function precision() {
+        var precisions = [this.min, this.max, this.step].map(function (item) {
+          var decimal = ('' + item).split('.')[1];
+          return decimal ? decimal.length : 0;
+        });
+        return Math.max.apply(Math, _toConsumableArray(precisions));
+      },
+      barStyle: function barStyle() {
+        return {
+          width: this.barSize,
+          left: this.barStart
+        };
+      },
+      rootClasses: function rootClasses() {
+        return {
+          'is-rounded': this.rounded,
+          'is-dragging': this.dragging,
+          'is-disabled': this.disabled,
+          'slider-focus': this.biggerSliderFocus
+        };
+      }
+    },
+    watch: {
+      /**
+      * When v-model is changed set the new active step.
+      */
+      value: function value(_value) {
+        this.setValues(_value);
+      },
+      value1: function value1() {
+        this.onInternalValueUpdate();
+      },
+      value2: function value2() {
+        this.onInternalValueUpdate();
+      },
+      min: function min() {
+        this.setValues(this.value);
+      },
+      max: function max() {
+        this.setValues(this.value);
+      }
+    },
+    methods: {
+      setValues: function setValues(newValue) {
+        if (this.min > this.max) {
+          return;
+        }
+        if (Array.isArray(newValue)) {
+          this.isRange = true;
+          var smallValue = typeof newValue[0] !== 'number' || isNaN(newValue[0]) ? this.min : bound(newValue[0], this.min, this.max);
+          var largeValue = typeof newValue[1] !== 'number' || isNaN(newValue[1]) ? this.max : bound(newValue[1], this.min, this.max);
+          this.value1 = this.isThumbReversed ? largeValue : smallValue;
+          this.value2 = this.isThumbReversed ? smallValue : largeValue;
+        } else {
+          this.isRange = false;
+          this.value1 = isNaN(newValue) ? this.min : bound(newValue, this.min, this.max);
+          this.value2 = null;
+        }
+      },
+      onInternalValueUpdate: function onInternalValueUpdate() {
+        if (this.isRange) {
+          this.isThumbReversed = this.value1 > this.value2;
+        }
+        if (!this.lazy || !this.dragging) {
+          this.emitValue('input');
+        }
+        if (this.dragging) {
+          this.emitValue('dragging');
+        }
+      },
+      sliderSize: function sliderSize() {
+        return this.$refs.slider.getBoundingClientRect().width;
+      },
+      onSliderClick: function onSliderClick(event) {
+        if (this.disabled || this.isTrackClickDisabled) return;
+        var sliderOffsetLeft = this.$refs.slider.getBoundingClientRect().left;
+        var percent = (event.clientX - sliderOffsetLeft) / this.sliderSize() * 100;
+        var targetValue = this.min + percent * (this.max - this.min) / 100;
+        var diffFirst = Math.abs(targetValue - this.value1);
+        if (!this.isRange) {
+          if (diffFirst < this.step / 2) return;
+          this.$refs.button1.setPosition(percent);
+        } else {
+          var diffSecond = Math.abs(targetValue - this.value2);
+          if (diffFirst <= diffSecond) {
+            if (diffFirst < this.step / 2) return;
+            this.$refs['button1'].setPosition(percent);
+          } else {
+            if (diffSecond < this.step / 2) return;
+            this.$refs['button2'].setPosition(percent);
+          }
+        }
+        this.emitValue('change');
+      },
+      onDragStart: function onDragStart() {
+        this.dragging = true;
+        this.$emit('dragstart');
+      },
+      onDragEnd: function onDragEnd() {
+        var _this = this;
+        this.isTrackClickDisabled = true;
+        this.timeOutID = setTimeout(function () {
+          // avoid triggering onSliderClick after dragend
+          _this.isTrackClickDisabled = false;
+        }, 0);
+        this.dragging = false;
+        this.$emit('dragend');
+        if (this.lazy) {
+          this.emitValue('input');
+        }
+      },
+      emitValue: function emitValue(type) {
+        this.$emit(type, this.isRange ? [this.minValue, this.maxValue] : this.value1);
+      }
+    },
+    created: function created() {
+      this.isThumbReversed = false;
+      this.isTrackClickDisabled = false;
+      this.setValues(this.value);
+    },
+    beforeDestroy: function beforeDestroy() {
+      clearTimeout(this.timeOutID);
+    }
+  };
+
+  /* script */
+  const __vue_script__ = script;
+
+  /* template */
+  var __vue_render__ = function () {var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;return _c('div',{staticClass:"b-slider",class:[_vm.size, _vm.type, _vm.rootClasses ],on:{"click":_vm.onSliderClick}},[_c('div',{ref:"slider",staticClass:"b-slider-track"},[_c('div',{staticClass:"b-slider-fill",style:(_vm.barStyle)}),(_vm.ticks)?_vm._l((_vm.tickValues),function(val,key){return _c('b-slider-tick',{key:key,attrs:{"value":val}})}):_vm._e(),_vm._t("default"),_c('b-slider-thumb',{ref:"button1",attrs:{"tooltip-always":_vm.tooltipAlways,"type":_vm.newTooltipType,"tooltip":_vm.tooltip,"custom-formatter":_vm.customFormatter,"indicator":_vm.indicator,"format":_vm.format,"locale":_vm.locale,"role":"slider","aria-valuenow":_vm.value1,"aria-valuemin":_vm.min,"aria-valuemax":_vm.max,"aria-orientation":"horizontal","aria-label":Array.isArray(_vm.ariaLabel) ? _vm.ariaLabel[0] : _vm.ariaLabel,"aria-disabled":_vm.disabled},on:{"dragstart":_vm.onDragStart,"dragend":_vm.onDragEnd},model:{value:(_vm.value1),callback:function ($$v) {_vm.value1=$$v;},expression:"value1"}}),(_vm.isRange)?_c('b-slider-thumb',{ref:"button2",attrs:{"tooltip-always":_vm.tooltipAlways,"type":_vm.newTooltipType,"tooltip":_vm.tooltip,"custom-formatter":_vm.customFormatter,"indicator":_vm.indicator,"format":_vm.format,"locale":_vm.locale,"role":"slider","aria-valuenow":_vm.value2,"aria-valuemin":_vm.min,"aria-valuemax":_vm.max,"aria-orientation":"horizontal","aria-label":Array.isArray(_vm.ariaLabel) ? _vm.ariaLabel[1] : '',"aria-disabled":_vm.disabled},on:{"dragstart":_vm.onDragStart,"dragend":_vm.onDragEnd},model:{value:(_vm.value2),callback:function ($$v) {_vm.value2=$$v;},expression:"value2"}}):_vm._e()],2)])};
+  var __vue_staticRenderFns__ = [];
+
+    /* style */
+    const __vue_inject_styles__ = undefined;
+    /* scoped */
+    const __vue_scope_id__ = undefined;
+    /* module identifier */
+    const __vue_module_identifier__ = undefined;
+    /* functional template */
+    const __vue_is_functional_template__ = false;
+    /* style inject */
+    
+    /* style inject SSR */
+    
+    /* style inject shadow dom */
+    
+
+    
+    const __vue_component__ = /*#__PURE__*/normalizeComponent(
+      { render: __vue_render__, staticRenderFns: __vue_staticRenderFns__ },
+      __vue_inject_styles__,
+      __vue_script__,
+      __vue_scope_id__,
+      __vue_is_functional_template__,
+      __vue_module_identifier__,
+      false,
+      undefined,
+      undefined,
+      undefined
+    );
+
+    var Slider = __vue_component__;
+
+  var use = function use(plugin) {
+    if (typeof window !== 'undefined' && window.Vue) {
+      window.Vue.use(plugin);
+    }
+  };
+  var registerComponent = function registerComponent(Vue, component) {
+    Vue.component(component.name, component);
+  };
+
+  var Plugin = {
+    install: function install(Vue) {
+      registerComponent(Vue, Slider);
+      registerComponent(Vue, SliderTick);
+    }
+  };
+  use(Plugin);
+
+  exports.BSlider = Slider;
+  exports.BSliderTick = SliderTick;
+  exports["default"] = Plugin;
+
+  Object.defineProperty(exports, '__esModule', { value: true });
+
+}));