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 = 57);
  /******/ })
  /************************************************************************/
  /******/ ({
  
  /***/ 0:
  /***/ (function(module, exports) {
  
  module.exports = require("element-mini-ui/lib/utils/date-util");
  
  /***/ }),
  
  /***/ 1:
  /***/ (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
    }
  }
  
  
  /***/ }),
  
  /***/ 10:
  /***/ (function(module, exports) {
  
  module.exports = require("element-mini-ui/lib/input");
  
  /***/ }),
  
  /***/ 11:
  /***/ (function(module, exports) {
  
  module.exports = require("element-mini-ui/lib/utils/clickoutside");
  
  /***/ }),
  
  /***/ 16:
  /***/ (function(module, exports) {
  
  module.exports = require("element-mini-ui/lib/scrollbar");
  
  /***/ }),
  
  /***/ 24:
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  
  // CONCATENATED MODULE: ./node_modules/_vue-loader@15.8.3@vue-loader/lib/loaders/templateLoader.js??vue-loader-options!./node_modules/_vue-loader@15.8.3@vue-loader/lib??vue-loader-options!./packages/date-picker/src/picker.vue?vue&type=template&id=79ae069f&
  var render = function() {
    var _vm = this
    var _h = _vm.$createElement
    var _c = _vm._self._c || _h
    return !_vm.ranged
      ? _c(
          "el-input",
          _vm._b(
            {
              directives: [
                {
                  name: "clickoutside",
                  rawName: "v-clickoutside",
                  value: _vm.handleClose,
                  expression: "handleClose"
                }
              ],
              ref: "reference",
              staticClass: "el-date-editor",
              class: "el-date-editor--" + _vm.type,
              attrs: {
                readonly:
                  !_vm.editable ||
                  _vm.readonly ||
                  _vm.type === "dates" ||
                  _vm.type === "week",
                disabled: _vm.pickerDisabled,
                size: _vm.pickerSize,
                name: _vm.name,
                placeholder: _vm.placeholder,
                value: _vm.displayValue,
                validateEvent: false
              },
              on: {
                focus: _vm.handleFocus,
                input: function(value) {
                  return (_vm.userInput = value)
                },
                change: _vm.handleChange
              },
              nativeOn: {
                keydown: function($event) {
                  return _vm.handleKeydown($event)
                },
                mouseenter: function($event) {
                  return _vm.handleMouseEnter($event)
                },
                mouseleave: function($event) {
                  _vm.showClose = false
                }
              }
            },
            "el-input",
            _vm.firstInputId,
            false
          ),
          [
            _c("i", {
              staticClass: "el-input__icon",
              class: _vm.triggerClass,
              attrs: { slot: "prefix" },
              on: { click: _vm.handleFocus },
              slot: "prefix"
            }),
            _vm.haveTrigger
              ? _c("i", {
                  staticClass: "el-input__icon",
                  class: [_vm.showClose ? "" + _vm.clearIcon : ""],
                  attrs: { slot: "suffix" },
                  on: { click: _vm.handleClickIcon },
                  slot: "suffix"
                })
              : _vm._e()
          ]
        )
      : _c(
          "div",
          {
            directives: [
              {
                name: "clickoutside",
                rawName: "v-clickoutside",
                value: _vm.handleClose,
                expression: "handleClose"
              }
            ],
            ref: "reference",
            staticClass: "el-date-editor el-range-editor el-input__inner",
            class: [
              "el-date-editor--" + _vm.type,
              _vm.pickerSize ? "el-range-editor--" + _vm.pickerSize : "",
              _vm.pickerDisabled ? "is-disabled" : "",
              _vm.pickerVisible ? "is-active" : ""
            ],
            on: {
              click: _vm.handleRangeClick,
              mouseenter: _vm.handleMouseEnter,
              mouseleave: function($event) {
                _vm.showClose = false
              },
              keydown: _vm.handleKeydown
            }
          },
          [
            _c("i", {
              class: ["el-input__icon", "el-range__icon", _vm.triggerClass]
            }),
            _c(
              "input",
              _vm._b(
                {
                  staticClass: "el-range-input",
                  attrs: {
                    autocomplete: "off",
                    placeholder: _vm.startPlaceholder,
                    disabled: _vm.pickerDisabled,
                    readonly: !_vm.editable || _vm.readonly,
                    name: _vm.name && _vm.name[0]
                  },
                  domProps: { value: _vm.displayValue && _vm.displayValue[0] },
                  on: {
                    input: _vm.handleStartInput,
                    change: _vm.handleStartChange,
                    focus: _vm.handleFocus
                  }
                },
                "input",
                _vm.firstInputId,
                false
              )
            ),
            _vm._t("range-separator", [
              _c("span", { staticClass: "el-range-separator" }, [
                _vm._v(_vm._s(_vm.rangeSeparator))
              ])
            ]),
            _c(
              "input",
              _vm._b(
                {
                  staticClass: "el-range-input",
                  attrs: {
                    autocomplete: "off",
                    placeholder: _vm.endPlaceholder,
                    disabled: _vm.pickerDisabled,
                    readonly: !_vm.editable || _vm.readonly,
                    name: _vm.name && _vm.name[1]
                  },
                  domProps: { value: _vm.displayValue && _vm.displayValue[1] },
                  on: {
                    input: _vm.handleEndInput,
                    change: _vm.handleEndChange,
                    focus: _vm.handleFocus
                  }
                },
                "input",
                _vm.secondInputId,
                false
              )
            ),
            _vm.haveTrigger
              ? _c("i", {
                  staticClass: "el-input__icon el-range__close-icon",
                  class: [_vm.showClose ? "" + _vm.clearIcon : ""],
                  on: { click: _vm.handleClickIcon }
                })
              : _vm._e()
          ],
          2
        )
  }
  var staticRenderFns = []
  render._withStripped = true
  
  
  // CONCATENATED MODULE: ./packages/date-picker/src/picker.vue?vue&type=template&id=79ae069f&
  
  // EXTERNAL MODULE: external "vue"
  var external_vue_ = __webpack_require__(7);
  var external_vue_default = /*#__PURE__*/__webpack_require__.n(external_vue_);
  
  // EXTERNAL MODULE: external "element-mini-ui/lib/utils/clickoutside"
  var clickoutside_ = __webpack_require__(11);
  var clickoutside_default = /*#__PURE__*/__webpack_require__.n(clickoutside_);
  
  // EXTERNAL MODULE: external "element-mini-ui/lib/utils/date-util"
  var date_util_ = __webpack_require__(0);
  
  // EXTERNAL MODULE: external "element-mini-ui/lib/utils/vue-popper"
  var vue_popper_ = __webpack_require__(5);
  var vue_popper_default = /*#__PURE__*/__webpack_require__.n(vue_popper_);
  
  // EXTERNAL MODULE: external "element-mini-ui/lib/mixins/emitter"
  var emitter_ = __webpack_require__(4);
  var emitter_default = /*#__PURE__*/__webpack_require__.n(emitter_);
  
  // EXTERNAL MODULE: external "element-mini-ui/lib/input"
  var input_ = __webpack_require__(10);
  var input_default = /*#__PURE__*/__webpack_require__.n(input_);
  
  // EXTERNAL MODULE: external "element-mini-ui/lib/utils/merge"
  var merge_ = __webpack_require__(8);
  var merge_default = /*#__PURE__*/__webpack_require__.n(merge_);
  
  // CONCATENATED MODULE: ./node_modules/_babel-loader@7.1.5@babel-loader/lib!./node_modules/_vue-loader@15.8.3@vue-loader/lib??vue-loader-options!./packages/date-picker/src/picker.vue?vue&type=script&lang=js&
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  
  
  
  
  
  
  
  
  
  var NewPopper = {
    props: {
      appendToBody: vue_popper_default.a.props.appendToBody,
      offset: vue_popper_default.a.props.offset,
      boundariesPadding: vue_popper_default.a.props.boundariesPadding,
      arrowOffset: vue_popper_default.a.props.arrowOffset
    },
    methods: vue_popper_default.a.methods,
    data: function data() {
      return merge_default()({ visibleArrow: true }, vue_popper_default.a.data);
    },
  
    beforeDestroy: vue_popper_default.a.beforeDestroy
  };
  
  var DEFAULT_FORMATS = {
    date: 'yyyy-MM-dd',
    month: 'yyyy-MM',
    datetime: 'yyyy-MM-dd HH:mm:ss',
    time: 'HH:mm:ss',
    week: 'yyyywWW',
    timerange: 'HH:mm:ss',
    daterange: 'yyyy-MM-dd',
    monthrange: 'yyyy-MM',
    datetimerange: 'yyyy-MM-dd HH:mm:ss',
    year: 'yyyy'
  };
  var HAVE_TRIGGER_TYPES = ['date', 'datetime', 'time', 'time-select', 'week', 'month', 'year', 'daterange', 'monthrange', 'timerange', 'datetimerange', 'dates'];
  var pickervue_type_script_lang_js_DATE_FORMATTER = function DATE_FORMATTER(value, format) {
    if (format === 'timestamp') return value.getTime();
    return Object(date_util_["formatDate"])(value, format);
  };
  var pickervue_type_script_lang_js_DATE_PARSER = function DATE_PARSER(text, format) {
    if (format === 'timestamp') return new Date(Number(text));
    return Object(date_util_["parseDate"])(text, format);
  };
  var RANGE_FORMATTER = function RANGE_FORMATTER(value, format) {
    if (Array.isArray(value) && value.length === 2) {
      var start = value[0];
      var end = value[1];
  
      if (start && end) {
        return [pickervue_type_script_lang_js_DATE_FORMATTER(start, format), pickervue_type_script_lang_js_DATE_FORMATTER(end, format)];
      }
    }
    return '';
  };
  var RANGE_PARSER = function RANGE_PARSER(array, format, separator) {
    if (!Array.isArray(array)) {
      array = array.split(separator);
    }
    if (array.length === 2) {
      var range1 = array[0];
      var range2 = array[1];
  
      return [pickervue_type_script_lang_js_DATE_PARSER(range1, format), pickervue_type_script_lang_js_DATE_PARSER(range2, format)];
    }
    return [];
  };
  var TYPE_VALUE_RESOLVER_MAP = {
    default: {
      formatter: function formatter(value) {
        if (!value) return '';
        return '' + value;
      },
      parser: function parser(text) {
        if (text === undefined || text === '') return null;
        return text;
      }
    },
    week: {
      formatter: function formatter(value, format) {
        var week = Object(date_util_["getWeekNumber"])(value);
        var month = value.getMonth();
        var trueDate = new Date(value);
        if (week === 1 && month === 11) {
          trueDate.setHours(0, 0, 0, 0);
          trueDate.setDate(trueDate.getDate() + 3 - (trueDate.getDay() + 6) % 7);
        }
        var date = Object(date_util_["formatDate"])(trueDate, format);
  
        date = /WW/.test(date) ? date.replace(/WW/, week < 10 ? '0' + week : week) : date.replace(/W/, week);
        return date;
      },
      parser: function parser(text, format) {
        // parse as if a normal date
        return TYPE_VALUE_RESOLVER_MAP.date.parser(text, format);
      }
    },
    date: {
      formatter: pickervue_type_script_lang_js_DATE_FORMATTER,
      parser: pickervue_type_script_lang_js_DATE_PARSER
    },
    datetime: {
      formatter: pickervue_type_script_lang_js_DATE_FORMATTER,
      parser: pickervue_type_script_lang_js_DATE_PARSER
    },
    daterange: {
      formatter: RANGE_FORMATTER,
      parser: RANGE_PARSER
    },
    monthrange: {
      formatter: RANGE_FORMATTER,
      parser: RANGE_PARSER
    },
    datetimerange: {
      formatter: RANGE_FORMATTER,
      parser: RANGE_PARSER
    },
    timerange: {
      formatter: RANGE_FORMATTER,
      parser: RANGE_PARSER
    },
    time: {
      formatter: pickervue_type_script_lang_js_DATE_FORMATTER,
      parser: pickervue_type_script_lang_js_DATE_PARSER
    },
    month: {
      formatter: pickervue_type_script_lang_js_DATE_FORMATTER,
      parser: pickervue_type_script_lang_js_DATE_PARSER
    },
    year: {
      formatter: pickervue_type_script_lang_js_DATE_FORMATTER,
      parser: pickervue_type_script_lang_js_DATE_PARSER
    },
    number: {
      formatter: function formatter(value) {
        if (!value) return '';
        return '' + value;
      },
      parser: function parser(text) {
        var result = Number(text);
  
        if (!isNaN(text)) {
          return result;
        } else {
          return null;
        }
      }
    },
    dates: {
      formatter: function formatter(value, format) {
        return value.map(function (date) {
          return pickervue_type_script_lang_js_DATE_FORMATTER(date, format);
        });
      },
      parser: function parser(value, format) {
        return (typeof value === 'string' ? value.split(', ') : value).map(function (date) {
          return date instanceof Date ? date : pickervue_type_script_lang_js_DATE_PARSER(date, format);
        });
      }
    }
  };
  var PLACEMENT_MAP = {
    left: 'bottom-start',
    center: 'bottom',
    right: 'bottom-end'
  };
  
  var parseAsFormatAndType = function parseAsFormatAndType(value, customFormat, type) {
    var rangeSeparator = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : '-';
  
    if (!value) return null;
    var parser = (TYPE_VALUE_RESOLVER_MAP[type] || TYPE_VALUE_RESOLVER_MAP['default']).parser;
    var format = customFormat || DEFAULT_FORMATS[type];
    return parser(value, format, rangeSeparator);
  };
  
  var formatAsFormatAndType = function formatAsFormatAndType(value, customFormat, type) {
    if (!value) return null;
    var formatter = (TYPE_VALUE_RESOLVER_MAP[type] || TYPE_VALUE_RESOLVER_MAP['default']).formatter;
    var format = customFormat || DEFAULT_FORMATS[type];
    return formatter(value, format);
  };
  
  /*
   * Considers:
   *   1. Date object
   *   2. date string
   *   3. array of 1 or 2
   */
  var valueEquals = function valueEquals(a, b) {
    // considers Date object and string
    var dateEquals = function dateEquals(a, b) {
      var aIsDate = a instanceof Date;
      var bIsDate = b instanceof Date;
      if (aIsDate && bIsDate) {
        return a.getTime() === b.getTime();
      }
      if (!aIsDate && !bIsDate) {
        return a === b;
      }
      return false;
    };
  
    var aIsArray = a instanceof Array;
    var bIsArray = b instanceof Array;
    if (aIsArray && bIsArray) {
      if (a.length !== b.length) {
        return false;
      }
      return a.every(function (item, index) {
        return dateEquals(item, b[index]);
      });
    }
    if (!aIsArray && !bIsArray) {
      return dateEquals(a, b);
    }
    return false;
  };
  
  var isString = function isString(val) {
    return typeof val === 'string' || val instanceof String;
  };
  
  var validator = function validator(val) {
    // either: String, Array of String, null / undefined
    return val === null || val === undefined || isString(val) || Array.isArray(val) && val.length === 2 && val.every(isString);
  };
  
  /* harmony default export */ var pickervue_type_script_lang_js_ = ({
    mixins: [emitter_default.a, NewPopper],
  
    inject: {
      elForm: {
        default: ''
      },
      elFormItem: {
        default: ''
      }
    },
  
    props: {
      size: String,
      format: String,
      valueFormat: String,
      readonly: Boolean,
      placeholder: String,
      startPlaceholder: String,
      endPlaceholder: String,
      prefixIcon: String,
      clearIcon: {
        type: String,
        default: 'el-icon-circle-close'
      },
      name: {
        default: '',
        validator: validator
      },
      disabled: Boolean,
      clearable: {
        type: Boolean,
        default: true
      },
      id: {
        default: '',
        validator: validator
      },
      popperClass: String,
      editable: {
        type: Boolean,
        default: true
      },
      align: {
        type: String,
        default: 'left'
      },
      value: {},
      defaultValue: {},
      defaultTime: {},
      rangeSeparator: {
        default: '-'
      },
      pickerOptions: {},
      unlinkPanels: Boolean,
      validateEvent: {
        type: Boolean,
        default: true
      }
    },
  
    components: { ElInput: input_default.a },
  
    directives: { Clickoutside: clickoutside_default.a },
  
    data: function data() {
      return {
        pickerVisible: false,
        showClose: false,
        userInput: null,
        valueOnOpen: null, // value when picker opens, used to determine whether to emit change
        unwatchPickerOptions: null
      };
    },
  
  
    watch: {
      pickerVisible: function pickerVisible(val) {
        if (this.readonly || this.pickerDisabled) return;
        if (val) {
          this.showPicker();
          this.valueOnOpen = Array.isArray(this.value) ? [].concat(this.value) : this.value;
        } else {
          this.hidePicker();
          this.emitChange(this.value);
          this.userInput = null;
          if (this.validateEvent) {
            this.dispatch('ElFormItem', 'el.form.blur');
          }
          this.$emit('blur', this);
          this.blur();
        }
      },
  
      parsedValue: {
        immediate: true,
        handler: function handler(val) {
          if (this.picker) {
            this.picker.value = val;
          }
        }
      },
      defaultValue: function defaultValue(val) {
        // NOTE: should eventually move to jsx style picker + panel ?
        if (this.picker) {
          this.picker.defaultValue = val;
        }
      },
      value: function value(val, oldVal) {
        if (!valueEquals(val, oldVal) && !this.pickerVisible && this.validateEvent) {
          this.dispatch('ElFormItem', 'el.form.change', val);
        }
      }
    },
  
    computed: {
      ranged: function ranged() {
        return this.type.indexOf('range') > -1;
      },
      reference: function reference() {
        var reference = this.$refs.reference;
        return reference.$el || reference;
      },
      refInput: function refInput() {
        if (this.reference) {
          return [].slice.call(this.reference.querySelectorAll('input'));
        }
        return [];
      },
      valueIsEmpty: function valueIsEmpty() {
        var val = this.value;
        if (Array.isArray(val)) {
          for (var i = 0, len = val.length; i < len; i++) {
            if (val[i]) {
              return false;
            }
          }
        } else {
          if (val) {
            return false;
          }
        }
        return true;
      },
      triggerClass: function triggerClass() {
        return this.prefixIcon || (this.type.indexOf('time') !== -1 ? 'el-icon-time' : 'el-icon-date');
      },
      selectionMode: function selectionMode() {
        if (this.type === 'week') {
          return 'week';
        } else if (this.type === 'month') {
          return 'month';
        } else if (this.type === 'year') {
          return 'year';
        } else if (this.type === 'dates') {
          return 'dates';
        }
  
        return 'day';
      },
      haveTrigger: function haveTrigger() {
        if (typeof this.showTrigger !== 'undefined') {
          return this.showTrigger;
        }
        return HAVE_TRIGGER_TYPES.indexOf(this.type) !== -1;
      },
      displayValue: function displayValue() {
        var formattedValue = formatAsFormatAndType(this.parsedValue, this.format, this.type, this.rangeSeparator);
        if (Array.isArray(this.userInput)) {
          return [this.userInput[0] || formattedValue && formattedValue[0] || '', this.userInput[1] || formattedValue && formattedValue[1] || ''];
        } else if (this.userInput !== null) {
          return this.userInput;
        } else if (formattedValue) {
          return this.type === 'dates' ? formattedValue.join(', ') : formattedValue;
        } else {
          return '';
        }
      },
      parsedValue: function parsedValue() {
        if (!this.value) return this.value; // component value is not set
        if (this.type === 'time-select') return this.value; // time-select does not require parsing, this might change in next major version
  
        var valueIsDateObject = Object(date_util_["isDateObject"])(this.value) || Array.isArray(this.value) && this.value.every(date_util_["isDateObject"]);
        if (valueIsDateObject) {
          return this.value;
        }
  
        if (this.valueFormat) {
          return parseAsFormatAndType(this.value, this.valueFormat, this.type, this.rangeSeparator) || this.value;
        }
  
        // NOTE: deal with common but incorrect usage, should remove in next major version
        // user might provide string / timestamp without value-format, coerce them into date (or array of date)
        return Array.isArray(this.value) ? this.value.map(function (val) {
          return new Date(val);
        }) : new Date(this.value);
      },
      _elFormItemSize: function _elFormItemSize() {
        return (this.elFormItem || {}).elFormItemSize;
      },
      pickerSize: function pickerSize() {
        return this.size || this._elFormItemSize || (this.$ELEMENT || {}).size;
      },
      pickerDisabled: function pickerDisabled() {
        return this.disabled || (this.elForm || {}).disabled;
      },
      firstInputId: function firstInputId() {
        var obj = {};
        var id = void 0;
        if (this.ranged) {
          id = this.id && this.id[0];
        } else {
          id = this.id;
        }
        if (id) obj.id = id;
        return obj;
      },
      secondInputId: function secondInputId() {
        var obj = {};
        var id = void 0;
        if (this.ranged) {
          id = this.id && this.id[1];
        }
        if (id) obj.id = id;
        return obj;
      }
    },
  
    created: function created() {
      // vue-popper
      this.popperOptions = {
        boundariesPadding: 0,
        gpuAcceleration: false
      };
      this.placement = PLACEMENT_MAP[this.align] || PLACEMENT_MAP.left;
  
      this.$on('fieldReset', this.handleFieldReset);
    },
  
  
    methods: {
      focus: function focus() {
        if (!this.ranged) {
          this.$refs.reference.focus();
        } else {
          this.handleFocus();
        }
      },
      blur: function blur() {
        this.refInput.forEach(function (input) {
          return input.blur();
        });
      },
  
  
      // {parse, formatTo} Value deals maps component value with internal Date
      parseValue: function parseValue(value) {
        var isParsed = Object(date_util_["isDateObject"])(value) || Array.isArray(value) && value.every(date_util_["isDateObject"]);
        if (this.valueFormat && !isParsed) {
          return parseAsFormatAndType(value, this.valueFormat, this.type, this.rangeSeparator) || value;
        } else {
          return value;
        }
      },
      formatToValue: function formatToValue(date) {
        var isFormattable = Object(date_util_["isDateObject"])(date) || Array.isArray(date) && date.every(date_util_["isDateObject"]);
        if (this.valueFormat && isFormattable) {
          return formatAsFormatAndType(date, this.valueFormat, this.type, this.rangeSeparator);
        } else {
          return date;
        }
      },
  
  
      // {parse, formatTo} String deals with user input
      parseString: function parseString(value) {
        var type = Array.isArray(value) ? this.type : this.type.replace('range', '');
        return parseAsFormatAndType(value, this.format, type);
      },
      formatToString: function formatToString(value) {
        var type = Array.isArray(value) ? this.type : this.type.replace('range', '');
        return formatAsFormatAndType(value, this.format, type);
      },
      handleMouseEnter: function handleMouseEnter() {
        if (this.readonly || this.pickerDisabled) return;
        if (!this.valueIsEmpty && this.clearable) {
          this.showClose = true;
        }
      },
      handleChange: function handleChange() {
        if (this.userInput) {
          var value = this.parseString(this.displayValue);
          if (value) {
            this.picker.value = value;
            if (this.isValidValue(value)) {
              this.emitInput(value);
              this.userInput = null;
            }
          }
        }
        if (this.userInput === '') {
          this.emitInput(null);
          this.emitChange(null);
          this.userInput = null;
        }
      },
      handleStartInput: function handleStartInput(event) {
        if (this.userInput) {
          this.userInput = [event.target.value, this.userInput[1]];
        } else {
          this.userInput = [event.target.value, null];
        }
      },
      handleEndInput: function handleEndInput(event) {
        if (this.userInput) {
          this.userInput = [this.userInput[0], event.target.value];
        } else {
          this.userInput = [null, event.target.value];
        }
      },
      handleStartChange: function handleStartChange(event) {
        var value = this.parseString(this.userInput && this.userInput[0]);
        if (value) {
          this.userInput = [this.formatToString(value), this.displayValue[1]];
          var newValue = [value, this.picker.value && this.picker.value[1]];
          this.picker.value = newValue;
          if (this.isValidValue(newValue)) {
            this.emitInput(newValue);
            this.userInput = null;
          }
        }
      },
      handleEndChange: function handleEndChange(event) {
        var value = this.parseString(this.userInput && this.userInput[1]);
        if (value) {
          this.userInput = [this.displayValue[0], this.formatToString(value)];
          var newValue = [this.picker.value && this.picker.value[0], value];
          this.picker.value = newValue;
          if (this.isValidValue(newValue)) {
            this.emitInput(newValue);
            this.userInput = null;
          }
        }
      },
      handleClickIcon: function handleClickIcon(event) {
        if (this.readonly || this.pickerDisabled) return;
        if (this.showClose) {
          this.valueOnOpen = this.value;
          event.stopPropagation();
          this.emitInput(null);
          this.emitChange(null);
          this.showClose = false;
          if (this.picker && typeof this.picker.handleClear === 'function') {
            this.picker.handleClear();
          }
        } else {
          this.pickerVisible = !this.pickerVisible;
        }
      },
      handleClose: function handleClose() {
        if (!this.pickerVisible) return;
        this.pickerVisible = false;
  
        if (this.type === 'dates') {
          // restore to former value
          var oldValue = parseAsFormatAndType(this.valueOnOpen, this.valueFormat, this.type, this.rangeSeparator) || this.valueOnOpen;
          this.emitInput(oldValue);
        }
      },
      handleFieldReset: function handleFieldReset(initialValue) {
        this.userInput = initialValue === '' ? null : initialValue;
      },
      handleFocus: function handleFocus() {
        var type = this.type;
  
        if (HAVE_TRIGGER_TYPES.indexOf(type) !== -1 && !this.pickerVisible) {
          this.pickerVisible = true;
        }
        this.$emit('focus', this);
      },
      handleKeydown: function handleKeydown(event) {
        var _this = this;
  
        var keyCode = event.keyCode;
  
        // ESC
        if (keyCode === 27) {
          this.pickerVisible = false;
          event.stopPropagation();
          return;
        }
  
        // Tab
        if (keyCode === 9) {
          if (!this.ranged) {
            this.handleChange();
            this.pickerVisible = this.picker.visible = false;
            this.blur();
            event.stopPropagation();
          } else {
            // user may change focus between two input
            setTimeout(function () {
              if (_this.refInput.indexOf(document.activeElement) === -1) {
                _this.pickerVisible = false;
                _this.blur();
                event.stopPropagation();
              }
            }, 0);
          }
          return;
        }
  
        // Enter
        if (keyCode === 13) {
          if (this.userInput === '' || this.isValidValue(this.parseString(this.displayValue))) {
            this.handleChange();
            this.pickerVisible = this.picker.visible = false;
            this.blur();
          }
          event.stopPropagation();
          return;
        }
  
        // if user is typing, do not let picker handle key input
        if (this.userInput) {
          event.stopPropagation();
          return;
        }
  
        // delegate other keys to panel
        if (this.picker && this.picker.handleKeydown) {
          this.picker.handleKeydown(event);
        }
      },
      handleRangeClick: function handleRangeClick() {
        var type = this.type;
  
        if (HAVE_TRIGGER_TYPES.indexOf(type) !== -1 && !this.pickerVisible) {
          this.pickerVisible = true;
        }
        this.$emit('focus', this);
      },
      hidePicker: function hidePicker() {
        if (this.picker) {
          this.picker.resetView && this.picker.resetView();
          this.pickerVisible = this.picker.visible = false;
          this.destroyPopper();
        }
      },
      showPicker: function showPicker() {
        var _this2 = this;
  
        if (this.$isServer) return;
        if (!this.picker) {
          this.mountPicker();
        }
        this.pickerVisible = this.picker.visible = true;
  
        this.updatePopper();
  
        this.picker.value = this.parsedValue;
        this.picker.resetView && this.picker.resetView();
  
        this.$nextTick(function () {
          _this2.picker.adjustSpinners && _this2.picker.adjustSpinners();
        });
      },
      mountPicker: function mountPicker() {
        var _this3 = this;
  
        this.picker = new external_vue_default.a(this.panel).$mount();
        this.picker.defaultValue = this.defaultValue;
        this.picker.defaultTime = this.defaultTime;
        this.picker.popperClass = this.popperClass;
        this.popperElm = this.picker.$el;
        this.picker.width = this.reference.getBoundingClientRect().width;
        this.picker.showTime = this.type === 'datetime' || this.type === 'datetimerange';
        this.picker.selectionMode = this.selectionMode;
        this.picker.unlinkPanels = this.unlinkPanels;
        this.picker.arrowControl = this.arrowControl || this.timeArrowControl || false;
        this.$watch('format', function (format) {
          _this3.picker.format = format;
        });
  
        var updateOptions = function updateOptions() {
          var options = _this3.pickerOptions;
  
          if (options && options.selectableRange) {
            var ranges = options.selectableRange;
            var parser = TYPE_VALUE_RESOLVER_MAP.datetimerange.parser;
            var format = DEFAULT_FORMATS.timerange;
  
            ranges = Array.isArray(ranges) ? ranges : [ranges];
            _this3.picker.selectableRange = ranges.map(function (range) {
              return parser(range, format, _this3.rangeSeparator);
            });
          }
  
          for (var option in options) {
            if (options.hasOwnProperty(option) &&
            // 忽略 time-picker 的该配置项
            option !== 'selectableRange') {
              _this3.picker[option] = options[option];
            }
          }
  
          // main format must prevail over undocumented pickerOptions.format
          if (_this3.format) {
            _this3.picker.format = _this3.format;
          }
        };
        updateOptions();
        this.unwatchPickerOptions = this.$watch('pickerOptions', function () {
          return updateOptions();
        }, { deep: true });
        this.$el.appendChild(this.picker.$el);
        this.picker.resetView && this.picker.resetView();
  
        this.picker.$on('dodestroy', this.doDestroy);
        this.picker.$on('pick', function () {
          var date = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
          var visible = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
  
          _this3.userInput = null;
          _this3.pickerVisible = _this3.picker.visible = visible;
          _this3.emitInput(date);
          _this3.picker.resetView && _this3.picker.resetView();
        });
  
        this.picker.$on('select-range', function (start, end, pos) {
          if (_this3.refInput.length === 0) return;
          if (!pos || pos === 'min') {
            _this3.refInput[0].setSelectionRange(start, end);
            _this3.refInput[0].focus();
          } else if (pos === 'max') {
            _this3.refInput[1].setSelectionRange(start, end);
            _this3.refInput[1].focus();
          }
        });
      },
      unmountPicker: function unmountPicker() {
        if (this.picker) {
          this.picker.$destroy();
          this.picker.$off();
          if (typeof this.unwatchPickerOptions === 'function') {
            this.unwatchPickerOptions();
          }
          this.picker.$el.parentNode.removeChild(this.picker.$el);
        }
      },
      emitChange: function emitChange(val) {
        // determine user real change only
        if (!valueEquals(val, this.valueOnOpen)) {
          this.$emit('change', val);
          this.valueOnOpen = val;
          if (this.validateEvent) {
            this.dispatch('ElFormItem', 'el.form.change', val);
          }
        }
      },
      emitInput: function emitInput(val) {
        var formatted = this.formatToValue(val);
        if (!valueEquals(this.value, formatted)) {
          this.$emit('input', formatted);
        }
      },
      isValidValue: function isValidValue(value) {
        if (!this.picker) {
          this.mountPicker();
        }
        if (this.picker.isValidValue) {
          return value && this.picker.isValidValue(value);
        } else {
          return true;
        }
      }
    }
  });
  // CONCATENATED MODULE: ./packages/date-picker/src/picker.vue?vue&type=script&lang=js&
   /* harmony default export */ var src_pickervue_type_script_lang_js_ = (pickervue_type_script_lang_js_); 
  // EXTERNAL MODULE: ./node_modules/_vue-loader@15.8.3@vue-loader/lib/runtime/componentNormalizer.js
  var componentNormalizer = __webpack_require__(1);
  
  // CONCATENATED MODULE: ./packages/date-picker/src/picker.vue
  
  
  
  
  
  /* normalize component */
  
  var component = Object(componentNormalizer["a" /* default */])(
    src_pickervue_type_script_lang_js_,
    render,
    staticRenderFns,
    false,
    null,
    null,
    null
    
  )
  
  /* hot reload */
  if (false) { var api; }
  component.options.__file = "packages/date-picker/src/picker.vue"
  /* harmony default export */ var picker = __webpack_exports__["a"] = (component.exports);
  
  /***/ }),
  
  /***/ 27:
  /***/ (function(module, exports) {
  
  module.exports = require("element-mini-ui/lib/utils/scroll-into-view");
  
  /***/ }),
  
  /***/ 4:
  /***/ (function(module, exports) {
  
  module.exports = require("element-mini-ui/lib/mixins/emitter");
  
  /***/ }),
  
  /***/ 5:
  /***/ (function(module, exports) {
  
  module.exports = require("element-mini-ui/lib/utils/vue-popper");
  
  /***/ }),
  
  /***/ 57:
  /***/ (function(module, __webpack_exports__, __webpack_require__) {
  
  "use strict";
  __webpack_require__.r(__webpack_exports__);
  
  // EXTERNAL MODULE: ./packages/date-picker/src/picker.vue + 4 modules
  var picker = __webpack_require__(24);
  
  // CONCATENATED MODULE: ./node_modules/_vue-loader@15.8.3@vue-loader/lib/loaders/templateLoader.js??vue-loader-options!./node_modules/_vue-loader@15.8.3@vue-loader/lib??vue-loader-options!./packages/date-picker/src/panel/time-select.vue?vue&type=template&id=51ab9320&
  var render = function() {
    var _vm = this
    var _h = _vm.$createElement
    var _c = _vm._self._c || _h
    return _c(
      "transition",
      {
        attrs: { name: "el-zoom-in-top" },
        on: {
          "before-enter": _vm.handleMenuEnter,
          "after-leave": function($event) {
            return _vm.$emit("dodestroy")
          }
        }
      },
      [
        _c(
          "div",
          {
            directives: [
              {
                name: "show",
                rawName: "v-show",
                value: _vm.visible,
                expression: "visible"
              }
            ],
            ref: "popper",
            staticClass: "el-picker-panel time-select el-popper",
            class: _vm.popperClass,
            style: { width: _vm.width + "px" }
          },
          [
            _c(
              "el-scrollbar",
              {
                attrs: { noresize: "", "wrap-class": "el-picker-panel__content" }
              },
              _vm._l(_vm.items, function(item) {
                return _c(
                  "div",
                  {
                    key: item.value,
                    staticClass: "time-select-item",
                    class: {
                      selected: _vm.value === item.value,
                      disabled: item.disabled,
                      default: item.value === _vm.defaultValue
                    },
                    attrs: { disabled: item.disabled },
                    on: {
                      click: function($event) {
                        return _vm.handleClick(item)
                      }
                    }
                  },
                  [_vm._v(_vm._s(item.value))]
                )
              }),
              0
            )
          ],
          1
        )
      ]
    )
  }
  var staticRenderFns = []
  render._withStripped = true
  
  
  // CONCATENATED MODULE: ./packages/date-picker/src/panel/time-select.vue?vue&type=template&id=51ab9320&
  
  // EXTERNAL MODULE: external "element-mini-ui/lib/scrollbar"
  var scrollbar_ = __webpack_require__(16);
  var scrollbar_default = /*#__PURE__*/__webpack_require__.n(scrollbar_);
  
  // EXTERNAL MODULE: external "element-mini-ui/lib/utils/scroll-into-view"
  var scroll_into_view_ = __webpack_require__(27);
  var scroll_into_view_default = /*#__PURE__*/__webpack_require__.n(scroll_into_view_);
  
  // CONCATENATED MODULE: ./node_modules/_babel-loader@7.1.5@babel-loader/lib!./node_modules/_vue-loader@15.8.3@vue-loader/lib??vue-loader-options!./packages/date-picker/src/panel/time-select.vue?vue&type=script&lang=js&
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  //
  
  
  
  
  var parseTime = function parseTime(time) {
    var values = (time || '').split(':');
    if (values.length >= 2) {
      var hours = parseInt(values[0], 10);
      var minutes = parseInt(values[1], 10);
  
      return {
        hours: hours,
        minutes: minutes
      };
    }
    /* istanbul ignore next */
    return null;
  };
  
  var compareTime = function compareTime(time1, time2) {
    var value1 = parseTime(time1);
    var value2 = parseTime(time2);
  
    var minutes1 = value1.minutes + value1.hours * 60;
    var minutes2 = value2.minutes + value2.hours * 60;
  
    if (minutes1 === minutes2) {
      return 0;
    }
  
    return minutes1 > minutes2 ? 1 : -1;
  };
  
  var formatTime = function formatTime(time) {
    return (time.hours < 10 ? '0' + time.hours : time.hours) + ':' + (time.minutes < 10 ? '0' + time.minutes : time.minutes);
  };
  
  var nextTime = function nextTime(time, step) {
    var timeValue = parseTime(time);
    var stepValue = parseTime(step);
  
    var next = {
      hours: timeValue.hours,
      minutes: timeValue.minutes
    };
  
    next.minutes += stepValue.minutes;
    next.hours += stepValue.hours;
  
    next.hours += Math.floor(next.minutes / 60);
    next.minutes = next.minutes % 60;
  
    return formatTime(next);
  };
  
  /* harmony default export */ var time_selectvue_type_script_lang_js_ = ({
    components: { ElScrollbar: scrollbar_default.a },
  
    watch: {
      value: function value(val) {
        var _this = this;
  
        if (!val) return;
        this.$nextTick(function () {
          return _this.scrollToOption();
        });
      }
    },
  
    methods: {
      handleClick: function handleClick(item) {
        if (!item.disabled) {
          this.$emit('pick', item.value);
        }
      },
      handleClear: function handleClear() {
        this.$emit('pick', null);
      },
      scrollToOption: function scrollToOption() {
        var selector = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '.selected';
  
        var menu = this.$refs.popper.querySelector('.el-picker-panel__content');
        scroll_into_view_default()(menu, menu.querySelector(selector));
      },
      handleMenuEnter: function handleMenuEnter() {
        var _this2 = this;
  
        var selected = this.items.map(function (item) {
          return item.value;
        }).indexOf(this.value) !== -1;
        var hasDefault = this.items.map(function (item) {
          return item.value;
        }).indexOf(this.defaultValue) !== -1;
        var option = selected && '.selected' || hasDefault && '.default' || '.time-select-item:not(.disabled)';
        this.$nextTick(function () {
          return _this2.scrollToOption(option);
        });
      },
      scrollDown: function scrollDown(step) {
        var items = this.items;
        var length = items.length;
        var total = items.length;
        var index = items.map(function (item) {
          return item.value;
        }).indexOf(this.value);
        while (total--) {
          index = (index + step + length) % length;
          if (!items[index].disabled) {
            this.$emit('pick', items[index].value, true);
            return;
          }
        }
      },
      isValidValue: function isValidValue(date) {
        return this.items.filter(function (item) {
          return !item.disabled;
        }).map(function (item) {
          return item.value;
        }).indexOf(date) !== -1;
      },
      handleKeydown: function handleKeydown(event) {
        var keyCode = event.keyCode;
        if (keyCode === 38 || keyCode === 40) {
          var mapping = { 40: 1, 38: -1 };
          var offset = mapping[keyCode.toString()];
          this.scrollDown(offset);
          event.stopPropagation();
          return;
        }
      }
    },
  
    data: function data() {
      return {
        popperClass: '',
        start: '09:00',
        end: '18:00',
        step: '00:30',
        value: '',
        defaultValue: '',
        visible: false,
        minTime: '',
        maxTime: '',
        width: 0
      };
    },
  
  
    computed: {
      items: function items() {
        var start = this.start;
        var end = this.end;
        var step = this.step;
  
        var result = [];
  
        if (start && end && step) {
          var current = start;
          while (compareTime(current, end) <= 0) {
            result.push({
              value: current,
              disabled: compareTime(current, this.minTime || '-1:-1') <= 0 || compareTime(current, this.maxTime || '100:100') >= 0
            });
            current = nextTime(current, step);
          }
        }
  
        return result;
      }
    }
  });
  // CONCATENATED MODULE: ./packages/date-picker/src/panel/time-select.vue?vue&type=script&lang=js&
   /* harmony default export */ var panel_time_selectvue_type_script_lang_js_ = (time_selectvue_type_script_lang_js_); 
  // EXTERNAL MODULE: ./node_modules/_vue-loader@15.8.3@vue-loader/lib/runtime/componentNormalizer.js
  var componentNormalizer = __webpack_require__(1);
  
  // CONCATENATED MODULE: ./packages/date-picker/src/panel/time-select.vue
  
  
  
  
  
  /* normalize component */
  
  var component = Object(componentNormalizer["a" /* default */])(
    panel_time_selectvue_type_script_lang_js_,
    render,
    staticRenderFns,
    false,
    null,
    null,
    null
    
  )
  
  /* hot reload */
  if (false) { var api; }
  component.options.__file = "packages/date-picker/src/panel/time-select.vue"
  /* harmony default export */ var time_select = (component.exports);
  // CONCATENATED MODULE: ./packages/date-picker/src/picker/time-select.js
  
  
  
  /* harmony default export */ var picker_time_select = ({
    mixins: [picker["a" /* default */]],
  
    name: 'ElTimeSelect',
  
    componentName: 'ElTimeSelect',
  
    props: {
      type: {
        type: String,
        default: 'time-select'
      }
    },
  
    beforeCreate: function beforeCreate() {
      this.panel = time_select;
    }
  });
  // CONCATENATED MODULE: ./packages/time-select/index.js
  
  
  /* istanbul ignore next */
  picker_time_select.install = function (Vue) {
    Vue.component(picker_time_select.name, picker_time_select);
  };
  
  /* harmony default export */ var packages_time_select = __webpack_exports__["default"] = (picker_time_select);
  
  /***/ }),
  
  /***/ 7:
  /***/ (function(module, exports) {
  
  module.exports = require("vue");
  
  /***/ }),
  
  /***/ 8:
  /***/ (function(module, exports) {
  
  module.exports = require("element-mini-ui/lib/utils/merge");
  
  /***/ })
  
  /******/ });