text: module.exports =
      /******/ (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;
      /******/
      /******/ 	// define getter function for harmony exports
      /******/
      __webpack_require__.d = function (exports, name, getter) {
          /******/
          if (!__webpack_require__.o(exports, name)) {
              /******/
              Object.defineProperty(exports, name, {enumerable: true, get: getter});
              /******/
          }
          /******/
      };
      /******/
      /******/ 	// define __esModule on exports
      /******/
      __webpack_require__.r = function (exports) {
          /******/
          if (typeof Symbol !== 'undefined' && Symbol.toStringTag) {
              /******/
              Object.defineProperty(exports, Symbol.toStringTag, {value: 'Module'});
              /******/
          }
          /******/
          Object.defineProperty(exports, '__esModule', {value: true});
          /******/
      };
      /******/
      /******/ 	// create a fake namespace object
      /******/ 	// mode & 1: value is a module id, require it
      /******/ 	// mode & 2: merge all properties of value into the ns
      /******/ 	// mode & 4: return value when already ns object
      /******/ 	// mode & 8|1: behave like require
      /******/
      __webpack_require__.t = function (value, mode) {
          /******/
          if (mode & 1) value = __webpack_require__(value);
          /******/
          if (mode & 8) return value;
          /******/
          if ((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
          /******/
          var ns = Object.create(null);
          /******/
          __webpack_require__.r(ns);
          /******/
          Object.defineProperty(ns, 'default', {enumerable: true, value: value});
          /******/
          if (mode & 2 && typeof value != 'string') for (var key in value) __webpack_require__.d(ns, key, function (key) {
              return value[key];
          }.bind(null, key));
          /******/
          return ns;
          /******/
      };
      /******/
      /******/ 	// 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 = "/dist/";
      /******/
      /******/
      /******/ 	// Load entry module and return exports
      /******/
      return __webpack_require__(__webpack_require__.s = 61);
      /******/
  })
  /************************************************************************/
  /******/({
  
      /***/ 0:
      /***/ (function (module, __webpack_exports__, __webpack_require__) {
  
          "use strict";
          /* harmony export (binding) */
          __webpack_require__.d(__webpack_exports__, "a", function () {
              return normalizeComponent;
          });
          /* globals __VUE_SSR_CONTEXT__ */
  
  // IMPORTANT: Do NOT use ES2015 features in this file (except for modules).
  // This module is a runtime utility for cleaner component module output and will
  // be included in the final webpack user bundle.
  
          function normalizeComponent(
              scriptExports,
              render,
              staticRenderFns,
              functionalTemplate,
              injectStyles,
              scopeId,
              moduleIdentifier, /* server only */
              shadowMode /* vue-cli only */
          ) {
              // Vue.extend constructor export interop
              var options = typeof scriptExports === 'function'
                  ? scriptExports.options
                  : scriptExports
  
              // render functions
              if (render) {
                  options.render = render
                  options.staticRenderFns = staticRenderFns
                  options._compiled = true
              }
  
              // functional template
              if (functionalTemplate) {
                  options.functional = true
              }
  
              // scopedId
              if (scopeId) {
                  options._scopeId = 'data-v-' + 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 = shadowMode
                      ? function () {
                          injectStyles.call(this, this.$root.$options.shadowRoot)
                      }
                      : injectStyles
              }
  
              if (hook) {
                  if (options.functional) {
                      // for template-only hot-reload because in that case the render fn doesn't
                      // go through the normalizer
                      options._injectStyles = hook
                      // register for functioal component in vue file
                      var originalRender = options.render
                      options.render = function renderWithStyleInjection(h, context) {
                          hook.call(context)
                          return originalRender(h, context)
                      }
                  } else {
                      // inject component registration as beforeCreate hook
                      var existing = options.beforeCreate
                      options.beforeCreate = existing
                          ? [].concat(existing, hook)
                          : [hook]
                  }
              }
  
              return {
                  exports: scriptExports,
                  options: options
              }
          }
  
  
          /***/
      }),
  
      /***/ 29:
      /***/ (function (module, exports) {
  
          module.exports = require("element-ui/lib/tooltip");
  
          /***/
      }),
  
      /***/ 4:
      /***/ (function (module, exports) {
  
          module.exports = require("element-ui/lib/mixins/emitter");
  
          /***/
      }),
  
      /***/ 49:
      /***/ (function (module, exports) {
  
          module.exports = require("element-ui/lib/input-number");
  
          /***/
      }),
  
      /***/ 61:
      /***/ (function (module, __webpack_exports__, __webpack_require__) {
  
          "use strict";
          __webpack_require__.r(__webpack_exports__);
  
  // CONCATENATED MODULE: ./node_modules/_vue-loader@15.7.1@vue-loader/lib/loaders/templateLoader.js??vue-loader-options!./node_modules/_vue-loader@15.7.1@vue-loader/lib??vue-loader-options!./packages/slider/src/main.vue?vue&type=template&id=32708644&
          var render = function () {
              var _vm = this
              var _h = _vm.$createElement
              var _c = _vm._self._c || _h
              return _c(
                  "div",
                  {
                      staticClass: "el-slider",
                      class: {
                          "is-vertical": _vm.vertical,
                          "el-slider--with-input": _vm.showInput
                      },
                      attrs: {
                          role: "slider",
                          "aria-valuemin": _vm.min,
                          "aria-valuemax": _vm.max,
                          "aria-orientation": _vm.vertical ? "vertical" : "horizontal",
                          "aria-disabled": _vm.sliderDisabled
                      }
                  },
                  [
                      _vm.showInput && !_vm.range
                          ? _c("el-input-number", {
                              ref: "input",
                              staticClass: "el-slider__input",
                              attrs: {
                                  step: _vm.step,
                                  disabled: _vm.sliderDisabled,
                                  controls: _vm.showInputControls,
                                  min: _vm.min,
                                  max: _vm.max,
                                  debounce: _vm.debounce,
                                  size: _vm.inputSize
                              },
                              on: {change: _vm.emitChange},
                              model: {
                                  value: _vm.firstValue,
                                  callback: function ($$v) {
                                      _vm.firstValue = $$v
                                  },
                                  expression: "firstValue"
                              }
                          })
                          : _vm._e(),
                      _c(
                          "div",
                          {
                              ref: "slider",
                              staticClass: "el-slider__runway",
                              class: {"show-input": _vm.showInput, disabled: _vm.sliderDisabled},
                              style: _vm.runwayStyle,
                              on: {click: _vm.onSliderClick}
                          },
                          [
                              _c("div", {staticClass: "el-slider__bar", style: _vm.barStyle}),
                              _c("slider-button", {
                                  ref: "button1",
                                  attrs: {
                                      vertical: _vm.vertical,
                                      "tooltip-class": _vm.tooltipClass
                                  },
                                  model: {
                                      value: _vm.firstValue,
                                      callback: function ($$v) {
                                          _vm.firstValue = $$v
                                      },
                                      expression: "firstValue"
                                  }
                              }),
                              _vm.range
                                  ? _c("slider-button", {
                                      ref: "button2",
                                      attrs: {
                                          vertical: _vm.vertical,
                                          "tooltip-class": _vm.tooltipClass
                                      },
                                      model: {
                                          value: _vm.secondValue,
                                          callback: function ($$v) {
                                              _vm.secondValue = $$v
                                          },
                                          expression: "secondValue"
                                      }
                                  })
                                  : _vm._e(),
                              _vm._l(_vm.stops, function (item, key) {
                                  return _vm.showStops
                                      ? _c("div", {
                                          key: key,
                                          staticClass: "el-slider__stop",
                                          style: _vm.getStopStyle(item)
                                      })
                                      : _vm._e()
                              }),
                              _vm.markList.length > 0
                                  ? [
                                      _c(
                                          "div",
                                          _vm._l(_vm.markList, function (item, key) {
                                              return _c("div", {
                                                  key: key,
                                                  staticClass: "el-slider__stop el-slider__marks-stop",
                                                  style: _vm.getStopStyle(item.position)
                                              })
                                          }),
                                          0
                                      ),
                                      _c(
                                          "div",
                                          {staticClass: "el-slider__marks"},
                                          _vm._l(_vm.markList, function (item, key) {
                                              return _c("slider-marker", {
                                                  key: key,
                                                  style: _vm.getStopStyle(item.position),
                                                  attrs: {mark: item.mark}
                                              })
                                          }),
                                          1
                                      )
                                  ]
                                  : _vm._e()
                          ],
                          2
                      )
                  ],
                  1
              )
          }
          var staticRenderFns = []
          render._withStripped = true
  
  
  // CONCATENATED MODULE: ./packages/slider/src/main.vue?vue&type=template&id=32708644&
  
  // EXTERNAL MODULE: external "element-ui/lib/input-number"
          var input_number_ = __webpack_require__(49);
          var input_number_default = /*#__PURE__*/__webpack_require__.n(input_number_);
  
  // CONCATENATED MODULE: ./node_modules/_vue-loader@15.7.1@vue-loader/lib/loaders/templateLoader.js??vue-loader-options!./node_modules/_vue-loader@15.7.1@vue-loader/lib??vue-loader-options!./packages/slider/src/button.vue?vue&type=template&id=e72d2ad2&
          var buttonvue_type_template_id_e72d2ad2_render = function () {
              var _vm = this
              var _h = _vm.$createElement
              var _c = _vm._self._c || _h
              return _c(
                  "div",
                  {
                      ref: "button",
                      staticClass: "el-slider__button-wrapper",
                      class: {hover: _vm.hovering, dragging: _vm.dragging},
                      style: _vm.wrapperStyle,
                      attrs: {tabindex: "0"},
                      on: {
                          mouseenter: _vm.handleMouseEnter,
                          mouseleave: _vm.handleMouseLeave,
                          mousedown: _vm.onButtonDown,
                          touchstart: _vm.onButtonDown,
                          focus: _vm.handleMouseEnter,
                          blur: _vm.handleMouseLeave,
                          keydown: [
                              function ($event) {
                                  if (
                                      !("button" in $event) &&
                                      _vm._k($event.keyCode, "left", 37, $event.key, [
                                          "Left",
                                          "ArrowLeft"
                                      ])
                                  ) {
                                      return null
                                  }
                                  if ("button" in $event && $event.button !== 0) {
                                      return null
                                  }
                                  return _vm.onLeftKeyDown($event)
                              },
                              function ($event) {
                                  if (
                                      !("button" in $event) &&
                                      _vm._k($event.keyCode, "right", 39, $event.key, [
                                          "Right",
                                          "ArrowRight"
                                      ])
                                  ) {
                                      return null
                                  }
                                  if ("button" in $event && $event.button !== 2) {
                                      return null
                                  }
                                  return _vm.onRightKeyDown($event)
                              },
                              function ($event) {
                                  if (
                                      !("button" in $event) &&
                                      _vm._k($event.keyCode, "down", 40, $event.key, [
                                          "Down",
                                          "ArrowDown"
                                      ])
                                  ) {
                                      return null
                                  }
                                  $event.preventDefault()
                                  return _vm.onLeftKeyDown($event)
                              },
                              function ($event) {
                                  if (
                                      !("button" in $event) &&
                                      _vm._k($event.keyCode, "up", 38, $event.key, ["Up", "ArrowUp"])
                                  ) {
                                      return null
                                  }
                                  $event.preventDefault()
                                  return _vm.onRightKeyDown($event)
                              }
                          ]
                      }
                  },
                  [
                      _c(
                          "el-tooltip",
                          {
                              ref: "tooltip",
                              attrs: {
                                  placement: "top",
                                  "popper-class": _vm.tooltipClass,
                                  disabled: !_vm.showTooltip
                              }
                          },
                          [
                              _c("span", {attrs: {slot: "content"}, slot: "content"}, [
                                  _vm._v(_vm._s(_vm.formatValue))
                              ]),
                              _c("div", {
                                  staticClass: "el-slider__button",
                                  class: {hover: _vm.hovering, dragging: _vm.dragging}
                              })
                          ]
                      )
                  ],
                  1
              )
          }
          var buttonvue_type_template_id_e72d2ad2_staticRenderFns = []
          buttonvue_type_template_id_e72d2ad2_render._withStripped = true
  
  
  // CONCATENATED MODULE: ./packages/slider/src/button.vue?vue&type=template&id=e72d2ad2&
  
  // EXTERNAL MODULE: external "element-ui/lib/tooltip"
          var tooltip_ = __webpack_require__(29);
          var tooltip_default = /*#__PURE__*/__webpack_require__.n(tooltip_);
  
  // CONCATENATED MODULE: ./node_modules/_babel-loader@7.1.5@babel-loader/lib!./node_modules/_vue-loader@15.7.1@vue-loader/lib??vue-loader-options!./packages/slider/src/button.vue?vue&type=script&lang=js&
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  
  
          /* harmony default export */
          var buttonvue_type_script_lang_js_ = ({
              name: 'ElSliderButton',
  
              components: {
                  ElTooltip: tooltip_default.a
              },
  
              props: {
                  value: {
                      type: Number,
                      default: 0
                  },
                  vertical: {
                      type: Boolean,
                      default: false
                  },
                  tooltipClass: String
              },
  
              data: function data() {
                  return {
                      hovering: false,
                      dragging: false,
                      isClick: false,
                      startX: 0,
                      currentX: 0,
                      startY: 0,
                      currentY: 0,
                      startPosition: 0,
                      newPosition: null,
                      oldValue: this.value
                  };
              },
  
  
              computed: {
                  disabled: function disabled() {
                      return this.$parent.sliderDisabled;
                  },
                  max: function max() {
                      return this.$parent.max;
                  },
                  min: function min() {
                      return this.$parent.min;
                  },
                  step: function step() {
                      return this.$parent.step;
                  },
                  showTooltip: function showTooltip() {
                      return this.$parent.showTooltip;
                  },
                  precision: function precision() {
                      return this.$parent.precision;
                  },
                  currentPosition: function currentPosition() {
                      return (this.value - this.min) / (this.max - this.min) * 100 + '%';
                  },
                  enableFormat: function enableFormat() {
                      return this.$parent.formatTooltip instanceof Function;
                  },
                  formatValue: function formatValue() {
                      return this.enableFormat && this.$parent.formatTooltip(this.value) || this.value;
                  },
                  wrapperStyle: function wrapperStyle() {
                      return this.vertical ? {bottom: this.currentPosition} : {left: this.currentPosition};
                  }
              },
  
              watch: {
                  dragging: function dragging(val) {
                      this.$parent.dragging = val;
                  }
              },
  
              methods: {
                  displayTooltip: function displayTooltip() {
                      this.$refs.tooltip && (this.$refs.tooltip.showPopper = true);
                  },
                  hideTooltip: function hideTooltip() {
                      this.$refs.tooltip && (this.$refs.tooltip.showPopper = false);
                  },
                  handleMouseEnter: function handleMouseEnter() {
                      this.hovering = true;
                      this.displayTooltip();
                  },
                  handleMouseLeave: function handleMouseLeave() {
                      this.hovering = false;
                      this.hideTooltip();
                  },
                  onButtonDown: function onButtonDown(event) {
                      if (this.disabled) return;
                      event.preventDefault();
                      this.onDragStart(event);
                      window.addEventListener('mousemove', this.onDragging);
                      window.addEventListener('touchmove', this.onDragging);
                      window.addEventListener('mouseup', this.onDragEnd);
                      window.addEventListener('touchend', this.onDragEnd);
                      window.addEventListener('contextmenu', this.onDragEnd);
                  },
                  onLeftKeyDown: function onLeftKeyDown() {
                      if (this.disabled) return;
                      this.newPosition = parseFloat(this.currentPosition) - this.step / (this.max - this.min) * 100;
                      this.setPosition(this.newPosition);
                      this.$parent.emitChange();
                  },
                  onRightKeyDown: function onRightKeyDown() {
                      if (this.disabled) return;
                      this.newPosition = parseFloat(this.currentPosition) + this.step / (this.max - this.min) * 100;
                      this.setPosition(this.newPosition);
                      this.$parent.emitChange();
                  },
                  onDragStart: function onDragStart(event) {
                      this.dragging = true;
                      this.isClick = true;
                      if (event.type === 'touchstart') {
                          event.clientY = event.touches[0].clientY;
                          event.clientX = event.touches[0].clientX;
                      }
                      if (this.vertical) {
                          this.startY = event.clientY;
                      } else {
                          this.startX = event.clientX;
                      }
                      this.startPosition = parseFloat(this.currentPosition);
                      this.newPosition = this.startPosition;
                  },
                  onDragging: function onDragging(event) {
                      if (this.dragging) {
                          this.isClick = false;
                          this.displayTooltip();
                          this.$parent.resetSize();
                          var diff = 0;
                          if (event.type === 'touchmove') {
                              event.clientY = event.touches[0].clientY;
                              event.clientX = event.touches[0].clientX;
                          }
                          if (this.vertical) {
                              this.currentY = event.clientY;
                              diff = (this.startY - this.currentY) / this.$parent.sliderSize * 100;
                          } else {
                              this.currentX = event.clientX;
                              diff = (this.currentX - this.startX) / this.$parent.sliderSize * 100;
                          }
                          this.newPosition = this.startPosition + diff;
                          this.setPosition(this.newPosition);
                      }
                  },
                  onDragEnd: function onDragEnd() {
                      var _this = this;
  
                      if (this.dragging) {
                          /*
                           * 防止在 mouseup 后立即触发 click，导致滑块有几率产生一小段位移
                           * 不使用 preventDefault 是因为 mouseup 和 click 没有注册在同一个 DOM 上
                           */
                          setTimeout(function () {
                              _this.dragging = false;
                              _this.hideTooltip();
                              if (!_this.isClick) {
                                  _this.setPosition(_this.newPosition);
                                  _this.$parent.emitChange();
                              }
                          }, 0);
                          window.removeEventListener('mousemove', this.onDragging);
                          window.removeEventListener('touchmove', this.onDragging);
                          window.removeEventListener('mouseup', this.onDragEnd);
                          window.removeEventListener('touchend', this.onDragEnd);
                          window.removeEventListener('contextmenu', this.onDragEnd);
                      }
                  },
                  setPosition: function setPosition(newPosition) {
                      var _this2 = this;
  
                      if (newPosition === null || isNaN(newPosition)) return;
                      if (newPosition < 0) {
                          newPosition = 0;
                      } else if (newPosition > 100) {
                          newPosition = 100;
                      }
                      var lengthPerStep = 100 / ((this.max - this.min) / this.step);
                      var steps = Math.round(newPosition / lengthPerStep);
                      var value = steps * lengthPerStep * (this.max - this.min) * 0.01 + this.min;
                      value = parseFloat(value.toFixed(this.precision));
                      this.$emit('input', value);
                      this.$nextTick(function () {
                          _this2.displayTooltip();
                          _this2.$refs.tooltip && _this2.$refs.tooltip.updatePopper();
                      });
                      if (!this.dragging && this.value !== this.oldValue) {
                          this.oldValue = this.value;
                      }
                  }
              }
          });
  // CONCATENATED MODULE: ./packages/slider/src/button.vue?vue&type=script&lang=js&
          /* harmony default export */
          var src_buttonvue_type_script_lang_js_ = (buttonvue_type_script_lang_js_);
  // EXTERNAL MODULE: ./node_modules/_vue-loader@15.7.1@vue-loader/lib/runtime/componentNormalizer.js
          var componentNormalizer = __webpack_require__(0);
  
  // CONCATENATED MODULE: ./packages/slider/src/button.vue
  
  
          /* normalize component */
  
          var component = Object(componentNormalizer["a" /* default */])(
              src_buttonvue_type_script_lang_js_,
              buttonvue_type_template_id_e72d2ad2_render,
              buttonvue_type_template_id_e72d2ad2_staticRenderFns,
              false,
              null,
              null,
              null
          )
  
          /* hot reload */
          if (false) {
              var api;
          }
          component.options.__file = "packages/slider/src/button.vue"
          /* harmony default export */
          var src_button = (component.exports);
  // CONCATENATED MODULE: ./packages/slider/src/marker.js
          /* harmony default export */
          var marker = ({
              name: 'ElMarker',
  
              props: {
                  mark: {
                      type: [String, Object]
                  }
              },
              render: function render() {
                  var h = arguments[0];
  
                  var label = typeof this.mark === 'string' ? this.mark : this.mark.label;
  
                  return h(
                      'div',
                      {'class': 'el-slider__marks-text', style: this.mark.style || {}},
                      [label]
                  );
              }
          });
  // EXTERNAL MODULE: external "element-ui/lib/mixins/emitter"
          var emitter_ = __webpack_require__(4);
          var emitter_default = /*#__PURE__*/__webpack_require__.n(emitter_);
  
  // CONCATENATED MODULE: ./node_modules/_babel-loader@7.1.5@babel-loader/lib!./node_modules/_vue-loader@15.7.1@vue-loader/lib??vue-loader-options!./packages/slider/src/main.vue?vue&type=script&lang=js&
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  
  
          /* harmony default export */
          var mainvue_type_script_lang_js_ = ({
              name: 'ElSlider',
  
              mixins: [emitter_default.a],
  
              inject: {
                  elForm: {
                      default: ''
                  }
              },
  
              props: {
                  min: {
                      type: Number,
                      default: 0
                  },
                  max: {
                      type: Number,
                      default: 100
                  },
                  step: {
                      type: Number,
                      default: 1
                  },
                  value: {
                      type: [Number, Array],
                      default: 0
                  },
                  showInput: {
                      type: Boolean,
                      default: false
                  },
                  showInputControls: {
                      type: Boolean,
                      default: true
                  },
                  inputSize: {
                      type: String,
                      default: 'small'
                  },
                  showStops: {
                      type: Boolean,
                      default: false
                  },
                  showTooltip: {
                      type: Boolean,
                      default: true
                  },
                  formatTooltip: Function,
                  disabled: {
                      type: Boolean,
                      default: false
                  },
                  range: {
                      type: Boolean,
                      default: false
                  },
                  vertical: {
                      type: Boolean,
                      default: false
                  },
                  height: {
                      type: String
                  },
                  debounce: {
                      type: Number,
                      default: 300
                  },
                  label: {
                      type: String
                  },
                  tooltipClass: String,
                  marks: Object
              },
  
              components: {
                  ElInputNumber: input_number_default.a,
                  SliderButton: src_button,
                  SliderMarker: marker
              },
  
              data: function data() {
                  return {
                      firstValue: null,
                      secondValue: null,
                      oldValue: null,
                      dragging: false,
                      sliderSize: 1
                  };
              },
  
  
              watch: {
                  value: function value(val, oldVal) {
                      if (this.dragging || Array.isArray(val) && Array.isArray(oldVal) && val.every(function (item, index) {
                          return item === oldVal[index];
                      })) {
                          return;
                      }
                      this.setValues();
                  },
                  dragging: function dragging(val) {
                      if (!val) {
                          this.setValues();
                      }
                  },
                  firstValue: function firstValue(val) {
                      if (this.range) {
                          this.$emit('input', [this.minValue, this.maxValue]);
                      } else {
                          this.$emit('input', val);
                      }
                  },
                  secondValue: function secondValue() {
                      if (this.range) {
                          this.$emit('input', [this.minValue, this.maxValue]);
                      }
                  },
                  min: function min() {
                      this.setValues();
                  },
                  max: function max() {
                      this.setValues();
                  }
              },
  
              methods: {
                  valueChanged: function valueChanged() {
                      var _this = this;
  
                      if (this.range) {
                          return ![this.minValue, this.maxValue].every(function (item, index) {
                              return item === _this.oldValue[index];
                          });
                      } else {
                          return this.value !== this.oldValue;
                      }
                  },
                  setValues: function setValues() {
                      if (this.min > this.max) {
                          console.error('[Element Error][Slider]min should not be greater than max.');
                          return;
                      }
                      var val = this.value;
                      if (this.range && Array.isArray(val)) {
                          if (val[1] < this.min) {
                              this.$emit('input', [this.min, this.min]);
                          } else if (val[0] > this.max) {
                              this.$emit('input', [this.max, this.max]);
                          } else if (val[0] < this.min) {
                              this.$emit('input', [this.min, val[1]]);
                          } else if (val[1] > this.max) {
                              this.$emit('input', [val[0], this.max]);
                          } else {
                              this.firstValue = val[0];
                              this.secondValue = val[1];
                              if (this.valueChanged()) {
                                  this.dispatch('ElFormItem', 'el.form.change', [this.minValue, this.maxValue]);
                                  this.oldValue = val.slice();
                              }
                          }
                      } else if (!this.range && typeof val === 'number' && !isNaN(val)) {
                          if (val < this.min) {
                              this.$emit('input', this.min);
                          } else if (val > this.max) {
                              this.$emit('input', this.max);
                          } else {
                              this.firstValue = val;
                              if (this.valueChanged()) {
                                  this.dispatch('ElFormItem', 'el.form.change', val);
                                  this.oldValue = val;
                              }
                          }
                      }
                  },
                  setPosition: function setPosition(percent) {
                      var targetValue = this.min + percent * (this.max - this.min) / 100;
                      if (!this.range) {
                          this.$refs.button1.setPosition(percent);
                          return;
                      }
                      var button = void 0;
                      if (Math.abs(this.minValue - targetValue) < Math.abs(this.maxValue - targetValue)) {
                          button = this.firstValue < this.secondValue ? 'button1' : 'button2';
                      } else {
                          button = this.firstValue > this.secondValue ? 'button1' : 'button2';
                      }
                      this.$refs[button].setPosition(percent);
                  },
                  onSliderClick: function onSliderClick(event) {
                      if (this.sliderDisabled || this.dragging) return;
                      this.resetSize();
                      if (this.vertical) {
                          var sliderOffsetBottom = this.$refs.slider.getBoundingClientRect().bottom;
                          this.setPosition((sliderOffsetBottom - event.clientY) / this.sliderSize * 100);
                      } else {
                          var sliderOffsetLeft = this.$refs.slider.getBoundingClientRect().left;
                          this.setPosition((event.clientX - sliderOffsetLeft) / this.sliderSize * 100);
                      }
                      this.emitChange();
                  },
                  resetSize: function resetSize() {
                      if (this.$refs.slider) {
                          this.sliderSize = this.$refs.slider['client' + (this.vertical ? 'Height' : 'Width')];
                      }
                  },
                  emitChange: function emitChange() {
                      var _this2 = this;
  
                      this.$nextTick(function () {
                          _this2.$emit('change', _this2.range ? [_this2.minValue, _this2.maxValue] : _this2.value);
                      });
                  },
                  getStopStyle: function getStopStyle(position) {
                      return this.vertical ? {'bottom': position + '%'} : {'left': position + '%'};
                  }
              },
  
              computed: {
                  stops: function stops() {
                      var _this3 = this;
  
                      if (!this.showStops || this.min > this.max) return [];
                      if (this.step === 0) {
                          false && false;
                          return [];
                      }
                      var stopCount = (this.max - this.min) / this.step;
                      var stepWidth = 100 * this.step / (this.max - this.min);
                      var result = [];
                      for (var i = 1; i < stopCount; i++) {
                          result.push(i * stepWidth);
                      }
                      if (this.range) {
                          return result.filter(function (step) {
                              return step < 100 * (_this3.minValue - _this3.min) / (_this3.max - _this3.min) || step > 100 * (_this3.maxValue - _this3.min) / (_this3.max - _this3.min);
                          });
                      } else {
                          return result.filter(function (step) {
                              return step > 100 * (_this3.firstValue - _this3.min) / (_this3.max - _this3.min);
                          });
                      }
                  },
                  markList: function markList() {
                      var _this4 = this;
  
                      if (!this.marks) {
                          return [];
                      }
  
                      var marksKeys = Object.keys(this.marks);
                      return marksKeys.map(parseFloat).sort(function (a, b) {
                          return a - b;
                      }).filter(function (point) {
                          return point <= _this4.max && point >= _this4.min;
                      }).map(function (point) {
                          return {
                              point: point,
                              position: (point - _this4.min) * 100 / (_this4.max - _this4.min),
                              mark: _this4.marks[point]
                          };
                      });
                  },
                  minValue: function minValue() {
                      return Math.min(this.firstValue, this.secondValue);
                  },
                  maxValue: function maxValue() {
                      return Math.max(this.firstValue, this.secondValue);
                  },
                  barSize: function barSize() {
                      return this.range ? 100 * (this.maxValue - this.minValue) / (this.max - this.min) + '%' : 100 * (this.firstValue - this.min) / (this.max - this.min) + '%';
                  },
                  barStart: function barStart() {
                      return this.range ? 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(null, precisions);
                  },
                  runwayStyle: function runwayStyle() {
                      return this.vertical ? {height: this.height} : {};
                  },
                  barStyle: function barStyle() {
                      return this.vertical ? {
                          height: this.barSize,
                          bottom: this.barStart
                      } : {
                          width: this.barSize,
                          left: this.barStart
                      };
                  },
                  sliderDisabled: function sliderDisabled() {
                      return this.disabled || (this.elForm || {}).disabled;
                  }
              },
  
              mounted: function mounted() {
                  var valuetext = void 0;
                  if (this.range) {
                      if (Array.isArray(this.value)) {
                          this.firstValue = Math.max(this.min, this.value[0]);
                          this.secondValue = Math.min(this.max, this.value[1]);
                      } else {
                          this.firstValue = this.min;
                          this.secondValue = this.max;
                      }
                      this.oldValue = [this.firstValue, this.secondValue];
                      valuetext = this.firstValue + '-' + this.secondValue;
                  } else {
                      if (typeof this.value !== 'number' || isNaN(this.value)) {
                          this.firstValue = this.min;
                      } else {
                          this.firstValue = Math.min(this.max, Math.max(this.min, this.value));
                      }
                      this.oldValue = this.firstValue;
                      valuetext = this.firstValue;
                  }
                  this.$el.setAttribute('aria-valuetext', valuetext);
  
                  // label screen reader
                  this.$el.setAttribute('aria-label', this.label ? this.label : 'slider between ' + this.min + ' and ' + this.max);
  
                  this.resetSize();
                  window.addEventListener('resize', this.resetSize);
              },
              beforeDestroy: function beforeDestroy() {
                  window.removeEventListener('resize', this.resetSize);
              }
          });
  // CONCATENATED MODULE: ./packages/slider/src/main.vue?vue&type=script&lang=js&
          /* harmony default export */
          var src_mainvue_type_script_lang_js_ = (mainvue_type_script_lang_js_);
  // CONCATENATED MODULE: ./packages/slider/src/main.vue
  
  
          /* normalize component */
  
          var main_component = Object(componentNormalizer["a" /* default */])(
              src_mainvue_type_script_lang_js_,
              render,
              staticRenderFns,
              false,
              null,
              null,
              null
          )
  
          /* hot reload */
          if (false) {
              var main_api;
          }
          main_component.options.__file = "packages/slider/src/main.vue"
          /* harmony default export */
          var main = (main_component.exports);
  // CONCATENATED MODULE: ./packages/slider/index.js
  
  
          /* istanbul ignore next */
          main.install = function (Vue) {
              Vue.component(main.name, main);
          };
  
          /* harmony default export */
          var slider = __webpack_exports__["default"] = (main);
  
          /***/
      })
  
      /******/
  });