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] = {
/******/ 			exports: {},
/******/ 			id: moduleId,
/******/ 			loaded: false
/******/ 		};

/******/ 		// Execute the module function
/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);

/******/ 		// Flag the module as loaded
/******/ 		module.loaded = 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;

/******/ 	// __webpack_public_path__
/******/ 	__webpack_require__.p = "/dist/";

/******/ 	// Load entry module and return exports
/******/ 	return __webpack_require__(0);
/******/ })
/************************************************************************/
/******/ ({

/***/ 0:
/***/ (function(module, exports, __webpack_require__) {

	module.exports = __webpack_require__(159);


/***/ }),

/***/ 3:
/***/ (function(module, exports) {

	/* globals __VUE_SSR_CONTEXT__ */

	// this module is a runtime utility for cleaner component module output and will
	// be included in the final webpack user bundle

	module.exports = function normalizeComponent (
	  rawScriptExports,
	  compiledTemplate,
	  injectStyles,
	  scopeId,
	  moduleIdentifier /* server only */
	) {
	  var esModule
	  var scriptExports = rawScriptExports = rawScriptExports || {}

	  // ES6 modules interop
	  var type = typeof rawScriptExports.default
	  if (type === 'object' || type === 'function') {
	    esModule = rawScriptExports
	    scriptExports = rawScriptExports.default
	  }

	  // Vue.extend constructor export interop
	  var options = typeof scriptExports === 'function'
	    ? scriptExports.options
	    : scriptExports

	  // render functions
	  if (compiledTemplate) {
	    options.render = compiledTemplate.render
	    options.staticRenderFns = compiledTemplate.staticRenderFns
	  }

	  // scopedId
	  if (scopeId) {
	    options._scopeId = scopeId
	  }

	  var hook
	  if (moduleIdentifier) { // server build
	    hook = function (context) {
	      // 2.3 injection
	      context =
	        context || // cached call
	        (this.$vnode && this.$vnode.ssrContext) || // stateful
	        (this.parent && this.parent.$vnode && this.parent.$vnode.ssrContext) // functional
	      // 2.2 with runInNewContext: true
	      if (!context && typeof __VUE_SSR_CONTEXT__ !== 'undefined') {
	        context = __VUE_SSR_CONTEXT__
	      }
	      // inject component styles
	      if (injectStyles) {
	        injectStyles.call(this, context)
	      }
	      // register component module identifier for async chunk inferrence
	      if (context && context._registeredComponents) {
	        context._registeredComponents.add(moduleIdentifier)
	      }
	    }
	    // used by ssr in case component is cached and beforeCreate
	    // never gets called
	    options._ssrRegister = hook
	  } else if (injectStyles) {
	    hook = injectStyles
	  }

	  if (hook) {
	    var functional = options.functional
	    var existing = functional
	      ? options.render
	      : options.beforeCreate
	    if (!functional) {
	      // inject component registration as beforeCreate hook
	      options.beforeCreate = existing
	        ? [].concat(existing, hook)
	        : [hook]
	    } else {
	      // register for functioal component in vue file
	      options.render = function renderWithStyleInjection (h, context) {
	        hook.call(context)
	        return existing(h, context)
	      }
	    }
	  }

	  return {
	    esModule: esModule,
	    exports: scriptExports,
	    options: options
	  }
	}


/***/ }),

/***/ 8:
/***/ (function(module, exports) {

	module.exports = require("vue");

/***/ }),

/***/ 11:
/***/ (function(module, exports) {

	'use strict';

	exports.__esModule = true;

	var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };

	exports.hasOwn = hasOwn;
	exports.toObject = toObject;
	var hasOwnProperty = Object.prototype.hasOwnProperty;
	function hasOwn(obj, key) {
	  return hasOwnProperty.call(obj, key);
	};

	var generateId = exports.generateId = function generateId() {
	  return Math.floor(Math.random() * 10000);
	};
	var kebabCase = exports.kebabCase = function kebabCase(str) {
	  var hyphenateRE = /([^-])([A-Z])/g;
	  return str.replace(hyphenateRE, '$1-$2').replace(hyphenateRE, '$1-$2').toLowerCase();
	};

	function extend(to, _from) {
	  for (var key in _from) {
	    to[key] = _from[key];
	  }
	  return to;
	};

	function toObject(arr) {
	  var res = {};
	  for (var i = 0; i < arr.length; i++) {
	    if (arr[i]) {
	      extend(res, arr[i]);
	    }
	  }
	  return res;
	};

	var getValueByPath = exports.getValueByPath = function getValueByPath(object, prop) {
	  prop = prop || '';
	  var paths = prop.split('.');
	  var current = object;
	  var result = null;
	  for (var i = 0, j = paths.length; i < j; i++) {
	    var path = paths[i];
	    if (current === undefined) break;

	    if (i === j - 1) {
	      result = current[path];
	      break;
	    }
	    current = current[path];
	  }
	  return result;
	};

	var autoprefixer = exports.autoprefixer = function autoprefixer(style) {
	  if ((typeof style === 'undefined' ? 'undefined' : _typeof(style)) !== 'object') return style;
	  var rules = ['transform', 'transition', 'animation'];
	  var prefixes = ['ms-', 'webkit-'];
	  rules.forEach(function (rule) {
	    var value = style[rule];
	    if (rule && value) {
	      prefixes.forEach(function (prefix) {
	        style[prefix + rule] = value;
	      });
	    }
	  });
	  return style;
	};

	var arrayFindIndex = exports.arrayFindIndex = function arrayFindIndex(arr, pred) {
	  for (var i = 0; i !== arr.length; ++i) {
	    if (pred(arr[i])) {
	      return i;
	    }
	  }
	  return -1;
	};

	var arrayFind = exports.arrayFind = function arrayFind(arr, pred) {
	  var idx = arrayFindIndex(arr, pred);
	  return idx !== -1 ? arr[idx] : undefined;
	};

	// coerce truthy value to array
	var coerceTruthyValueToArray = exports.coerceTruthyValueToArray = function coerceTruthyValueToArray(val) {
	  if (Array.isArray(val)) {
	    return val;
	  } else if (val) {
	    return [val];
	  } else {
	    return [];
	  }
	};

/***/ }),

/***/ 19:
/***/ (function(module, exports) {

	"use strict";

	exports.__esModule = true;
	function _broadcast(componentName, eventName, params) {
	  this.$children.forEach(function (child) {
	    var name = child.$options.componentName;

	    if (name === componentName) {
	      child.$emit.apply(child, [eventName].concat(params));
	    } else {
	      _broadcast.apply(child, [componentName, eventName].concat([params]));
	    }
	  });
	}
	exports.default = {
	  methods: {
	    dispatch: function dispatch(componentName, eventName, params) {
	      var parent = this.$parent || this.$root;
	      var name = parent.$options.componentName;

	      while (parent && (!name || name !== componentName)) {
	        parent = parent.$parent;

	        if (parent) {
	          name = parent.$options.componentName;
	        }
	      }
	      if (parent) {
	        parent.$emit.apply(parent, [eventName].concat(params));
	      }
	    },
	    broadcast: function broadcast(componentName, eventName, params) {
	      _broadcast.call(this, componentName, eventName, params);
	    }
	  }
	};

/***/ }),

/***/ 29:
/***/ (function(module, exports, __webpack_require__) {

	'use strict';

	exports.__esModule = true;
	exports.getStyle = exports.once = exports.off = exports.on = undefined;

	var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; /* istanbul ignore next */

	exports.hasClass = hasClass;
	exports.addClass = addClass;
	exports.removeClass = removeClass;
	exports.setStyle = setStyle;

	var _vue = __webpack_require__(8);

	var _vue2 = _interopRequireDefault(_vue);

	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

	var isServer = _vue2.default.prototype.$isServer;
	var SPECIAL_CHARS_REGEXP = /([\:\-\_]+(.))/g;
	var MOZ_HACK_REGEXP = /^moz([A-Z])/;
	var ieVersion = isServer ? 0 : Number(document.documentMode);

	/* istanbul ignore next */
	var trim = function trim(string) {
	  return (string || '').replace(/^[\s\uFEFF]+|[\s\uFEFF]+$/g, '');
	};
	/* istanbul ignore next */
	var camelCase = function camelCase(name) {
	  return name.replace(SPECIAL_CHARS_REGEXP, function (_, separator, letter, offset) {
	    return offset ? letter.toUpperCase() : letter;
	  }).replace(MOZ_HACK_REGEXP, 'Moz$1');
	};

	/* istanbul ignore next */
	var on = exports.on = function () {
	  if (!isServer && document.addEventListener) {
	    return function (element, event, handler) {
	      if (element && event && handler) {
	        element.addEventListener(event, handler, false);
	      }
	    };
	  } else {
	    return function (element, event, handler) {
	      if (element && event && handler) {
	        element.attachEvent('on' + event, handler);
	      }
	    };
	  }
	}();

	/* istanbul ignore next */
	var off = exports.off = function () {
	  if (!isServer && document.removeEventListener) {
	    return function (element, event, handler) {
	      if (element && event) {
	        element.removeEventListener(event, handler, false);
	      }
	    };
	  } else {
	    return function (element, event, handler) {
	      if (element && event) {
	        element.detachEvent('on' + event, handler);
	      }
	    };
	  }
	}();

	/* istanbul ignore next */
	var once = exports.once = function once(el, event, fn) {
	  var listener = function listener() {
	    if (fn) {
	      fn.apply(this, arguments);
	    }
	    off(el, event, listener);
	  };
	  on(el, event, listener);
	};

	/* istanbul ignore next */
	function hasClass(el, cls) {
	  if (!el || !cls) return false;
	  if (cls.indexOf(' ') !== -1) throw new Error('className should not contain space.');
	  if (el.classList) {
	    return el.classList.contains(cls);
	  } else {
	    return (' ' + el.className + ' ').indexOf(' ' + cls + ' ') > -1;
	  }
	};

	/* istanbul ignore next */
	function addClass(el, cls) {
	  if (!el) return;
	  var curClass = el.className;
	  var classes = (cls || '').split(' ');

	  for (var i = 0, j = classes.length; i < j; i++) {
	    var clsName = classes[i];
	    if (!clsName) continue;

	    if (el.classList) {
	      el.classList.add(clsName);
	    } else {
	      if (!hasClass(el, clsName)) {
	        curClass += ' ' + clsName;
	      }
	    }
	  }
	  if (!el.classList) {
	    el.className = curClass;
	  }
	};

	/* istanbul ignore next */
	function removeClass(el, cls) {
	  if (!el || !cls) return;
	  var classes = cls.split(' ');
	  var curClass = ' ' + el.className + ' ';

	  for (var i = 0, j = classes.length; i < j; i++) {
	    var clsName = classes[i];
	    if (!clsName) continue;

	    if (el.classList) {
	      el.classList.remove(clsName);
	    } else {
	      if (hasClass(el, clsName)) {
	        curClass = curClass.replace(' ' + clsName + ' ', ' ');
	      }
	    }
	  }
	  if (!el.classList) {
	    el.className = trim(curClass);
	  }
	};

	/* istanbul ignore next */
	var getStyle = exports.getStyle = ieVersion < 9 ? function (element, styleName) {
	  if (isServer) return;
	  if (!element || !styleName) return null;
	  styleName = camelCase(styleName);
	  if (styleName === 'float') {
	    styleName = 'styleFloat';
	  }
	  try {
	    switch (styleName) {
	      case 'opacity':
	        try {
	          return element.filters.item('alpha').opacity / 100;
	        } catch (e) {
	          return 1.0;
	        }
	      default:
	        return element.style[styleName] || element.currentStyle ? element.currentStyle[styleName] : null;
	    }
	  } catch (e) {
	    return element.style[styleName];
	  }
	} : function (element, styleName) {
	  if (isServer) return;
	  if (!element || !styleName) return null;
	  styleName = camelCase(styleName);
	  if (styleName === 'float') {
	    styleName = 'cssFloat';
	  }
	  try {
	    var computed = document.defaultView.getComputedStyle(element, '');
	    return element.style[styleName] || computed ? computed[styleName] : null;
	  } catch (e) {
	    return element.style[styleName];
	  }
	};

	/* istanbul ignore next */
	function setStyle(element, styleName, value) {
	  if (!element || !styleName) return;

	  if ((typeof styleName === 'undefined' ? 'undefined' : _typeof(styleName)) === 'object') {
	    for (var prop in styleName) {
	      if (styleName.hasOwnProperty(prop)) {
	        setStyle(element, prop, styleName[prop]);
	      }
	    }
	  } else {
	    styleName = camelCase(styleName);
	    if (styleName === 'opacity' && ieVersion < 9) {
	      element.style.filter = isNaN(value) ? '' : 'alpha(opacity=' + value * 100 + ')';
	    } else {
	      element.style[styleName] = value;
	    }
	  }
	};

/***/ }),

/***/ 47:
/***/ (function(module, exports, __webpack_require__) {

	'use strict';

	exports.__esModule = true;

	var _button = __webpack_require__(48);

	var _button2 = _interopRequireDefault(_button);

	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

	/* istanbul ignore next */
	_button2.default.install = function (Vue) {
	  Vue.component(_button2.default.name, _button2.default);
	};

	exports.default = _button2.default;

/***/ }),

/***/ 48:
/***/ (function(module, exports, __webpack_require__) {

	var Component = __webpack_require__(3)(
	  /* script */
	  __webpack_require__(49),
	  /* template */
	  __webpack_require__(50),
	  /* styles */
	  null,
	  /* scopeId */
	  null,
	  /* moduleIdentifier (server only) */
	  null
	)

	module.exports = Component.exports


/***/ }),

/***/ 49:
/***/ (function(module, exports) {

	'use strict';

	exports.__esModule = true;
	//
	//
	//
	//
	//
	//
	//
	//
	//
	//
	//
	//
	//
	//
	//
	//
	//
	//
	//
	//
	//
	//
	//
	//
	//
	//
	//
	//

	exports.default = {
	  name: 'ElButton',

	  props: {
	    type: {
	      type: String,
	      default: 'default'
	    },
	    size: String,
	    icon: {
	      type: String,
	      default: ''
	    },
	    nativeType: {
	      type: String,
	      default: 'button'
	    },
	    loading: Boolean,
	    disabled: Boolean,
	    plain: Boolean,
	    autofocus: Boolean
	  },
	  data: function data() {
	    return {
	      showBorder: false
	    };
	  },
	  methods: {
	    handleClick: function handleClick(evt) {
	      this.$emit('click', evt);
	      this.showBorder = false;
	    },
	    handleFocus: function handleFocus(evt) {
	      this.$emit('focus', evt);
	    },
	    handleBlur: function handleBlur(evt) {
	      this.showBorder = false;
	      this.$emit('blur', evt);
	    },
	    handleKeyup: function handleKeyup(evt) {
	      this.showBorder = true;
	      this.$emit('keyup', evt);
	    }
	  }
	};

/***/ }),

/***/ 50:
/***/ (function(module, exports) {

	module.exports={render:function (){var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;
	  return _c('button', {
	    staticClass: "el-button",
	    class: [
	      _vm.showBorder ? 'border' : '',
	      _vm.type ? 'el-button--' + _vm.type : '',
	      _vm.size ? 'el-button--' + _vm.size : '',
	      {
	        'is-disabled': _vm.disabled,
	        'is-loading': _vm.loading,
	        'is-plain': _vm.plain
	      }
	    ],
	    attrs: {
	      "disabled": _vm.disabled,
	      "autofocus": _vm.autofocus,
	      "type": _vm.nativeType
	    },
	    on: {
	      "click": _vm.handleClick,
	      "keyup": _vm.handleKeyup,
	      "blur": _vm.handleBlur,
	      "focus": _vm.handleFocus
	    }
	  }, [(_vm.loading) ? _c('div', {
	    staticClass: "loading—animation"
	  }, [_c('div', {
	    staticClass: "bounce1"
	  }), _c('div', {
	    staticClass: "bounce2"
	  }), _c('div', {
	    staticClass: "bounce3"
	  })]) : _vm._e(), (_vm.icon && !_vm.loading) ? _c('i', {
	    class: 'icon-' + _vm.icon
	  }) : _vm._e(), (_vm.$slots.default) ? _c('span', [_vm._t("default")], 2) : _vm._e()])
	},staticRenderFns: []}

/***/ }),

/***/ 51:
/***/ (function(module, exports, __webpack_require__) {

	'use strict';

	exports.__esModule = true;

	var _buttonGroup = __webpack_require__(52);

	var _buttonGroup2 = _interopRequireDefault(_buttonGroup);

	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

	/* istanbul ignore next */
	_buttonGroup2.default.install = function (Vue) {
	  Vue.component(_buttonGroup2.default.name, _buttonGroup2.default);
	};

	exports.default = _buttonGroup2.default;

/***/ }),

/***/ 52:
/***/ (function(module, exports, __webpack_require__) {

	var Component = __webpack_require__(3)(
	  /* script */
	  __webpack_require__(53),
	  /* template */
	  __webpack_require__(54),
	  /* styles */
	  null,
	  /* scopeId */
	  null,
	  /* moduleIdentifier (server only) */
	  null
	)

	module.exports = Component.exports


/***/ }),

/***/ 53:
/***/ (function(module, exports) {

	'use strict';

	exports.__esModule = true;
	//
	//
	//
	//
	//

	/**
	 * button
	 * @module components/basic/menu
	 * @desc 用于按钮组
	 * @param {string} label - 名称
	 */
	exports.default = {
	  name: 'ElButtonGroup'
	};

/***/ }),

/***/ 54:
/***/ (function(module, exports) {

	module.exports={render:function (){var _vm=this;var _h=_vm.$createElement;var _c=_vm._self._c||_h;
	  return _c('div', {
	    staticClass: "el-button-group"
	  }, [_vm._t("default")], 2)
	},staticRenderFns: []}

/***/ }),

/***/ 72:
/***/ (function(module, exports, __webpack_require__) {

	'use strict';

	exports.__esModule = true;

	var _vue = __webpack_require__(8);

	var _vue2 = _interopRequireDefault(_vue);

	var _dom = __webpack_require__(29);

	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

	var nodeList = [];
	var ctx = '@@clickoutsideContext';

	var startClick = void 0;

	!_vue2.default.prototype.$isServer && (0, _dom.on)(document, 'mousedown', function (e) {
	  return startClick = e;
	});

	!_vue2.default.prototype.$isServer && (0, _dom.on)(document, 'mouseup', function (e) {
	  nodeList.forEach(function (node) {
	    return node[ctx].documentHandler(e, startClick);
	  });
	});
	/**
	 * v-clickoutside
	 * @desc 点击元素外面才会触发的事件
	 * @example
	 * ```vue
	 * <div v-element-clickoutside="handleClose">
	 * ```
	 */
	exports.default = {
	  bind: function bind(el, binding, vnode) {
	    var id = nodeList.push(el) - 1;
	    var documentHandler = function documentHandler(mouseup, mousedown) {
	      if (!vnode.context || el.contains(mouseup.target) || vnode.context.popperElm && (vnode.context.popperElm.contains(mouseup.target) || vnode.context.popperElm.contains(mousedown.target))) return;

	      if (binding.expression && el[ctx].methodName && vnode.context[el[ctx].methodName]) {
	        vnode.context[el[ctx].methodName]();
	      } else {
	        el[ctx].bindingFn && el[ctx].bindingFn();
	      }
	    };
	    el[ctx] = {
	      id: id,
	      documentHandler: documentHandler,
	      methodName: binding.expression,
	      bindingFn: binding.value
	    };
	  },
	  update: function update(el, binding) {
	    el[ctx].methodName = binding.expression;
	    el[ctx].bindingFn = binding.value;
	  },
	  unbind: function unbind(el) {
	    var len = nodeList.length;

	    for (var i = 0; i < len; i++) {
	      if (nodeList[i][ctx].id === el[ctx].id) {
	        nodeList.splice(i, 1);
	        break;
	      }
	    }
	  }
	};

/***/ }),

/***/ 159:
/***/ (function(module, exports, __webpack_require__) {

	'use strict';

	exports.__esModule = true;

	var _dropdown = __webpack_require__(160);

	var _dropdown2 = _interopRequireDefault(_dropdown);

	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

	/* istanbul ignore next */
	_dropdown2.default.install = function (Vue) {
	  Vue.component(_dropdown2.default.name, _dropdown2.default);
	};

	exports.default = _dropdown2.default;

/***/ }),

/***/ 160:
/***/ (function(module, exports, __webpack_require__) {

	var Component = __webpack_require__(3)(
	  /* script */
	  __webpack_require__(161),
	  /* template */
	  null,
	  /* styles */
	  null,
	  /* scopeId */
	  null,
	  /* moduleIdentifier (server only) */
	  null
	)

	module.exports = Component.exports


/***/ }),

/***/ 161:
/***/ (function(module, exports, __webpack_require__) {

	'use strict';

	exports.__esModule = true;

	var _clickoutside = __webpack_require__(72);

	var _clickoutside2 = _interopRequireDefault(_clickoutside);

	var _emitter = __webpack_require__(19);

	var _emitter2 = _interopRequireDefault(_emitter);

	var _migrating = __webpack_require__(162);

	var _migrating2 = _interopRequireDefault(_migrating);

	var _button = __webpack_require__(47);

	var _button2 = _interopRequireDefault(_button);

	var _buttonGroup = __webpack_require__(51);

	var _buttonGroup2 = _interopRequireDefault(_buttonGroup);

	var _util = __webpack_require__(11);

	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

	exports.default = {
	  name: 'ElDropdown',

	  componentName: 'ElDropdown',

	  mixins: [_emitter2.default, _migrating2.default],

	  directives: { Clickoutside: _clickoutside2.default },

	  components: {
	    ElButton: _button2.default,
	    ElButtonGroup: _buttonGroup2.default
	  },

	  provide: function provide() {
	    return {
	      dropdown: this
	    };
	  },


	  props: {
	    id: {
	      type: String,
	      default: ''
	    },
	    buttonId: {
	      type: String
	    },
	    arrowId: {
	      type: String
	    },
	    disabled: Boolean,
	    trigger: {
	      type: String,
	      default: 'hover'
	    },
	    type: String,
	    size: {
	      type: String,
	      default: ''
	    },
	    splitButton: Boolean,
	    hideOnClick: {
	      type: Boolean,
	      default: true
	    },
	    triggerAriaLabel: {
	      type: String
	    },
	    placement: {
	      type: String,
	      default: 'bottom-end'
	    },
	    visibleArrow: {
	      default: true
	    },
	    showTimeout: {
	      type: Number,
	      default: 250
	    },
	    hideTimeout: {
	      type: Number,
	      default: 200
	    },
	    ariaLabel: {
	      type: String
	    },
	    tabindex: {
	      type: Number,
	      default: 0
	    },
	    freezeMenu: {
	      type: Boolean,
	      default: false
	    },
	    defaultOption: {}
	  },

	  data: function data() {
	    var id = this.id;
	    return {
	      timeout: null,
	      visible: false,
	      triggerElm: null,
	      menuItems: null,
	      menuItemsArray: null,
	      dropdownElm: null,
	      focusing: false,
	      listId: this.id ? this.id + '-menu' : 'dropdown-menu-' + (0, _util.generateId)()
	    };
	  },


	  computed: {
	    dropdownSize: function dropdownSize() {
	      return this.size || (this.$ELEMENT || {}).size;
	    }
	  },

	  mounted: function mounted() {
	    this.$on('menu-item-click', this.handleMenuItemClick);
	  },


	  watch: {
	    visible: function visible(val) {
	      this.broadcast('ElDropdownMenu', 'visible', val);
	      this.$emit('visible-change', val);
	    },
	    focusing: function focusing(val) {
	      var selfDefine = this.$el.querySelector('.el-dropdown-selfdefine');
	      if (selfDefine) {
	        // 自定义
	        if (val) {
	          selfDefine.className += ' focusing';
	        } else {
	          selfDefine.className = selfDefine.className.replace('focusing', '');
	        }
	      }
	    }
	  },

	  methods: {
	    getMigratingConfig: function getMigratingConfig() {
	      return {
	        props: {
	          'menu-align': 'menu-align is renamed to placement.'
	        }
	      };
	    },
	    show: function show() {
	      var _this2 = this;

	      var _this = this;
	      if (this.triggerElm.disabled) return;
	      this.triggerElm.setAttribute('aria-expanded', true);
	      clearTimeout(this.timeout);

	      this.timeout = setTimeout(function () {
	        _this2.visible = true;
	        setTimeout(function () {
	          var nextIndex = 0;
	          _this2.resetTabindex(_this2.menuItems[nextIndex]);
	          if (_this.defaultOption) {
	            var defaultItem = void 0;
	            if (_this2.menuItems[0].getAttribute('data-id')) {
	              defaultItem = _this.menuItemsArray.filter(function (item) {
	                return item.getAttribute('data-id') === '' + _this.defaultOption;
	              })[0];
	            } else if (!isNaN(Number(_this.defaultOption))) {
	              defaultItem = _this2.menuItems[_this.defaultOption];
	            }
	            defaultItem && defaultItem.focus();
	          } else {
	            _this2.menuItems[nextIndex].focus();
	          }
	        }, 200);
	      }, this.trigger === 'click' ? 0 : this.showTimeout);
	    },
	    hide: function hide() {
	      var _this3 = this;

	      if (this.freezeMenu) {
	        return;
	      }
	      if (this.triggerElm.disabled) return;
	      this.triggerElm.setAttribute('aria-expanded', 'false');
	      this.triggerElm.removeAttribute('aria-activedescendant');
	      this.removeTabindex();
	      if (this.tabindex >= 0) {
	        this.resetTabindex(this.triggerElm);
	      }
	      clearTimeout(this.timeout);
	      this.timeout = setTimeout(function () {
	        _this3.visible = false;
	      }, this.trigger === 'click' ? 0 : this.hideTimeout);
	    },
	    handleClick: function handleClick(ev, force) {
	      if (this.triggerElm.disabled) return;
	      if (!force && ev.keyCode) {
	        return;
	      }
	      if (this.visible) {
	        this.hide(ev);
	      } else {
	        this.show(ev);
	      }
	    },
	    focusMenuItem: function focusMenuItem(i) {
	      this.removeTabindex();
	      var el = this.menuItems[0];
	      this.resetTabindex(el);
	      el.focus();
	      this.triggerElm.setAttribute('aria-activedescendant', el.id);
	    },
	    handleTriggerKeyDown: function handleTriggerKeyDown(ev) {
	      var keyCode = ev.keyCode;
	      if ([38, 40].indexOf(keyCode) > -1) {
	        // up/down
	        this.removeTabindex();
	        var el = this.menuItems[0];
	        this.resetTabindex(this.menuItems[0]);
	        this.menuItems[0].focus();
	        this.triggerElm.setAttribute('aria-activedescendant', this.menuItems[0].id);

	        ev.preventDefault();
	        ev.stopPropagation();
	      } else if ([13, 32].indexOf(keyCode) > -1) {
	        // space enter选中
	        ev.preventDefault();
	        this.handleClick(ev, true);
	      } else if ([9, 27].indexOf(keyCode) > -1) {
	        // tab || esc
	        this.hide();
	      }
	    },
	    handleItemKeyDown: function handleItemKeyDown(ev) {
	      var keyCode = ev.keyCode;
	      var target = ev.target;
	      var currentIndex = this.menuItemsArray.indexOf(target);
	      var max = this.menuItemsArray.length - 1;
	      var nextIndex = void 0;
	      if ([38, 40].indexOf(keyCode) > -1) {
	        // up/down
	        if (keyCode === 38) {
	          // up
	          nextIndex = currentIndex === 0 ? max : currentIndex - 1;
	        } else {
	          // down
	          nextIndex = currentIndex === max ? 0 : currentIndex + 1;
	        }
	        this.removeTabindex();
	        this.resetTabindex(this.menuItems[nextIndex]);
	        this.menuItems[nextIndex].focus();
	        this.triggerElm.setAttribute('aria-activedescendant', this.menuItems[nextIndex].id);

	        ev.preventDefault();
	        ev.stopPropagation();
	      } else if ([13, 32].indexOf(keyCode) > -1) {
	        // enter选中
	        this.triggerElmFocus();
	        target.click();
	        if (this.hideOnClick) {
	          // click关闭
	          this.visible = false;
	        }
	      } else if ([9, 27].indexOf(keyCode) > -1) {
	        // tab // esc
	        ev.preventDefault();
	        ev.stopPropagation();
	        this.hide();
	        this.triggerElmFocus();
	      }
	    },
	    resetTabindex: function resetTabindex(ele) {
	      // 下次tab时组件聚焦元素
	      this.removeTabindex();
	      ele && ele.setAttribute('tabindex', '0'); // 下次期望的聚焦元素
	    },
	    removeTabindex: function removeTabindex() {
	      this.triggerElm.setAttribute('tabindex', '-1');
	      this.menuItemsArray.forEach(function (item) {
	        item.setAttribute('tabindex', '-1');
	      });
	    },
	    initAria: function initAria() {
	      var dropMenuId = this.id || this.listId;

	      this.dropdownElm.setAttribute('id', dropMenuId);
	      this.triggerElm.setAttribute('aria-haspopup', 'listbox');
	      this.triggerElm.setAttribute('aria-expanded', 'false');
	      this.triggerElm.setAttribute('aria-controls', dropMenuId);
	      this.triggerElm.setAttribute('role', 'button');

	      if (!this.splitButton) {
	        this.$el.setAttribute('id', dropMenuId + '-trigger');
	        this.triggerElm.setAttribute('tabindex', this.tabindex);
	        this.triggerElm.setAttribute('class', (this.triggerElm.getAttribute('class') || '') + ' el-dropdown-selfdefine'); // 控制
	      } else {
	        this.arrowId ? this.triggerElm.setAttribute('id', this.arrowId) : this.triggerElm.setAttribute('id', dropMenuId + '-trigger');
	        this.buttonId ? this.$refs.action.$el.setAttribute('id', this.buttonId) : this.$refs.action.$el.setAttribute('id', dropMenuId + '-action');
	      }
	    },
	    initEvent: function initEvent() {
	      var _this4 = this;

	      var trigger = this.trigger,
	          show = this.show,
	          hide = this.hide,
	          handleClick = this.handleClick,
	          handlePointerEvent = this.handlePointerEvent,
	          splitButton = this.splitButton,
	          handleTriggerKeyDown = this.handleTriggerKeyDown,
	          handleItemKeyDown = this.handleItemKeyDown;

	      this.triggerElm = splitButton ? this.$refs.trigger.$el : this.$slots.default[0].elm;

	      var dropdownElm = this.dropdownElm;

	      this.triggerElm.addEventListener('keydown', handleTriggerKeyDown); // triggerElm keydown
	      dropdownElm.addEventListener('keydown', handleItemKeyDown, true); // item keydown
	      // 控制自定义元素的样式
	      if (!splitButton) {
	        this.triggerElm.addEventListener('focus', function () {
	          _this4.focusing = true;
	        });
	        this.triggerElm.addEventListener('blur', function () {
	          _this4.focusing = false;
	        });
	        this.triggerElm.addEventListener('click', function () {
	          _this4.focusing = false;
	        });
	      }
	      if (trigger === 'hover') {
	        this.triggerElm.addEventListener('mouseenter', show);
	        this.triggerElm.addEventListener('mouseleave', hide);
	        dropdownElm.addEventListener('mouseenter', show);
	        dropdownElm.addEventListener('mouseleave', hide);
	        this.triggerElm.addEventListener('click', handleClick);
	      } else if (trigger === 'click') {
	        this.triggerElm.addEventListener('click', handleClick);
	      }
	    },
	    handleMenuItemClick: function handleMenuItemClick(command, instance) {
	      if (this.hideOnClick) {
	        this.visible = false;
	      }
	      this.$emit('command', command, instance);
	    },
	    triggerElmFocus: function triggerElmFocus() {
	      this.triggerElm.focus && this.triggerElm.focus();
	    },
	    initDomOperation: function initDomOperation() {
	      this.dropdownElm = this.popperElm;
	      this.menuItems = this.dropdownElm.querySelectorAll("[tabindex='-1']");
	      this.menuItemsArray = [].slice.call(this.menuItems);

	      this.initEvent();
	      this.initAria();
	    }
	  },

	  render: function render(h) {
	    var _this5 = this;

	    var hide = this.hide,
	        splitButton = this.splitButton,
	        type = this.type,
	        dropdownSize = this.dropdownSize,
	        ariaLabel = this.ariaLabel,
	        visible = this.visible,
	        disabled = this.disabled,
	        triggerAriaLabel = this.triggerAriaLabel;


	    var handleMainButtonClick = function handleMainButtonClick(event) {
	      _this5.$emit('click', event);
	      hide();
	    };

	    var triggerElm = !splitButton ? this.$slots.default : h('el-button-group', [h(
	      'el-button',
	      { ref: 'action', attrs: { type: type, size: dropdownSize, disabled: disabled, 'aria-label': ariaLabel },
	        nativeOn: {
	          'click': handleMainButtonClick
	        }
	      },
	      [this.$slots.default]
	    ), h(
	      'el-button',
	      { ref: 'trigger', attrs: { 'aria-label': triggerAriaLabel, type: type, disabled: disabled, size: dropdownSize },
	        'class': 'el-dropdown__caret-button' },
	      [h('i', { 'class': 'el-dropdown__icon icon-ng-down' })]
	    )]);
	    if (splitButton) {
	      return h(
	        'div',
	        { 'class': 'el-dropdown', directives: [{
	            name: 'clickoutside',
	            value: hide
	          }]
	        },
	        [triggerElm, this.$slots.dropdown]
	      );
	    }
	    return h(
	      'div',
	      { 'class': 'el-dropdown', directives: [{
	          name: 'clickoutside',
	          value: hide
	        }],
	        attrs: { 'aria-label': ariaLabel }
	      },
	      [triggerElm, this.$slots.dropdown]
	    );
	  }
	};

/***/ }),

/***/ 162:
/***/ (function(module, exports, __webpack_require__) {

	'use strict';

	exports.__esModule = true;

	var _util = __webpack_require__(11);

	/**
	 * Show migrating guide in browser console.
	 *
	 * Usage:
	 * import Migrating from 'element-ui/src/mixins/migrating';
	 *
	 * mixins: [Migrating]
	 *
	 * add getMigratingConfig method for your component.
	 *  getMigratingConfig() {
	 *    return {
	 *      props: {
	 *        'allow-no-selection': 'allow-no-selection is removed.',
	 *        'selection-mode': 'selection-mode is removed.'
	 *      },
	 *      events: {
	 *        selectionchange: 'selectionchange is renamed to selection-change.'
	 *      }
	 *    };
	 *  },
	 */
	exports.default = {
	  mounted: function mounted() {
	    if (true) return;
	    if (!this.$vnode) return;

	    var _getMigratingConfig = this.getMigratingConfig(),
	        _getMigratingConfig$p = _getMigratingConfig.props,
	        props = _getMigratingConfig$p === undefined ? {} : _getMigratingConfig$p,
	        _getMigratingConfig$e = _getMigratingConfig.events,
	        events = _getMigratingConfig$e === undefined ? {} : _getMigratingConfig$e;

	    var _$vnode = this.$vnode,
	        data = _$vnode.data,
	        componentOptions = _$vnode.componentOptions;

	    var definedProps = data.attrs || {};
	    var definedEvents = componentOptions.listeners || {};

	    for (var propName in definedProps) {
	      propName = (0, _util.kebabCase)(propName); // compatible with camel case
	      if (props[propName]) {
	        console.warn('[Element Migrating][' + this.$options.name + '][Attribute]: ' + props[propName]);
	      }
	    }

	    for (var eventName in definedEvents) {
	      eventName = (0, _util.kebabCase)(eventName); // compatible with camel case
	      if (events[eventName]) {
	        console.warn('[Element Migrating][' + this.$options.name + '][Event]: ' + events[eventName]);
	      }
	    }
	  },

	  methods: {
	    getMigratingConfig: function getMigratingConfig() {
	      return {
	        props: {},
	        events: {}
	      };
	    }
	  }
	};

/***/ })

/******/ });