cy-element-ui 1.1.25 → 1.1.26

package/lib/CyTreeSelect.js

@@ -0,0 +1,4422 @@
+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 = 119);
+/******/ })
+/************************************************************************/
+/******/ ({
+
+/***/ 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,
+            (options.functional ? this.parent : 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 functional 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
+  }
+}
+
+
+/***/ }),
+
+/***/ 1:
+/***/ (function(module, exports) {
+
+module.exports = require("element-ui/lib/utils/dom");
+
+/***/ }),
+
+/***/ 11:
+/***/ (function(module, exports) {
+
+module.exports = require("element-ui/lib/utils/shared");
+
+/***/ }),
+
+/***/ 119:
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+// ESM COMPAT FLAG
+__webpack_require__.r(__webpack_exports__);
+
+// CONCATENATED MODULE: ./node_modules/vue-loader/lib/loaders/templateLoader.js??vue-loader-options!./node_modules/vue-loader/lib??vue-loader-options!./packages/cy/treeSelect/src/main.vue?vue&type=template&id=5e4054a3
+var render = function () {
+  var _vm = this
+  var _h = _vm.$createElement
+  var _c = _vm._self._c || _h
+  return _c(
+    "div",
+    { staticClass: "cy-tree-select" },
+    [
+      _c(
+        "el-popover",
+        {
+          attrs: {
+            placement: "bottom-start",
+            width: "300",
+            trigger: "click",
+            "popper-class": _vm.popperClass,
+          },
+          on: {
+            show: function ($event) {
+              _vm.popoverOpen = true
+            },
+            hide: function ($event) {
+              _vm.popoverOpen = false
+            },
+          },
+          model: {
+            value: _vm.popoverOpen,
+            callback: function ($$v) {
+              _vm.popoverOpen = $$v
+            },
+            expression: "popoverOpen",
+          },
+        },
+        [
+          _c("div", { staticClass: "cy-tree-select-select-con" }, [
+            _vm.filterable
+              ? _c(
+                  "div",
+                  { staticClass: "cy-tree-select-select-con-s" },
+                  [
+                    _c("el-input", {
+                      attrs: {
+                        placeholder: "搜索",
+                        "prefix-icon": "el-icon-search",
+                        clearable: "",
+                        size: "small",
+                      },
+                      model: {
+                        value: _vm.filterText,
+                        callback: function ($$v) {
+                          _vm.filterText = $$v
+                        },
+                        expression: "filterText",
+                      },
+                    }),
+                  ],
+                  1
+                )
+              : _vm._e(),
+            _vm.showCheckStrictly
+              ? _c(
+                  "div",
+                  { staticClass: "cy-tree-select-select-con-t" },
+                  [
+                    _c(
+                      "el-checkbox",
+                      {
+                        model: {
+                          value: _vm.isCheckStrictly,
+                          callback: function ($$v) {
+                            _vm.isCheckStrictly = $$v
+                          },
+                          expression: "isCheckStrictly",
+                        },
+                      },
+                      [_vm._v("父子节点联动")]
+                    ),
+                  ],
+                  1
+                )
+              : _vm._e(),
+            _c(
+              "div",
+              { staticClass: "cy-tree-select-select-con-c" },
+              [
+                _c("el-tree", {
+                  ref: "tree",
+                  attrs: {
+                    data: _vm.treeOptions,
+                    "show-checkbox": _vm.multiple,
+                    "node-key": _vm.defaultOptions.id,
+                    "check-strictly": !_vm.isCheckStrictly,
+                    props: _vm.defaultOptions,
+                    "expand-on-click-node": false,
+                    "default-expand-all": _vm.defaultExpandAll,
+                    "filter-node-method": _vm.filterNode,
+                  },
+                  on: { check: _vm.treeCheck, "node-click": _vm.treeClick },
+                }),
+              ],
+              1
+            ),
+          ]),
+          _c(
+            "div",
+            {
+              staticClass: "cy-tree-select-select",
+              class: _vm.size,
+              style: _vm.vStyle,
+              attrs: { slot: "reference" },
+              slot: "reference",
+            },
+            [
+              _c("div", { staticClass: "cy-tree-select-select-v" }, [
+                _vm.checkedArr.length < 1
+                  ? _c(
+                      "span",
+                      { staticClass: "cy-tree-select-select-v-placeholder" },
+                      [_vm._v(_vm._s(_vm.placeholder))]
+                    )
+                  : _c("span", [
+                      _vm._v(
+                        _vm._s(
+                          _vm.checkedArr
+                            .map(function (item) {
+                              return item[_vm.defaultOptions.label]
+                            })
+                            .join()
+                        )
+                      ),
+                    ]),
+              ]),
+              _c(
+                "div",
+                {
+                  staticClass: "cy-tree-select-select-v-icon",
+                  on: {
+                    mouseenter: function ($event) {
+                      _vm.isClearIcon = true
+                    },
+                    mouseleave: function ($event) {
+                      _vm.isClearIcon = false
+                    },
+                  },
+                },
+                [
+                  _vm.isClearIcon && _vm.clearable
+                    ? _c("i", {
+                        staticClass: "el-icon-circle-close",
+                        on: {
+                          click: function ($event) {
+                            $event.stopPropagation()
+                            return _vm.handleClear($event)
+                          },
+                        },
+                      })
+                    : _c("i", {
+                        staticClass:
+                          "el-icon-arrow-down cy-tree-select-select-v-arrow",
+                        class: {
+                          "cy-tree-select-select-v-arrow-show": _vm.popoverOpen,
+                        },
+                      }),
+                ]
+              ),
+            ]
+          ),
+        ]
+      ),
+    ],
+    1
+  )
+}
+var staticRenderFns = []
+render._withStripped = true
+
+
+// CONCATENATED MODULE: ./packages/cy/treeSelect/src/main.vue?vue&type=template&id=5e4054a3
+
+// EXTERNAL MODULE: ./packages/checkbox/index.js + 5 modules
+var packages_checkbox = __webpack_require__(16);
+
+// EXTERNAL MODULE: ./packages/popover/index.js + 6 modules
+var popover = __webpack_require__(36);
+
+// EXTERNAL MODULE: ./packages/input/index.js + 6 modules
+var input = __webpack_require__(13);
+
+// EXTERNAL MODULE: ./packages/tree/index.js + 13 modules
+var tree = __webpack_require__(46);
+
+// CONCATENATED MODULE: ./node_modules/babel-loader/lib!./node_modules/vue-loader/lib??vue-loader-options!./packages/cy/treeSelect/src/main.vue?vue&type=script&lang=js
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+
+
+
+
+
+
+/* harmony default export */ var mainvue_type_script_lang_js = ({
+	name: 'CyTreeSelect',
+	components: {
+		ElCheckbox: packages_checkbox["default"],
+		ElPopover: popover["default"],
+		ElInput: input["default"],
+		ElTree: tree["default"]
+	},
+	model: {
+		prop: 'value',
+		event: 'change'
+	},
+	props: {
+		value: {
+			type: [String, Number, Array],
+			default: ''
+		},
+
+		options: {
+			type: Array,
+			default: []
+		},
+
+		placeholder: {
+			type: String,
+			default: ''
+		},
+
+		size: {
+			type: String
+		},
+
+		filterable: {
+			type: Boolean,
+			default: false
+		},
+
+		showCheckStrictly: {
+			type: Boolean,
+			default: true
+		},
+
+		checkStrictly: {
+			type: Boolean,
+			default: true
+		},
+
+		clearable: {
+			type: Boolean,
+			default: false
+		},
+
+		multiple: {
+			type: Boolean,
+			default: false
+		},
+
+		defaultOptions: {
+			type: Object,
+			default: function _default() {
+				return {
+					children: 'children',
+					label: 'label',
+					id: 'id'
+				};
+			}
+		},
+
+		vStyle: {
+			type: [Array, String, Object],
+			default: ''
+		},
+
+		popperClass: {
+			type: String,
+			default: ''
+		},
+
+		defaultExpandAll: {
+			type: Boolean,
+			default: false
+		}
+	},
+	data: function data() {
+		return {
+			isCheckStrictly: true,
+			popoverOpen: false,
+			isClearIcon: false,
+
+			treeOptions: [],
+			treeArr: [],
+			filterText: '',
+			matchedNodeIds: []
+		};
+	},
+
+	computed: {
+		checkedArr: function checkedArr() {
+			var _this = this;
+
+			if (this.multiple) {
+				var arr = [];
+				this.value && this.value.forEach(function (id) {
+					var cItem = _this.treeArr.filter(function (tItem) {
+						return tItem[_this.defaultOptions.id] === id;
+					})[0];
+					if (cItem) arr.push(cItem);
+				});
+				return arr;
+			} else {
+				var cItem = this.treeArr.filter(function (tItem) {
+					return tItem[_this.defaultOptions.id] === Number(_this.value);
+				})[0];
+				return cItem ? [cItem] : [];
+			}
+		}
+	},
+	watch: {
+		checkStrictly: {
+			immediate: true,
+			handler: function handler() {
+				this.isCheckStrictly = this.checkStrictly;
+			}
+		},
+
+		value: {
+			immediate: true,
+			deep: true,
+			handler: function handler() {
+				var _this2 = this;
+
+				this.$nextTick(function () {
+					_this2.init();
+				});
+			}
+		},
+
+		options: {
+			deep: true,
+			immediate: true,
+			handler: function handler() {
+				this.treeOptions = this.options;
+				this.treeArr = this.turnFormatTreeData([], this.treeOptions, 0);
+			}
+		},
+
+		filterText: function filterText(val) {
+			var _this3 = this;
+
+			if (val) {
+				this.matchedNodeIds = this.findMatchedNodes(val, this.treeOptions);
+				this.$refs.tree.filter(val);
+				this.$nextTick(function () {
+					_this3.expandMatchedNodes();
+				});
+			} else {
+				this.matchedNodeIds = [];
+				this.$refs.tree.filter(val);
+			}
+		}
+	},
+	created: function created() {},
+
+	methods: {
+		filterNode: function filterNode(value, data) {
+			if (!value) return true;
+			return this.matchedNodeIds.includes(data[this.defaultOptions.id]);
+		},
+		findMatchedNodes: function findMatchedNodes(value, nodes) {
+			var _this4 = this;
+
+			var parentMatched = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+
+			var matchedIds = [];
+
+			nodes.forEach(function (node) {
+				var currentNodeMatched = node[_this4.defaultOptions.label].indexOf(value) !== -1;
+				var shouldShow = currentNodeMatched || parentMatched;
+
+				if (shouldShow) {
+					matchedIds.push(node[_this4.defaultOptions.id]);
+				}
+
+				if (node[_this4.defaultOptions.children] && node[_this4.defaultOptions.children].length > 0) {
+					var childIds = _this4.findMatchedNodes(value, node[_this4.defaultOptions.children], shouldShow);
+					matchedIds = matchedIds.concat(childIds);
+				}
+			});
+
+			return matchedIds;
+		},
+		expandMatchedNodes: function expandMatchedNodes() {
+			var _this5 = this;
+
+			this.matchedNodeIds.forEach(function (nodeId) {
+				var treeNode = _this5.$refs.tree.store.nodesMap[nodeId];
+				if (treeNode) {
+					treeNode.expand();
+				}
+			});
+		},
+		init: function init() {
+			var _this6 = this;
+
+			var arr = [];
+			if (this.multiple) {
+				arr = this.value ? this.value : [];
+			} else {
+				arr = this.value ? [this.value] : [];
+			}
+			this.$nextTick(function () {
+				_this6.$refs.tree.setCheckedKeys(arr);
+			});
+		},
+		treeCheck: function treeCheck(value, _ref) {
+			var _this7 = this;
+
+			var checkedKeys = _ref.checkedKeys,
+			    checkedNodes = _ref.checkedNodes;
+
+			var arr = [];
+			arr = checkedNodes;
+			var idArr = arr.map(function (item) {
+				return item[_this7.defaultOptions.id];
+			});
+			this.$emit('change', this.multiple ? idArr : idArr[0], this.multiple ? arr : arr[0]);
+		},
+		treeClick: function treeClick(value, node, event) {
+			if (this.multiple) return;
+
+			this.$emit('change', value.id, value);
+			this.popoverOpen = false;
+		},
+		handleClear: function handleClear() {
+			this.$emit('change', this.multiple ? [] : '', this.multiple ? [] : null);
+			this.$refs.tree.setCheckedKeys([]);
+		},
+		turnFormatTreeData: function turnFormatTreeData(arr, data, pId) {
+			var _this8 = this;
+
+			data.forEach(function (item) {
+				var cItem = JSON.parse(JSON.stringify(item));
+				delete cItem[_this8.defaultOptions.children];
+				cItem.pId = pId;
+				arr.push(cItem);
+
+				if (item[_this8.defaultOptions.children] && item[_this8.defaultOptions.children].length > 0) {
+					_this8.turnFormatTreeData(arr, item[_this8.defaultOptions.children], item[_this8.defaultOptions.id]);
+				}
+			});
+			return arr;
+		}
+	}
+});
+// CONCATENATED MODULE: ./packages/cy/treeSelect/src/main.vue?vue&type=script&lang=js
+ /* harmony default export */ var src_mainvue_type_script_lang_js = (mainvue_type_script_lang_js); 
+// EXTERNAL MODULE: ./node_modules/vue-loader/lib/runtime/componentNormalizer.js
+var componentNormalizer = __webpack_require__(0);
+
+// CONCATENATED MODULE: ./packages/cy/treeSelect/src/main.vue
+
+
+
+
+
+/* normalize component */
+
+var component = Object(componentNormalizer["a" /* default */])(
+  src_mainvue_type_script_lang_js,
+  render,
+  staticRenderFns,
+  false,
+  null,
+  null,
+  null
+  
+)
+
+/* harmony default export */ var main = (component.exports);
+// CONCATENATED MODULE: ./packages/cy/treeSelect/index.js
+
+
+main.install = function (Vue) {
+	Vue.component(main.name, main);
+};
+
+/* harmony default export */ var treeSelect = __webpack_exports__["default"] = (main);
+
+/***/ }),
+
+/***/ 13:
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+// ESM COMPAT FLAG
+__webpack_require__.r(__webpack_exports__);
+
+// CONCATENATED MODULE: ./node_modules/vue-loader/lib/loaders/templateLoader.js??vue-loader-options!./node_modules/vue-loader/lib??vue-loader-options!./packages/input/src/input.vue?vue&type=template&id=048a9cde
+var render = function () {
+  var _vm = this
+  var _h = _vm.$createElement
+  var _c = _vm._self._c || _h
+  return _c(
+    "div",
+    {
+      class: [
+        _vm.type === "textarea" ? "el-textarea" : "el-input",
+        _vm.inputSize ? "el-input--" + _vm.inputSize : "",
+        {
+          "is-disabled": _vm.inputDisabled,
+          "is-exceed": _vm.inputExceed,
+          "el-input-group": _vm.$slots.prepend || _vm.$slots.append,
+          "el-input-group--append": _vm.$slots.append,
+          "el-input-group--prepend": _vm.$slots.prepend,
+          "el-input--prefix": _vm.$slots.prefix || _vm.prefixIcon,
+          "el-input--suffix":
+            _vm.$slots.suffix ||
+            _vm.suffixIcon ||
+            _vm.clearable ||
+            _vm.showPassword,
+        },
+      ],
+      on: {
+        mouseenter: function ($event) {
+          _vm.hovering = true
+        },
+        mouseleave: function ($event) {
+          _vm.hovering = false
+        },
+      },
+    },
+    [
+      _vm.type !== "textarea"
+        ? [
+            _vm.$slots.prepend
+              ? _c(
+                  "div",
+                  { staticClass: "el-input-group__prepend" },
+                  [_vm._t("prepend")],
+                  2
+                )
+              : _vm._e(),
+            _vm.type !== "textarea"
+              ? _c(
+                  "input",
+                  _vm._b(
+                    {
+                      ref: "input",
+                      staticClass: "el-input__inner",
+                      attrs: {
+                        tabindex: _vm.tabindex,
+                        type: _vm.showPassword
+                          ? _vm.passwordVisible
+                            ? "text"
+                            : "password"
+                          : _vm.type,
+                        disabled: _vm.inputDisabled,
+                        readonly: _vm.readonly,
+                        autocomplete: _vm.autoComplete || _vm.autocomplete,
+                        "aria-label": _vm.label,
+                      },
+                      on: {
+                        compositionstart: _vm.handleCompositionStart,
+                        compositionupdate: _vm.handleCompositionUpdate,
+                        compositionend: _vm.handleCompositionEnd,
+                        input: _vm.handleInput,
+                        focus: _vm.handleFocus,
+                        blur: _vm.handleBlur,
+                        change: _vm.handleChange,
+                      },
+                    },
+                    "input",
+                    _vm.$attrs,
+                    false
+                  )
+                )
+              : _vm._e(),
+            _vm.$slots.prefix || _vm.prefixIcon
+              ? _c(
+                  "span",
+                  { staticClass: "el-input__prefix" },
+                  [
+                    _vm._t("prefix"),
+                    _vm.prefixIcon
+                      ? _c("i", {
+                          staticClass: "el-input__icon",
+                          class: _vm.prefixIcon,
+                        })
+                      : _vm._e(),
+                  ],
+                  2
+                )
+              : _vm._e(),
+            _vm.getSuffixVisible()
+              ? _c("span", { staticClass: "el-input__suffix" }, [
+                  _c(
+                    "span",
+                    { staticClass: "el-input__suffix-inner" },
+                    [
+                      !_vm.showClear ||
+                      !_vm.showPwdVisible ||
+                      !_vm.isWordLimitVisible
+                        ? [
+                            _vm._t("suffix"),
+                            _vm.suffixIcon
+                              ? _c("i", {
+                                  staticClass: "el-input__icon",
+                                  class: _vm.suffixIcon,
+                                })
+                              : _vm._e(),
+                          ]
+                        : _vm._e(),
+                      _vm.showClear
+                        ? _c("i", {
+                            staticClass:
+                              "el-input__icon el-icon-circle-close el-input__clear",
+                            on: {
+                              mousedown: function ($event) {
+                                $event.preventDefault()
+                              },
+                              click: _vm.clear,
+                            },
+                          })
+                        : _vm._e(),
+                      _vm.showPwdVisible
+                        ? _c("i", {
+                            staticClass:
+                              "el-input__icon el-icon-view el-input__clear",
+                            on: { click: _vm.handlePasswordVisible },
+                          })
+                        : _vm._e(),
+                      _vm.isWordLimitVisible
+                        ? _c("span", { staticClass: "el-input__count" }, [
+                            _c(
+                              "span",
+                              { staticClass: "el-input__count-inner" },
+                              [
+                                _vm._v(
+                                  "\n\t\t\t\t\t\t\t" +
+                                    _vm._s(_vm.textLength) +
+                                    "/" +
+                                    _vm._s(_vm.upperLimit) +
+                                    "\n\t\t\t\t\t\t"
+                                ),
+                              ]
+                            ),
+                          ])
+                        : _vm._e(),
+                    ],
+                    2
+                  ),
+                  _vm.validateState
+                    ? _c("i", {
+                        staticClass: "el-input__icon",
+                        class: ["el-input__validateIcon", _vm.validateIcon],
+                      })
+                    : _vm._e(),
+                ])
+              : _vm._e(),
+            _vm.$slots.append
+              ? _c(
+                  "div",
+                  { staticClass: "el-input-group__append" },
+                  [_vm._t("append")],
+                  2
+                )
+              : _vm._e(),
+          ]
+        : _c(
+            "textarea",
+            _vm._b(
+              {
+                ref: "textarea",
+                staticClass: "el-textarea__inner",
+                style: _vm.textareaStyle,
+                attrs: {
+                  tabindex: _vm.tabindex,
+                  disabled: _vm.inputDisabled,
+                  readonly: _vm.readonly,
+                  autocomplete: _vm.autoComplete || _vm.autocomplete,
+                  "aria-label": _vm.label,
+                },
+                on: {
+                  compositionstart: _vm.handleCompositionStart,
+                  compositionupdate: _vm.handleCompositionUpdate,
+                  compositionend: _vm.handleCompositionEnd,
+                  input: _vm.handleInput,
+                  focus: _vm.handleFocus,
+                  blur: _vm.handleBlur,
+                  change: _vm.handleChange,
+                },
+              },
+              "textarea",
+              _vm.$attrs,
+              false
+            )
+          ),
+      _vm.isWordLimitVisible && _vm.type === "textarea"
+        ? _c("span", { staticClass: "el-input__count" }, [
+            _vm._v(_vm._s(_vm.textLength) + "/" + _vm._s(_vm.upperLimit)),
+          ])
+        : _vm._e(),
+    ],
+    2
+  )
+}
+var staticRenderFns = []
+render._withStripped = true
+
+
+// CONCATENATED MODULE: ./packages/input/src/input.vue?vue&type=template&id=048a9cde
+
+// EXTERNAL MODULE: external "element-ui/lib/mixins/emitter"
+var emitter_ = __webpack_require__(4);
+var emitter_default = /*#__PURE__*/__webpack_require__.n(emitter_);
+
+// EXTERNAL MODULE: external "element-ui/lib/mixins/migrating"
+var migrating_ = __webpack_require__(7);
+var migrating_default = /*#__PURE__*/__webpack_require__.n(migrating_);
+
+// CONCATENATED MODULE: ./packages/input/src/calcTextareaHeight.js
+var hiddenTextarea = void 0;
+
+var HIDDEN_STYLE = '\n  height:0 !important;\n  visibility:hidden !important;\n  overflow:hidden !important;\n  position:absolute !important;\n  z-index:-1000 !important;\n  top:0 !important;\n  right:0 !important\n';
+
+var CONTEXT_STYLE = ['letter-spacing', 'line-height', 'padding-top', 'padding-bottom', 'font-family', 'font-weight', 'font-size', 'text-rendering', 'text-transform', 'width', 'text-indent', 'padding-left', 'padding-right', 'border-width', 'box-sizing'];
+
+function calculateNodeStyling(targetElement) {
+	var style = window.getComputedStyle(targetElement);
+
+	var boxSizing = style.getPropertyValue('box-sizing');
+
+	var paddingSize = parseFloat(style.getPropertyValue('padding-bottom')) + parseFloat(style.getPropertyValue('padding-top'));
+
+	var borderSize = parseFloat(style.getPropertyValue('border-bottom-width')) + parseFloat(style.getPropertyValue('border-top-width'));
+
+	var contextStyle = CONTEXT_STYLE.map(function (name) {
+		return name + ':' + style.getPropertyValue(name);
+	}).join(';');
+
+	return { contextStyle: contextStyle, paddingSize: paddingSize, borderSize: borderSize, boxSizing: boxSizing };
+}
+
+function calcTextareaHeight(targetElement) {
+	var minRows = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
+	var maxRows = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
+
+	if (!hiddenTextarea) {
+		hiddenTextarea = document.createElement('textarea');
+		document.body.appendChild(hiddenTextarea);
+	}
+
+	var _calculateNodeStyling = calculateNodeStyling(targetElement),
+	    paddingSize = _calculateNodeStyling.paddingSize,
+	    borderSize = _calculateNodeStyling.borderSize,
+	    boxSizing = _calculateNodeStyling.boxSizing,
+	    contextStyle = _calculateNodeStyling.contextStyle;
+
+	hiddenTextarea.setAttribute('style', contextStyle + ';' + HIDDEN_STYLE);
+	hiddenTextarea.value = targetElement.value || targetElement.placeholder || '';
+
+	var height = hiddenTextarea.scrollHeight;
+	var result = {};
+
+	if (boxSizing === 'border-box') {
+		height = height + borderSize;
+	} else if (boxSizing === 'content-box') {
+		height = height - paddingSize;
+	}
+
+	hiddenTextarea.value = '';
+	var singleRowHeight = hiddenTextarea.scrollHeight - paddingSize;
+
+	if (minRows !== null) {
+		var minHeight = singleRowHeight * minRows;
+		if (boxSizing === 'border-box') {
+			minHeight = minHeight + paddingSize + borderSize;
+		}
+		height = Math.max(minHeight, height);
+		result.minHeight = minHeight + 'px';
+	}
+	if (maxRows !== null) {
+		var maxHeight = singleRowHeight * maxRows;
+		if (boxSizing === 'border-box') {
+			maxHeight = maxHeight + paddingSize + borderSize;
+		}
+		height = Math.min(maxHeight, height);
+	}
+	result.height = height + 'px';
+	hiddenTextarea.parentNode && hiddenTextarea.parentNode.removeChild(hiddenTextarea);
+	hiddenTextarea = null;
+	return result;
+};
+// EXTERNAL MODULE: external "element-ui/lib/utils/merge"
+var merge_ = __webpack_require__(6);
+var merge_default = /*#__PURE__*/__webpack_require__.n(merge_);
+
+// EXTERNAL MODULE: external "element-ui/lib/utils/shared"
+var shared_ = __webpack_require__(11);
+
+// CONCATENATED MODULE: ./node_modules/babel-loader/lib!./node_modules/vue-loader/lib??vue-loader-options!./packages/input/src/input.vue?vue&type=script&lang=js
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+
+
+
+
+
+
+
+/* harmony default export */ var inputvue_type_script_lang_js = ({
+	name: 'ElInput',
+
+	componentName: 'ElInput',
+
+	mixins: [emitter_default.a, migrating_default.a],
+
+	inheritAttrs: false,
+
+	inject: {
+		elForm: {
+			default: ''
+		},
+		elFormItem: {
+			default: ''
+		}
+	},
+
+	data: function data() {
+		return {
+			textareaCalcStyle: {},
+			hovering: false,
+			focused: false,
+			isComposing: false,
+			passwordVisible: false
+		};
+	},
+
+
+	props: {
+		value: [String, Number],
+		size: String,
+		resize: String,
+		form: String,
+		disabled: Boolean,
+		readonly: Boolean,
+		type: {
+			type: String,
+			default: 'text'
+		},
+		autosize: {
+			type: [Boolean, Object],
+			default: false
+		},
+		autocomplete: {
+			type: String,
+			default: 'off'
+		},
+		/** @Deprecated in next major version */
+		autoComplete: {
+			type: String,
+			validator: function validator(val) {
+				 false && false;
+				return true;
+			}
+		},
+		validateEvent: {
+			type: Boolean,
+			default: true
+		},
+		suffixIcon: String,
+		prefixIcon: String,
+		label: String,
+		clearable: {
+			type: Boolean,
+			default: false
+		},
+		showPassword: {
+			type: Boolean,
+			default: false
+		},
+		showWordLimit: {
+			type: Boolean,
+			default: false
+		},
+		tabindex: String
+	},
+
+	computed: {
+		_elFormItemSize: function _elFormItemSize() {
+			return (this.elFormItem || {}).elFormItemSize;
+		},
+		validateState: function validateState() {
+			return this.elFormItem ? this.elFormItem.validateState : '';
+		},
+		needStatusIcon: function needStatusIcon() {
+			return this.elForm ? this.elForm.statusIcon : false;
+		},
+		validateIcon: function validateIcon() {
+			return {
+				validating: 'el-icon-loading',
+				success: 'el-icon-circle-check',
+				error: 'el-icon-circle-close'
+			}[this.validateState];
+		},
+		textareaStyle: function textareaStyle() {
+			return merge_default()({}, this.textareaCalcStyle, { resize: this.resize });
+		},
+		inputSize: function inputSize() {
+			return this.size || this._elFormItemSize || (this.$ELEMENT || {}).size;
+		},
+		inputDisabled: function inputDisabled() {
+			return this.disabled || (this.elForm || {}).disabled;
+		},
+		nativeInputValue: function nativeInputValue() {
+			return this.value === null || this.value === undefined ? '' : String(this.value);
+		},
+		showClear: function showClear() {
+			return this.clearable && !this.inputDisabled && !this.readonly && this.nativeInputValue && (this.focused || this.hovering);
+		},
+		showPwdVisible: function showPwdVisible() {
+			return this.showPassword && !this.inputDisabled && !this.readonly && (!!this.nativeInputValue || this.focused);
+		},
+		isWordLimitVisible: function isWordLimitVisible() {
+			return this.showWordLimit && this.$attrs.maxlength && (this.type === 'text' || this.type === 'textarea') && !this.inputDisabled && !this.readonly && !this.showPassword;
+		},
+		upperLimit: function upperLimit() {
+			return this.$attrs.maxlength;
+		},
+		textLength: function textLength() {
+			if (typeof this.value === 'number') {
+				return String(this.value).length;
+			}
+
+			return (this.value || '').length;
+		},
+		inputExceed: function inputExceed() {
+			// show exceed style if length of initial value greater then maxlength
+			return this.isWordLimitVisible && this.textLength > this.upperLimit;
+		}
+	},
+
+	watch: {
+		value: function value(val) {
+			this.$nextTick(this.resizeTextarea);
+			if (this.validateEvent) {
+				this.dispatch('ElFormItem', 'el.form.change', [val]);
+			}
+		},
+
+		// native input value is set explicitly
+		// do not use v-model / :value in template
+		// see: https://github.com/ElemeFE/element/issues/14521
+		nativeInputValue: function nativeInputValue() {
+			this.setNativeInputValue();
+		},
+
+		// when change between <input> and <textarea>,
+		// update DOM dependent value and styles
+		// https://github.com/ElemeFE/element/issues/14857
+		type: function type() {
+			var _this = this;
+
+			this.$nextTick(function () {
+				_this.setNativeInputValue();
+				_this.resizeTextarea();
+				_this.updateIconOffset();
+			});
+		}
+	},
+
+	methods: {
+		focus: function focus() {
+			this.getInput().focus();
+		},
+		blur: function blur() {
+			this.getInput().blur();
+		},
+		getMigratingConfig: function getMigratingConfig() {
+			return {
+				props: {
+					'icon': 'icon is removed, use suffix-icon / prefix-icon instead.',
+					'on-icon-click': 'on-icon-click is removed.'
+				},
+				events: {
+					'click': 'click is removed.'
+				}
+			};
+		},
+		handleBlur: function handleBlur(event) {
+			this.focused = false;
+			this.$emit('blur', event);
+			if (this.validateEvent) {
+				this.dispatch('ElFormItem', 'el.form.blur', [this.value]);
+			}
+		},
+		select: function select() {
+			this.getInput().select();
+		},
+		resizeTextarea: function resizeTextarea() {
+			if (this.$isServer) return;
+			var autosize = this.autosize,
+			    type = this.type;
+
+			if (type !== 'textarea') return;
+			if (!autosize) {
+				this.textareaCalcStyle = {
+					minHeight: calcTextareaHeight(this.$refs.textarea).minHeight
+				};
+				return;
+			}
+			var minRows = autosize.minRows;
+			var maxRows = autosize.maxRows;
+
+			this.textareaCalcStyle = calcTextareaHeight(this.$refs.textarea, minRows, maxRows);
+		},
+		setNativeInputValue: function setNativeInputValue() {
+			var input = this.getInput();
+			if (!input) return;
+			if (input.value === this.nativeInputValue) return;
+			input.value = this.nativeInputValue;
+		},
+		handleFocus: function handleFocus(event) {
+			this.focused = true;
+			this.$emit('focus', event);
+		},
+		handleCompositionStart: function handleCompositionStart(event) {
+			this.$emit('compositionstart', event);
+			this.isComposing = true;
+		},
+		handleCompositionUpdate: function handleCompositionUpdate(event) {
+			this.$emit('compositionupdate', event);
+			var text = event.target.value;
+			var lastCharacter = text[text.length - 1] || '';
+			this.isComposing = !Object(shared_["isKorean"])(lastCharacter);
+		},
+		handleCompositionEnd: function handleCompositionEnd(event) {
+			this.$emit('compositionend', event);
+			if (this.isComposing) {
+				this.isComposing = false;
+				this.handleInput(event);
+			}
+		},
+		handleInput: function handleInput(event) {
+			// should not emit input during composition
+			// see: https://github.com/ElemeFE/element/issues/10516
+			if (this.isComposing) return;
+
+			// hack for https://github.com/ElemeFE/element/issues/8548
+			// should remove the following line when we don't support IE
+			if (event.target.value === this.nativeInputValue) return;
+
+			this.$emit('input', event.target.value);
+
+			// ensure native input value is controlled
+			// see: https://github.com/ElemeFE/element/issues/12850
+			this.$nextTick(this.setNativeInputValue);
+		},
+		handleChange: function handleChange(event) {
+			this.$emit('change', event.target.value);
+		},
+		calcIconOffset: function calcIconOffset(place) {
+			var elList = [].slice.call(this.$el.querySelectorAll('.el-input__' + place) || []);
+			if (!elList.length) return;
+			var el = null;
+			for (var i = 0; i < elList.length; i++) {
+				if (elList[i].parentNode === this.$el) {
+					el = elList[i];
+					break;
+				}
+			}
+			if (!el) return;
+			var pendantMap = {
+				suffix: 'append',
+				prefix: 'prepend'
+			};
+
+			var pendant = pendantMap[place];
+			if (this.$slots[pendant]) {
+				el.style.transform = 'translateX(' + (place === 'suffix' ? '-' : '') + this.$el.querySelector('.el-input-group__' + pendant).offsetWidth + 'px)';
+			} else {
+				el.removeAttribute('style');
+			}
+		},
+		updateIconOffset: function updateIconOffset() {
+			this.calcIconOffset('prefix');
+			this.calcIconOffset('suffix');
+		},
+		clear: function clear() {
+			this.$emit('input', '');
+			this.$emit('change', '');
+			this.$emit('clear');
+		},
+		handlePasswordVisible: function handlePasswordVisible() {
+			var _this2 = this;
+
+			this.passwordVisible = !this.passwordVisible;
+			this.$nextTick(function () {
+				_this2.focus();
+			});
+		},
+		getInput: function getInput() {
+			return this.$refs.input || this.$refs.textarea;
+		},
+		getSuffixVisible: function getSuffixVisible() {
+			return this.$slots.suffix || this.suffixIcon || this.showClear || this.showPassword || this.isWordLimitVisible || this.validateState && this.needStatusIcon;
+		}
+	},
+
+	created: function created() {
+		this.$on('inputSelect', this.select);
+	},
+	mounted: function mounted() {
+		this.setNativeInputValue();
+		this.resizeTextarea();
+		this.updateIconOffset();
+	},
+	updated: function updated() {
+		this.$nextTick(this.updateIconOffset);
+	}
+});
+// CONCATENATED MODULE: ./packages/input/src/input.vue?vue&type=script&lang=js
+ /* harmony default export */ var src_inputvue_type_script_lang_js = (inputvue_type_script_lang_js); 
+// EXTERNAL MODULE: ./node_modules/vue-loader/lib/runtime/componentNormalizer.js
+var componentNormalizer = __webpack_require__(0);
+
+// CONCATENATED MODULE: ./packages/input/src/input.vue
+
+
+
+
+
+/* normalize component */
+
+var component = Object(componentNormalizer["a" /* default */])(
+  src_inputvue_type_script_lang_js,
+  render,
+  staticRenderFns,
+  false,
+  null,
+  null,
+  null
+  
+)
+
+/* harmony default export */ var input = (component.exports);
+// CONCATENATED MODULE: ./packages/input/index.js
+
+
+/* istanbul ignore next */
+input.install = function (Vue) {
+	Vue.component(input.name, input);
+};
+
+/* harmony default export */ var packages_input = __webpack_exports__["default"] = (input);
+
+/***/ }),
+
+/***/ 16:
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+// ESM COMPAT FLAG
+__webpack_require__.r(__webpack_exports__);
+
+// CONCATENATED MODULE: ./node_modules/vue-loader/lib/loaders/templateLoader.js??vue-loader-options!./node_modules/vue-loader/lib??vue-loader-options!./packages/checkbox/src/checkbox.vue?vue&type=template&id=5f30258f
+var render = function () {
+  var _vm = this
+  var _h = _vm.$createElement
+  var _c = _vm._self._c || _h
+  return _c(
+    "label",
+    {
+      staticClass: "el-checkbox",
+      class: [
+        _vm.border && _vm.checkboxSize
+          ? "el-checkbox--" + _vm.checkboxSize
+          : "",
+        { "is-disabled": _vm.isDisabled },
+        { "is-bordered": _vm.border },
+        { "is-checked": _vm.isChecked },
+      ],
+      attrs: { id: _vm.id },
+    },
+    [
+      _c(
+        "span",
+        {
+          staticClass: "el-checkbox__input",
+          class: {
+            "is-disabled": _vm.isDisabled,
+            "is-checked": _vm.isChecked,
+            "is-indeterminate": _vm.indeterminate,
+            "is-focus": _vm.focus,
+          },
+          attrs: {
+            tabindex: _vm.indeterminate ? 0 : false,
+            role: _vm.indeterminate ? "checkbox" : false,
+            "aria-checked": _vm.indeterminate ? "mixed" : false,
+          },
+        },
+        [
+          _c("span", { staticClass: "el-checkbox__inner" }),
+          _vm.trueLabel || _vm.falseLabel
+            ? _c("input", {
+                directives: [
+                  {
+                    name: "model",
+                    rawName: "v-model",
+                    value: _vm.model,
+                    expression: "model",
+                  },
+                ],
+                staticClass: "el-checkbox__original",
+                attrs: {
+                  type: "checkbox",
+                  "aria-hidden": _vm.indeterminate ? "true" : "false",
+                  name: _vm.name,
+                  disabled: _vm.isDisabled,
+                  "true-value": _vm.trueLabel,
+                  "false-value": _vm.falseLabel,
+                },
+                domProps: {
+                  checked: Array.isArray(_vm.model)
+                    ? _vm._i(_vm.model, null) > -1
+                    : _vm._q(_vm.model, _vm.trueLabel),
+                },
+                on: {
+                  change: [
+                    function ($event) {
+                      var $$a = _vm.model,
+                        $$el = $event.target,
+                        $$c = $$el.checked ? _vm.trueLabel : _vm.falseLabel
+                      if (Array.isArray($$a)) {
+                        var $$v = null,
+                          $$i = _vm._i($$a, $$v)
+                        if ($$el.checked) {
+                          $$i < 0 && (_vm.model = $$a.concat([$$v]))
+                        } else {
+                          $$i > -1 &&
+                            (_vm.model = $$a
+                              .slice(0, $$i)
+                              .concat($$a.slice($$i + 1)))
+                        }
+                      } else {
+                        _vm.model = $$c
+                      }
+                    },
+                    _vm.handleChange,
+                  ],
+                  focus: function ($event) {
+                    _vm.focus = true
+                  },
+                  blur: function ($event) {
+                    _vm.focus = false
+                  },
+                },
+              })
+            : _c("input", {
+                directives: [
+                  {
+                    name: "model",
+                    rawName: "v-model",
+                    value: _vm.model,
+                    expression: "model",
+                  },
+                ],
+                staticClass: "el-checkbox__original",
+                attrs: {
+                  type: "checkbox",
+                  "aria-hidden": _vm.indeterminate ? "true" : "false",
+                  disabled: _vm.isDisabled,
+                  name: _vm.name,
+                },
+                domProps: {
+                  value: _vm.label,
+                  checked: Array.isArray(_vm.model)
+                    ? _vm._i(_vm.model, _vm.label) > -1
+                    : _vm.model,
+                },
+                on: {
+                  change: [
+                    function ($event) {
+                      var $$a = _vm.model,
+                        $$el = $event.target,
+                        $$c = $$el.checked ? true : false
+                      if (Array.isArray($$a)) {
+                        var $$v = _vm.label,
+                          $$i = _vm._i($$a, $$v)
+                        if ($$el.checked) {
+                          $$i < 0 && (_vm.model = $$a.concat([$$v]))
+                        } else {
+                          $$i > -1 &&
+                            (_vm.model = $$a
+                              .slice(0, $$i)
+                              .concat($$a.slice($$i + 1)))
+                        }
+                      } else {
+                        _vm.model = $$c
+                      }
+                    },
+                    _vm.handleChange,
+                  ],
+                  focus: function ($event) {
+                    _vm.focus = true
+                  },
+                  blur: function ($event) {
+                    _vm.focus = false
+                  },
+                },
+              }),
+        ]
+      ),
+      _vm.$slots.default || _vm.label
+        ? _c(
+            "span",
+            { staticClass: "el-checkbox__label" },
+            [
+              _vm._t("default"),
+              !_vm.$slots.default ? [_vm._v(_vm._s(_vm.label))] : _vm._e(),
+            ],
+            2
+          )
+        : _vm._e(),
+    ]
+  )
+}
+var staticRenderFns = []
+render._withStripped = true
+
+
+// CONCATENATED MODULE: ./packages/checkbox/src/checkbox.vue?vue&type=template&id=5f30258f
+
+// 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/lib!./node_modules/vue-loader/lib??vue-loader-options!./packages/checkbox/src/checkbox.vue?vue&type=script&lang=js
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+
+
+
+/* harmony default export */ var checkboxvue_type_script_lang_js = ({
+	name: 'ElCheckbox',
+
+	mixins: [emitter_default.a],
+
+	inject: {
+		elForm: {
+			default: ''
+		},
+		elFormItem: {
+			default: ''
+		}
+	},
+
+	componentName: 'ElCheckbox',
+
+	data: function data() {
+		return {
+			selfModel: false,
+			focus: false,
+			isLimitExceeded: false
+		};
+	},
+
+
+	computed: {
+		model: {
+			get: function get() {
+				return this.isGroup ? this.store : this.value !== undefined ? this.value : this.selfModel;
+			},
+			set: function set(val) {
+				if (this.isGroup) {
+					this.isLimitExceeded = false;
+					this._checkboxGroup.min !== undefined && val.length < this._checkboxGroup.min && (this.isLimitExceeded = true);
+
+					this._checkboxGroup.max !== undefined && val.length > this._checkboxGroup.max && (this.isLimitExceeded = true);
+
+					this.isLimitExceeded === false && this.dispatch('ElCheckboxGroup', 'input', [val]);
+				} else {
+					this.$emit('input', val);
+					this.selfModel = val;
+				}
+			}
+		},
+
+		isChecked: function isChecked() {
+			if ({}.toString.call(this.model) === '[object Boolean]') {
+				return this.model;
+			} else if (Array.isArray(this.model)) {
+				return this.model.indexOf(this.label) > -1;
+			} else if (this.model !== null && this.model !== undefined) {
+				return this.model === this.trueLabel;
+			}
+		},
+		isGroup: function isGroup() {
+			var parent = this.$parent;
+			while (parent) {
+				if (parent.$options.componentName !== 'ElCheckboxGroup') {
+					parent = parent.$parent;
+				} else {
+					this._checkboxGroup = parent;
+					return true;
+				}
+			}
+			return false;
+		},
+		store: function store() {
+			return this._checkboxGroup ? this._checkboxGroup.value : this.value;
+		},
+
+
+		/* used to make the isDisabled judgment under max/min props */
+		isLimitDisabled: function isLimitDisabled() {
+			var _checkboxGroup = this._checkboxGroup,
+			    max = _checkboxGroup.max,
+			    min = _checkboxGroup.min;
+
+			return !!(max || min) && this.model.length >= max && !this.isChecked || this.model.length <= min && this.isChecked;
+		},
+		isDisabled: function isDisabled() {
+			return this.isGroup ? this._checkboxGroup.disabled || this.disabled || (this.elForm || {}).disabled || this.isLimitDisabled : this.disabled || (this.elForm || {}).disabled;
+		},
+		_elFormItemSize: function _elFormItemSize() {
+			return (this.elFormItem || {}).elFormItemSize;
+		},
+		checkboxSize: function checkboxSize() {
+			var temCheckboxSize = this.size || this._elFormItemSize || (this.$ELEMENT || {}).size;
+			return this.isGroup ? this._checkboxGroup.checkboxGroupSize || temCheckboxSize : temCheckboxSize;
+		}
+	},
+
+	props: {
+		value: {},
+		label: {},
+		indeterminate: Boolean,
+		disabled: Boolean,
+		checked: Boolean,
+		name: String,
+		trueLabel: [String, Number],
+		falseLabel: [String, Number],
+		id: String, /* 当indeterminate为真时，为controls提供相关连的checkbox的id，表明元素间的控制关系*/
+		controls: String, /* 当indeterminate为真时，为controls提供相关连的checkbox的id，表明元素间的控制关系*/
+		border: Boolean,
+		size: String
+	},
+
+	methods: {
+		addToStore: function addToStore() {
+			if (Array.isArray(this.model) && this.model.indexOf(this.label) === -1) {
+				this.model.push(this.label);
+			} else {
+				this.model = this.trueLabel || true;
+			}
+		},
+		handleChange: function handleChange(ev) {
+			var _this = this;
+
+			if (this.isLimitExceeded) return;
+			var value = void 0;
+			if (ev.target.checked) {
+				value = this.trueLabel === undefined ? true : this.trueLabel;
+			} else {
+				value = this.falseLabel === undefined ? false : this.falseLabel;
+			}
+			this.$emit('change', value, ev);
+			this.$nextTick(function () {
+				if (_this.isGroup) {
+					_this.dispatch('ElCheckboxGroup', 'change', [_this._checkboxGroup.value]);
+				}
+			});
+		}
+	},
+
+	created: function created() {
+		this.checked && this.addToStore();
+	},
+	mounted: function mounted() {
+		// 为indeterminate元素 添加aria-controls 属性
+		if (this.indeterminate) {
+			this.$el.setAttribute('aria-controls', this.controls);
+		}
+	},
+
+
+	watch: {
+		value: function value(_value) {
+			this.dispatch('ElFormItem', 'el.form.change', _value);
+		}
+	}
+});
+// CONCATENATED MODULE: ./packages/checkbox/src/checkbox.vue?vue&type=script&lang=js
+ /* harmony default export */ var src_checkboxvue_type_script_lang_js = (checkboxvue_type_script_lang_js); 
+// EXTERNAL MODULE: ./node_modules/vue-loader/lib/runtime/componentNormalizer.js
+var componentNormalizer = __webpack_require__(0);
+
+// CONCATENATED MODULE: ./packages/checkbox/src/checkbox.vue
+
+
+
+
+
+/* normalize component */
+
+var component = Object(componentNormalizer["a" /* default */])(
+  src_checkboxvue_type_script_lang_js,
+  render,
+  staticRenderFns,
+  false,
+  null,
+  null,
+  null
+  
+)
+
+/* harmony default export */ var src_checkbox = (component.exports);
+// CONCATENATED MODULE: ./packages/checkbox/index.js
+
+
+/* istanbul ignore next */
+src_checkbox.install = function (Vue) {
+	Vue.component(src_checkbox.name, src_checkbox);
+};
+
+/* harmony default export */ var packages_checkbox = __webpack_exports__["default"] = (src_checkbox);
+
+/***/ }),
+
+/***/ 22:
+/***/ (function(module, exports) {
+
+module.exports = require("element-ui/lib/locale");
+
+/***/ }),
+
+/***/ 27:
+/***/ (function(module, exports) {
+
+module.exports = require("element-ui/lib/transitions/collapse-transition");
+
+/***/ }),
+
+/***/ 3:
+/***/ (function(module, exports) {
+
+module.exports = require("element-ui/lib/utils/util");
+
+/***/ }),
+
+/***/ 36:
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+// ESM COMPAT FLAG
+__webpack_require__.r(__webpack_exports__);
+
+// CONCATENATED MODULE: ./node_modules/vue-loader/lib/loaders/templateLoader.js??vue-loader-options!./node_modules/vue-loader/lib??vue-loader-options!./packages/popover/src/main.vue?vue&type=template&id=0e66f51f
+var render = function () {
+  var _vm = this
+  var _h = _vm.$createElement
+  var _c = _vm._self._c || _h
+  return _c(
+    "span",
+    [
+      _c(
+        "transition",
+        {
+          attrs: { name: _vm.transition },
+          on: {
+            "after-enter": _vm.handleAfterEnter,
+            "after-leave": _vm.handleAfterLeave,
+          },
+        },
+        [
+          _c(
+            "div",
+            {
+              directives: [
+                {
+                  name: "show",
+                  rawName: "v-show",
+                  value: !_vm.disabled && _vm.showPopper,
+                  expression: "!disabled && showPopper",
+                },
+              ],
+              ref: "popper",
+              staticClass: "el-popover el-popper",
+              class: [_vm.popperClass, _vm.content && "el-popover--plain"],
+              style: { width: _vm.width + "px" },
+              attrs: {
+                role: "tooltip",
+                id: _vm.tooltipId,
+                "aria-hidden":
+                  _vm.disabled || !_vm.showPopper ? "true" : "false",
+              },
+            },
+            [
+              _vm.title
+                ? _c("div", {
+                    staticClass: "el-popover__title",
+                    domProps: { textContent: _vm._s(_vm.title) },
+                  })
+                : _vm._e(),
+              _vm._t("default", [_vm._v(_vm._s(_vm.content))]),
+            ],
+            2
+          ),
+        ]
+      ),
+      _c(
+        "span",
+        { ref: "wrapper", staticClass: "el-popover__reference-wrapper" },
+        [_vm._t("reference")],
+        2
+      ),
+    ],
+    1
+  )
+}
+var staticRenderFns = []
+render._withStripped = true
+
+
+// CONCATENATED MODULE: ./packages/popover/src/main.vue?vue&type=template&id=0e66f51f
+
+// EXTERNAL MODULE: external "element-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-ui/lib/utils/dom"
+var dom_ = __webpack_require__(1);
+
+// EXTERNAL MODULE: external "element-ui/lib/utils/util"
+var util_ = __webpack_require__(3);
+
+// CONCATENATED MODULE: ./node_modules/babel-loader/lib!./node_modules/vue-loader/lib??vue-loader-options!./packages/popover/src/main.vue?vue&type=script&lang=js
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+
+
+
+
+
+
+/* harmony default export */ var mainvue_type_script_lang_js = ({
+	name: 'ElPopover',
+
+	mixins: [vue_popper_default.a],
+
+	props: {
+		trigger: {
+			type: String,
+			default: 'click',
+			validator: function validator(value) {
+				return ['click', 'focus', 'hover', 'manual'].indexOf(value) > -1;
+			}
+		},
+		openDelay: {
+			type: Number,
+			default: 0
+		},
+		closeDelay: {
+			type: Number,
+			default: 200
+		},
+		title: String,
+		disabled: Boolean,
+		content: String,
+		reference: {},
+		popperClass: String,
+		width: {},
+		visibleArrow: {
+			default: true
+		},
+		arrowOffset: {
+			type: Number,
+			default: 0
+		},
+		transition: {
+			type: String,
+			default: 'fade-in-linear'
+		},
+		tabindex: {
+			type: Number,
+			default: 0
+		}
+	},
+
+	computed: {
+		tooltipId: function tooltipId() {
+			return 'el-popover-' + Object(util_["generateId"])();
+		}
+	},
+	watch: {
+		showPopper: function showPopper(val) {
+			if (this.disabled) {
+				return;
+			}
+			val ? this.$emit('show') : this.$emit('hide');
+		}
+	},
+
+	mounted: function mounted() {
+		var _this = this;
+
+		var reference = this.referenceElm = this.reference || this.$refs.reference;
+		var popper = this.popper || this.$refs.popper;
+
+		if (!reference && this.$refs.wrapper.children) {
+			reference = this.referenceElm = this.$refs.wrapper.children[0];
+		}
+		// 可访问性
+		if (reference) {
+			Object(dom_["addClass"])(reference, 'el-popover__reference');
+			reference.setAttribute('aria-describedby', this.tooltipId);
+			reference.setAttribute('tabindex', this.tabindex); // tab序列
+			popper.setAttribute('tabindex', 0);
+
+			if (this.trigger !== 'click') {
+				Object(dom_["on"])(reference, 'focusin', function () {
+					_this.handleFocus();
+					var instance = reference.__vue__;
+					if (instance && typeof instance.focus === 'function') {
+						instance.focus();
+					}
+				});
+				Object(dom_["on"])(popper, 'focusin', this.handleFocus);
+				Object(dom_["on"])(reference, 'focusout', this.handleBlur);
+				Object(dom_["on"])(popper, 'focusout', this.handleBlur);
+			}
+			Object(dom_["on"])(reference, 'keydown', this.handleKeydown);
+			Object(dom_["on"])(reference, 'click', this.handleClick);
+		}
+		if (this.trigger === 'click') {
+			Object(dom_["on"])(reference, 'click', this.doToggle);
+			Object(dom_["on"])(document, 'click', this.handleDocumentClick);
+		} else if (this.trigger === 'hover') {
+			Object(dom_["on"])(reference, 'mouseenter', this.handleMouseEnter);
+			Object(dom_["on"])(popper, 'mouseenter', this.handleMouseEnter);
+			Object(dom_["on"])(reference, 'mouseleave', this.handleMouseLeave);
+			Object(dom_["on"])(popper, 'mouseleave', this.handleMouseLeave);
+		} else if (this.trigger === 'focus') {
+			if (this.tabindex < 0) {
+				console.warn('[Element Warn][Popover]a negative taindex means that the element cannot be focused by tab key');
+			}
+			if (reference.querySelector('input, textarea')) {
+				Object(dom_["on"])(reference, 'focusin', this.doShow);
+				Object(dom_["on"])(reference, 'focusout', this.doClose);
+			} else {
+				Object(dom_["on"])(reference, 'mousedown', this.doShow);
+				Object(dom_["on"])(reference, 'mouseup', this.doClose);
+			}
+		}
+	},
+	beforeDestroy: function beforeDestroy() {
+		this.cleanup();
+	},
+	deactivated: function deactivated() {
+		this.cleanup();
+	},
+
+
+	methods: {
+		doToggle: function doToggle() {
+			this.showPopper = !this.showPopper;
+		},
+		doShow: function doShow() {
+			this.showPopper = true;
+		},
+		doClose: function doClose() {
+			this.showPopper = false;
+		},
+		handleFocus: function handleFocus() {
+			Object(dom_["addClass"])(this.referenceElm, 'focusing');
+			if (this.trigger === 'click' || this.trigger === 'focus') this.showPopper = true;
+		},
+		handleClick: function handleClick() {
+			Object(dom_["removeClass"])(this.referenceElm, 'focusing');
+		},
+		handleBlur: function handleBlur() {
+			Object(dom_["removeClass"])(this.referenceElm, 'focusing');
+			if (this.trigger === 'click' || this.trigger === 'focus') this.showPopper = false;
+		},
+		handleMouseEnter: function handleMouseEnter() {
+			var _this2 = this;
+
+			clearTimeout(this._timer);
+			if (this.openDelay) {
+				this._timer = setTimeout(function () {
+					_this2.showPopper = true;
+				}, this.openDelay);
+			} else {
+				this.showPopper = true;
+			}
+		},
+		handleKeydown: function handleKeydown(ev) {
+			if (ev.keyCode === 27 && this.trigger !== 'manual') {
+				// esc
+				this.doClose();
+			}
+		},
+		handleMouseLeave: function handleMouseLeave() {
+			var _this3 = this;
+
+			clearTimeout(this._timer);
+			if (this.closeDelay) {
+				this._timer = setTimeout(function () {
+					_this3.showPopper = false;
+				}, this.closeDelay);
+			} else {
+				this.showPopper = false;
+			}
+		},
+		handleDocumentClick: function handleDocumentClick(e) {
+			var reference = this.reference || this.$refs.reference;
+			var popper = this.popper || this.$refs.popper;
+
+			if (!reference && this.$refs.wrapper.children) {
+				reference = this.referenceElm = this.$refs.wrapper.children[0];
+			}
+			if (!this.$el || !reference || this.$el.contains(e.target) || reference.contains(e.target) || !popper || popper.contains(e.target)) return;
+			this.showPopper = false;
+		},
+		handleAfterEnter: function handleAfterEnter() {
+			this.$emit('after-enter');
+		},
+		handleAfterLeave: function handleAfterLeave() {
+			this.$emit('after-leave');
+			this.doDestroy();
+		},
+		cleanup: function cleanup() {
+			if (this.openDelay || this.closeDelay) {
+				clearTimeout(this._timer);
+			}
+		}
+	},
+
+	destroyed: function destroyed() {
+		var reference = this.reference;
+
+		Object(dom_["off"])(reference, 'click', this.doToggle);
+		Object(dom_["off"])(reference, 'mouseup', this.doClose);
+		Object(dom_["off"])(reference, 'mousedown', this.doShow);
+		Object(dom_["off"])(reference, 'focusin', this.doShow);
+		Object(dom_["off"])(reference, 'focusout', this.doClose);
+		Object(dom_["off"])(reference, 'mousedown', this.doShow);
+		Object(dom_["off"])(reference, 'mouseup', this.doClose);
+		Object(dom_["off"])(reference, 'mouseleave', this.handleMouseLeave);
+		Object(dom_["off"])(reference, 'mouseenter', this.handleMouseEnter);
+		Object(dom_["off"])(document, 'click', this.handleDocumentClick);
+	}
+});
+// CONCATENATED MODULE: ./packages/popover/src/main.vue?vue&type=script&lang=js
+ /* harmony default export */ var src_mainvue_type_script_lang_js = (mainvue_type_script_lang_js); 
+// EXTERNAL MODULE: ./node_modules/vue-loader/lib/runtime/componentNormalizer.js
+var componentNormalizer = __webpack_require__(0);
+
+// CONCATENATED MODULE: ./packages/popover/src/main.vue
+
+
+
+
+
+/* normalize component */
+
+var component = Object(componentNormalizer["a" /* default */])(
+  src_mainvue_type_script_lang_js,
+  render,
+  staticRenderFns,
+  false,
+  null,
+  null,
+  null
+  
+)
+
+/* harmony default export */ var main = (component.exports);
+// CONCATENATED MODULE: ./packages/popover/src/directive.js
+var getReference = function getReference(el, binding, vnode) {
+	var _ref = binding.expression ? binding.value : binding.arg;
+	var popper = vnode.context.$refs[_ref];
+	if (popper) {
+		if (Array.isArray(popper)) {
+			popper[0].$refs.reference = el;
+		} else {
+			popper.$refs.reference = el;
+		}
+	}
+};
+
+/* harmony default export */ var directive = ({
+	bind: function bind(el, binding, vnode) {
+		getReference(el, binding, vnode);
+	},
+	inserted: function inserted(el, binding, vnode) {
+		getReference(el, binding, vnode);
+	}
+});
+// EXTERNAL MODULE: external "vue"
+var external_vue_ = __webpack_require__(8);
+var external_vue_default = /*#__PURE__*/__webpack_require__.n(external_vue_);
+
+// CONCATENATED MODULE: ./packages/popover/index.js
+
+
+
+
+external_vue_default.a.directive('popover', directive);
+
+/* istanbul ignore next */
+main.install = function (Vue) {
+	Vue.directive('popover', directive);
+	Vue.component(main.name, main);
+};
+main.directive = directive;
+
+/* harmony default export */ var popover = __webpack_exports__["default"] = (main);
+
+/***/ }),
+
+/***/ 4:
+/***/ (function(module, exports) {
+
+module.exports = require("element-ui/lib/mixins/emitter");
+
+/***/ }),
+
+/***/ 46:
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+// ESM COMPAT FLAG
+__webpack_require__.r(__webpack_exports__);
+
+// CONCATENATED MODULE: ./node_modules/vue-loader/lib/loaders/templateLoader.js??vue-loader-options!./node_modules/vue-loader/lib??vue-loader-options!./packages/tree/src/tree.vue?vue&type=template&id=37500abf
+var render = function () {
+  var _vm = this
+  var _h = _vm.$createElement
+  var _c = _vm._self._c || _h
+  return _c(
+    "div",
+    {
+      staticClass: "el-tree",
+      class: {
+        "el-tree--highlight-current": _vm.highlightCurrent,
+        "is-dragging": !!_vm.dragState.draggingNode,
+        "is-drop-not-allow": !_vm.dragState.allowDrop,
+        "is-drop-inner": _vm.dragState.dropType === "inner",
+      },
+      attrs: { role: "tree" },
+    },
+    [
+      _vm._l(_vm.root.childNodes, function (child) {
+        return _c("el-tree-node", {
+          key: _vm.getNodeKey(child),
+          attrs: {
+            node: child,
+            props: _vm.props,
+            "render-after-expand": _vm.renderAfterExpand,
+            "show-checkbox": _vm.showCheckbox,
+            "render-content": _vm.renderContent,
+          },
+          on: { "node-expand": _vm.handleNodeExpand },
+        })
+      }),
+      _vm.isEmpty
+        ? _c("div", { staticClass: "el-tree__empty-block" }, [
+            _c("span", { staticClass: "el-tree__empty-text" }, [
+              _vm._v(_vm._s(_vm.emptyText)),
+            ]),
+          ])
+        : _vm._e(),
+      _c("div", {
+        directives: [
+          {
+            name: "show",
+            rawName: "v-show",
+            value: _vm.dragState.showDropIndicator,
+            expression: "dragState.showDropIndicator",
+          },
+        ],
+        ref: "dropIndicator",
+        staticClass: "el-tree__drop-indicator",
+      }),
+    ],
+    2
+  )
+}
+var staticRenderFns = []
+render._withStripped = true
+
+
+// CONCATENATED MODULE: ./packages/tree/src/tree.vue?vue&type=template&id=37500abf
+
+// EXTERNAL MODULE: external "element-ui/lib/utils/merge"
+var merge_ = __webpack_require__(6);
+var merge_default = /*#__PURE__*/__webpack_require__.n(merge_);
+
+// CONCATENATED MODULE: ./packages/tree/src/model/util.js
+var NODE_KEY = '$treeNodeId';
+
+var markNodeData = function markNodeData(node, data) {
+	if (!data || data[NODE_KEY]) return;
+	Object.defineProperty(data, NODE_KEY, {
+		value: node.id,
+		enumerable: false,
+		configurable: false,
+		writable: false
+	});
+};
+
+var util_getNodeKey = function getNodeKey(key, data) {
+	if (!key) return data[NODE_KEY];
+	return data[key];
+};
+
+var findNearestComponent = function findNearestComponent(element, componentName) {
+	var target = element;
+	while (target && target.tagName !== 'BODY') {
+		if (target.__vue__ && target.__vue__.$options.name === componentName) {
+			return target.__vue__;
+		}
+		target = target.parentNode;
+	}
+	return null;
+};
+// EXTERNAL MODULE: external "element-ui/lib/utils/util"
+var util_ = __webpack_require__(3);
+
+// CONCATENATED MODULE: ./packages/tree/src/model/node.js
+var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+
+
+
+
+var getChildState = function getChildState(node) {
+	var all = true;
+	var none = true;
+	var allWithoutDisable = true;
+	for (var i = 0, j = node.length; i < j; i++) {
+		var n = node[i];
+		if (n.checked !== true || n.indeterminate) {
+			all = false;
+			if (!n.disabled) {
+				allWithoutDisable = false;
+			}
+		}
+		if (n.checked !== false || n.indeterminate) {
+			none = false;
+		}
+	}
+
+	return { all: all, none: none, allWithoutDisable: allWithoutDisable, half: !all && !none };
+};
+
+var reInitChecked = function reInitChecked(node) {
+	if (node.childNodes.length === 0 || node.loading) return;
+
+	var _getChildState = getChildState(node.childNodes),
+	    all = _getChildState.all,
+	    none = _getChildState.none,
+	    half = _getChildState.half;
+
+	if (all) {
+		node.checked = true;
+		node.indeterminate = false;
+	} else if (half) {
+		node.checked = false;
+		node.indeterminate = true;
+	} else if (none) {
+		node.checked = false;
+		node.indeterminate = false;
+	}
+
+	var parent = node.parent;
+	if (!parent || parent.level === 0) return;
+
+	if (!node.store.checkStrictly) {
+		reInitChecked(parent);
+	}
+};
+
+var getPropertyFromData = function getPropertyFromData(node, prop) {
+	var props = node.store.props;
+	var data = node.data || {};
+	var config = props[prop];
+
+	if (typeof config === 'function') {
+		return config(data, node);
+	} else if (typeof config === 'string') {
+		return data[config];
+	} else if (typeof config === 'undefined') {
+		var dataProp = data[prop];
+		return dataProp === undefined ? '' : dataProp;
+	}
+};
+
+var nodeIdSeed = 0;
+
+var node_Node = function () {
+	function Node(options) {
+		_classCallCheck(this, Node);
+
+		this.id = nodeIdSeed++;
+		this.text = null;
+		this.checked = false;
+		this.indeterminate = false;
+		this.data = null;
+		this.expanded = false;
+		this.parent = null;
+		this.visible = true;
+		this.isCurrent = false;
+
+		for (var name in options) {
+			if (options.hasOwnProperty(name)) {
+				this[name] = options[name];
+			}
+		}
+
+		// internal
+		this.level = 0;
+		this.loaded = false;
+		this.childNodes = [];
+		this.loading = false;
+
+		if (this.parent) {
+			this.level = this.parent.level + 1;
+		}
+
+		var store = this.store;
+		if (!store) {
+			throw new Error('[Node]store is required!');
+		}
+		store.registerNode(this);
+
+		var props = store.props;
+		if (props && typeof props.isLeaf !== 'undefined') {
+			var isLeaf = getPropertyFromData(this, 'isLeaf');
+			if (typeof isLeaf === 'boolean') {
+				this.isLeafByUser = isLeaf;
+			}
+		}
+
+		if (store.lazy !== true && this.data) {
+			this.setData(this.data);
+
+			if (store.defaultExpandAll) {
+				this.expanded = true;
+			}
+		} else if (this.level > 0 && store.lazy && store.defaultExpandAll) {
+			this.expand();
+		}
+		if (!Array.isArray(this.data)) {
+			markNodeData(this, this.data);
+		}
+		if (!this.data) return;
+		var defaultExpandedKeys = store.defaultExpandedKeys;
+		var key = store.key;
+		if (key && defaultExpandedKeys && defaultExpandedKeys.indexOf(this.key) !== -1) {
+			this.expand(null, store.autoExpandParent);
+		}
+
+		if (key && store.currentNodeKey !== undefined && this.key === store.currentNodeKey) {
+			store.currentNode = this;
+			store.currentNode.isCurrent = true;
+		}
+
+		if (store.lazy) {
+			store._initDefaultCheckedNode(this);
+		}
+
+		this.updateLeafState();
+	}
+
+	Node.prototype.setData = function setData(data) {
+		if (!Array.isArray(data)) {
+			markNodeData(this, data);
+		}
+
+		this.data = data;
+		this.childNodes = [];
+
+		var children = void 0;
+		if (this.level === 0 && this.data instanceof Array) {
+			children = this.data;
+		} else {
+			children = getPropertyFromData(this, 'children') || [];
+		}
+
+		for (var i = 0, j = children.length; i < j; i++) {
+			this.insertChild({ data: children[i] });
+		}
+	};
+
+	Node.prototype.contains = function contains(target) {
+		var deep = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+
+		var walk = function walk(parent) {
+			var children = parent.childNodes || [];
+			var result = false;
+			for (var i = 0, j = children.length; i < j; i++) {
+				var child = children[i];
+				if (child === target || deep && walk(child)) {
+					result = true;
+					break;
+				}
+			}
+			return result;
+		};
+
+		return walk(this);
+	};
+
+	Node.prototype.remove = function remove() {
+		var parent = this.parent;
+		if (parent) {
+			parent.removeChild(this);
+		}
+	};
+
+	Node.prototype.insertChild = function insertChild(child, index, batch) {
+		if (!child) throw new Error('insertChild error: child is required.');
+
+		if (!(child instanceof Node)) {
+			if (!batch) {
+				var children = this.getChildren(true) || [];
+				if (children.indexOf(child.data) === -1) {
+					if (typeof index === 'undefined' || index < 0) {
+						children.push(child.data);
+					} else {
+						children.splice(index, 0, child.data);
+					}
+				}
+			}
+			merge_default()(child, {
+				parent: this,
+				store: this.store
+			});
+			child = new Node(child);
+		}
+
+		child.level = this.level + 1;
+
+		if (typeof index === 'undefined' || index < 0) {
+			this.childNodes.push(child);
+		} else {
+			this.childNodes.splice(index, 0, child);
+		}
+
+		this.updateLeafState();
+	};
+
+	Node.prototype.insertBefore = function insertBefore(child, ref) {
+		var index = void 0;
+		if (ref) {
+			index = this.childNodes.indexOf(ref);
+		}
+		this.insertChild(child, index);
+	};
+
+	Node.prototype.insertAfter = function insertAfter(child, ref) {
+		var index = void 0;
+		if (ref) {
+			index = this.childNodes.indexOf(ref);
+			if (index !== -1) index += 1;
+		}
+		this.insertChild(child, index);
+	};
+
+	Node.prototype.removeChild = function removeChild(child) {
+		var children = this.getChildren() || [];
+		var dataIndex = children.indexOf(child.data);
+		if (dataIndex > -1) {
+			children.splice(dataIndex, 1);
+		}
+
+		var index = this.childNodes.indexOf(child);
+
+		if (index > -1) {
+			this.store && this.store.deregisterNode(child);
+			child.parent = null;
+			this.childNodes.splice(index, 1);
+		}
+
+		this.updateLeafState();
+	};
+
+	Node.prototype.removeChildByData = function removeChildByData(data) {
+		var targetNode = null;
+
+		for (var i = 0; i < this.childNodes.length; i++) {
+			if (this.childNodes[i].data === data) {
+				targetNode = this.childNodes[i];
+				break;
+			}
+		}
+
+		if (targetNode) {
+			this.removeChild(targetNode);
+		}
+	};
+
+	Node.prototype.expand = function expand(callback, expandParent) {
+		var _this = this;
+
+		var done = function done() {
+			if (expandParent) {
+				var parent = _this.parent;
+				while (parent.level > 0) {
+					parent.expanded = true;
+					parent = parent.parent;
+				}
+			}
+			_this.expanded = true;
+			if (callback) callback();
+		};
+
+		if (this.shouldLoadData()) {
+			this.loadData(function (data) {
+				if (data instanceof Array) {
+					if (_this.checked) {
+						_this.setChecked(true, true);
+					} else if (!_this.store.checkStrictly) {
+						reInitChecked(_this);
+					}
+					done();
+				}
+			});
+		} else {
+			done();
+		}
+	};
+
+	Node.prototype.doCreateChildren = function doCreateChildren(array) {
+		var _this2 = this;
+
+		var defaultProps = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+
+		array.forEach(function (item) {
+			_this2.insertChild(merge_default()({ data: item }, defaultProps), undefined, true);
+		});
+	};
+
+	Node.prototype.collapse = function collapse() {
+		this.expanded = false;
+	};
+
+	Node.prototype.shouldLoadData = function shouldLoadData() {
+		return this.store.lazy === true && this.store.load && !this.loaded;
+	};
+
+	Node.prototype.updateLeafState = function updateLeafState() {
+		if (this.store.lazy === true && this.loaded !== true && typeof this.isLeafByUser !== 'undefined') {
+			this.isLeaf = this.isLeafByUser;
+			return;
+		}
+		var childNodes = this.childNodes;
+		if (!this.store.lazy || this.store.lazy === true && this.loaded === true) {
+			this.isLeaf = !childNodes || childNodes.length === 0;
+			return;
+		}
+		this.isLeaf = false;
+	};
+
+	Node.prototype.setChecked = function setChecked(value, deep, recursion, passValue) {
+		var _this3 = this;
+
+		this.indeterminate = value === 'half';
+		this.checked = value === true;
+
+		if (this.store.checkStrictly) return;
+
+		if (!(this.shouldLoadData() && !this.store.checkDescendants)) {
+			var _getChildState2 = getChildState(this.childNodes),
+			    all = _getChildState2.all,
+			    allWithoutDisable = _getChildState2.allWithoutDisable;
+
+			if (!this.isLeaf && !all && allWithoutDisable) {
+				this.checked = false;
+				value = false;
+			}
+
+			var handleDescendants = function handleDescendants() {
+				if (deep) {
+					var childNodes = _this3.childNodes;
+					for (var i = 0, j = childNodes.length; i < j; i++) {
+						var child = childNodes[i];
+						passValue = passValue || value !== false;
+						var isCheck = child.disabled ? child.checked : passValue;
+						child.setChecked(isCheck, deep, true, passValue);
+					}
+
+					var _getChildState3 = getChildState(childNodes),
+					    half = _getChildState3.half,
+					    _all = _getChildState3.all;
+
+					if (!_all) {
+						_this3.checked = _all;
+						_this3.indeterminate = half;
+					}
+				}
+			};
+
+			if (this.shouldLoadData()) {
+				// Only work on lazy load data.
+				this.loadData(function () {
+					handleDescendants();
+					reInitChecked(_this3);
+				}, {
+					checked: value !== false
+				});
+				return;
+			} else {
+				handleDescendants();
+			}
+		}
+
+		var parent = this.parent;
+		if (!parent || parent.level === 0) return;
+
+		if (!recursion) {
+			reInitChecked(parent);
+		}
+	};
+
+	Node.prototype.getChildren = function getChildren() {
+		var forceInit = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+		// this is data
+		if (this.level === 0) return this.data;
+		var data = this.data;
+		if (!data) return null;
+
+		var props = this.store.props;
+		var children = 'children';
+		if (props) {
+			children = props.children || 'children';
+		}
+
+		if (data[children] === undefined) {
+			data[children] = null;
+		}
+
+		if (forceInit && !data[children]) {
+			data[children] = [];
+		}
+
+		return data[children];
+	};
+
+	Node.prototype.updateChildren = function updateChildren() {
+		var _this4 = this;
+
+		var newData = this.getChildren() || [];
+		var oldData = this.childNodes.map(function (node) {
+			return node.data;
+		});
+
+		var newDataMap = {};
+		var newNodes = [];
+
+		newData.forEach(function (item, index) {
+			var key = item[NODE_KEY];
+			var isNodeExists = !!key && Object(util_["arrayFindIndex"])(oldData, function (data) {
+				return data[NODE_KEY] === key;
+			}) >= 0;
+			if (isNodeExists) {
+				newDataMap[key] = { index: index, data: item };
+			} else {
+				newNodes.push({ index: index, data: item });
+			}
+		});
+
+		if (!this.store.lazy) {
+			oldData.forEach(function (item) {
+				if (!newDataMap[item[NODE_KEY]]) _this4.removeChildByData(item);
+			});
+		}
+
+		newNodes.forEach(function (_ref) {
+			var index = _ref.index,
+			    data = _ref.data;
+
+			_this4.insertChild({ data: data }, index);
+		});
+
+		this.updateLeafState();
+	};
+
+	Node.prototype.loadData = function loadData(callback) {
+		var _this5 = this;
+
+		var defaultProps = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+
+		if (this.store.lazy === true && this.store.load && !this.loaded && (!this.loading || Object.keys(defaultProps).length)) {
+			this.loading = true;
+
+			var resolve = function resolve(children) {
+				_this5.childNodes = [];
+
+				_this5.doCreateChildren(children, defaultProps);
+				_this5.loaded = true;
+				_this5.loading = false;
+				_this5.updateLeafState();
+				if (callback) {
+					callback.call(_this5, children);
+				}
+			};
+
+			this.store.load(this, resolve);
+		} else {
+			if (callback) {
+				callback.call(this);
+			}
+		}
+	};
+
+	_createClass(Node, [{
+		key: 'label',
+		get: function get() {
+			return getPropertyFromData(this, 'label');
+		}
+	}, {
+		key: 'key',
+		get: function get() {
+			var nodeKey = this.store.key;
+			if (this.data) return this.data[nodeKey];
+			return null;
+		}
+	}, {
+		key: 'disabled',
+		get: function get() {
+			return getPropertyFromData(this, 'disabled');
+		}
+	}, {
+		key: 'nextSibling',
+		get: function get() {
+			var parent = this.parent;
+			if (parent) {
+				var index = parent.childNodes.indexOf(this);
+				if (index > -1) {
+					return parent.childNodes[index + 1];
+				}
+			}
+			return null;
+		}
+	}, {
+		key: 'previousSibling',
+		get: function get() {
+			var parent = this.parent;
+			if (parent) {
+				var index = parent.childNodes.indexOf(this);
+				if (index > -1) {
+					return index > 0 ? parent.childNodes[index - 1] : null;
+				}
+			}
+			return null;
+		}
+	}]);
+
+	return Node;
+}();
+
+/* harmony default export */ var model_node = (node_Node);
+// CONCATENATED MODULE: ./packages/tree/src/model/tree-store.js
+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; };
+
+function tree_store_classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+
+
+
+var tree_store_TreeStore = function () {
+	function TreeStore(options) {
+		var _this = this;
+
+		tree_store_classCallCheck(this, TreeStore);
+
+		this.currentNode = null;
+		this.currentNodeKey = null;
+
+		for (var option in options) {
+			if (options.hasOwnProperty(option)) {
+				this[option] = options[option];
+			}
+		}
+
+		this.nodesMap = {};
+
+		this.root = new model_node({
+			data: this.data,
+			store: this
+		});
+
+		if (this.lazy && this.load) {
+			var loadFn = this.load;
+			loadFn(this.root, function (data) {
+				_this.root.doCreateChildren(data);
+				_this._initDefaultCheckedNodes();
+			});
+		} else {
+			this._initDefaultCheckedNodes();
+		}
+	}
+
+	TreeStore.prototype.filter = function filter(value) {
+		var filterNodeMethod = this.filterNodeMethod;
+		var lazy = this.lazy;
+		var traverse = function traverse(node) {
+			var childNodes = node.root ? node.root.childNodes : node.childNodes;
+
+			childNodes.forEach(function (child) {
+				child.visible = filterNodeMethod.call(child, value, child.data, child);
+
+				traverse(child);
+			});
+
+			if (!node.visible && childNodes.length) {
+				var allHidden = true;
+				allHidden = !childNodes.some(function (child) {
+					return child.visible;
+				});
+
+				if (node.root) {
+					node.root.visible = allHidden === false;
+				} else {
+					node.visible = allHidden === false;
+				}
+			}
+			if (!value) return;
+
+			if (node.visible && !node.isLeaf && !lazy) node.expand();
+		};
+
+		traverse(this);
+	};
+
+	TreeStore.prototype.setData = function setData(newVal) {
+		var instanceChanged = newVal !== this.root.data;
+		if (instanceChanged) {
+			this.root.setData(newVal);
+			this._initDefaultCheckedNodes();
+		} else {
+			this.root.updateChildren();
+		}
+	};
+
+	TreeStore.prototype.getNode = function getNode(data) {
+		if (data instanceof model_node) return data;
+		var key = (typeof data === 'undefined' ? 'undefined' : _typeof(data)) !== 'object' ? data : util_getNodeKey(this.key, data);
+		return this.nodesMap[key] || null;
+	};
+
+	TreeStore.prototype.insertBefore = function insertBefore(data, refData) {
+		var refNode = this.getNode(refData);
+		refNode.parent.insertBefore({ data: data }, refNode);
+	};
+
+	TreeStore.prototype.insertAfter = function insertAfter(data, refData) {
+		var refNode = this.getNode(refData);
+		refNode.parent.insertAfter({ data: data }, refNode);
+	};
+
+	TreeStore.prototype.remove = function remove(data) {
+		var node = this.getNode(data);
+
+		if (node && node.parent) {
+			if (node === this.currentNode) {
+				this.currentNode = null;
+			}
+			node.parent.removeChild(node);
+		}
+	};
+
+	TreeStore.prototype.append = function append(data, parentData) {
+		var parentNode = parentData ? this.getNode(parentData) : this.root;
+
+		if (parentNode) {
+			parentNode.insertChild({ data: data });
+		}
+	};
+
+	TreeStore.prototype._initDefaultCheckedNodes = function _initDefaultCheckedNodes() {
+		var _this2 = this;
+
+		var defaultCheckedKeys = this.defaultCheckedKeys || [];
+		var nodesMap = this.nodesMap;
+
+		defaultCheckedKeys.forEach(function (checkedKey) {
+			var node = nodesMap[checkedKey];
+
+			if (node) {
+				node.setChecked(true, !_this2.checkStrictly);
+			}
+		});
+	};
+
+	TreeStore.prototype._initDefaultCheckedNode = function _initDefaultCheckedNode(node) {
+		var defaultCheckedKeys = this.defaultCheckedKeys || [];
+
+		if (defaultCheckedKeys.indexOf(node.key) !== -1) {
+			node.setChecked(true, !this.checkStrictly);
+		}
+	};
+
+	TreeStore.prototype.setDefaultCheckedKey = function setDefaultCheckedKey(newVal) {
+		if (newVal !== this.defaultCheckedKeys) {
+			this.defaultCheckedKeys = newVal;
+			this._initDefaultCheckedNodes();
+		}
+	};
+
+	TreeStore.prototype.registerNode = function registerNode(node) {
+		var key = this.key;
+		if (!key || !node || !node.data) return;
+
+		var nodeKey = node.key;
+		if (nodeKey !== undefined) this.nodesMap[node.key] = node;
+	};
+
+	TreeStore.prototype.deregisterNode = function deregisterNode(node) {
+		var _this3 = this;
+
+		var key = this.key;
+		if (!key || !node || !node.data) return;
+
+		node.childNodes.forEach(function (child) {
+			_this3.deregisterNode(child);
+		});
+
+		delete this.nodesMap[node.key];
+	};
+
+	TreeStore.prototype.getCheckedNodes = function getCheckedNodes() {
+		var leafOnly = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+		var includeHalfChecked = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+
+		var checkedNodes = [];
+		var traverse = function traverse(node) {
+			var childNodes = node.root ? node.root.childNodes : node.childNodes;
+
+			childNodes.forEach(function (child) {
+				if ((child.checked || includeHalfChecked && child.indeterminate) && (!leafOnly || leafOnly && child.isLeaf)) {
+					checkedNodes.push(child.data);
+				}
+
+				traverse(child);
+			});
+		};
+
+		traverse(this);
+
+		return checkedNodes;
+	};
+
+	TreeStore.prototype.getCheckedKeys = function getCheckedKeys() {
+		var _this4 = this;
+
+		var leafOnly = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+
+		return this.getCheckedNodes(leafOnly).map(function (data) {
+			return (data || {})[_this4.key];
+		});
+	};
+
+	TreeStore.prototype.getHalfCheckedNodes = function getHalfCheckedNodes() {
+		var nodes = [];
+		var traverse = function traverse(node) {
+			var childNodes = node.root ? node.root.childNodes : node.childNodes;
+
+			childNodes.forEach(function (child) {
+				if (child.indeterminate) {
+					nodes.push(child.data);
+				}
+
+				traverse(child);
+			});
+		};
+
+		traverse(this);
+
+		return nodes;
+	};
+
+	TreeStore.prototype.getHalfCheckedKeys = function getHalfCheckedKeys() {
+		var _this5 = this;
+
+		return this.getHalfCheckedNodes().map(function (data) {
+			return (data || {})[_this5.key];
+		});
+	};
+
+	TreeStore.prototype._getAllNodes = function _getAllNodes() {
+		var allNodes = [];
+		var nodesMap = this.nodesMap;
+		for (var nodeKey in nodesMap) {
+			if (nodesMap.hasOwnProperty(nodeKey)) {
+				allNodes.push(nodesMap[nodeKey]);
+			}
+		}
+
+		return allNodes;
+	};
+
+	TreeStore.prototype.updateChildren = function updateChildren(key, data) {
+		var node = this.nodesMap[key];
+		if (!node) return;
+		var childNodes = node.childNodes;
+		for (var i = childNodes.length - 1; i >= 0; i--) {
+			var child = childNodes[i];
+			this.remove(child.data);
+		}
+		for (var _i = 0, j = data.length; _i < j; _i++) {
+			var _child = data[_i];
+			this.append(_child, node.data);
+		}
+	};
+
+	TreeStore.prototype._setCheckedKeys = function _setCheckedKeys(key) {
+		var leafOnly = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+		var checkedKeys = arguments[2];
+
+		var allNodes = this._getAllNodes().sort(function (a, b) {
+			return b.level - a.level;
+		});
+		var cache = Object.create(null);
+		var keys = Object.keys(checkedKeys);
+		allNodes.forEach(function (node) {
+			return node.setChecked(false, false);
+		});
+		for (var i = 0, j = allNodes.length; i < j; i++) {
+			var node = allNodes[i];
+			var nodeKey = node.data[key].toString();
+			var checked = keys.indexOf(nodeKey) > -1;
+			if (!checked) {
+				if (node.checked && !cache[nodeKey]) {
+					node.setChecked(false, false);
+				}
+				continue;
+			}
+
+			var parent = node.parent;
+			while (parent && parent.level > 0) {
+				cache[parent.data[key]] = true;
+				parent = parent.parent;
+			}
+
+			if (node.isLeaf || this.checkStrictly) {
+				node.setChecked(true, false);
+				continue;
+			}
+			node.setChecked(true, true);
+
+			if (leafOnly) {
+				(function () {
+					node.setChecked(false, false);
+					var traverse = function traverse(node) {
+						var childNodes = node.childNodes;
+						childNodes.forEach(function (child) {
+							if (!child.isLeaf) {
+								child.setChecked(false, false);
+							}
+							traverse(child);
+						});
+					};
+					traverse(node);
+				})();
+			}
+		}
+	};
+
+	TreeStore.prototype.setCheckedNodes = function setCheckedNodes(array) {
+		var leafOnly = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+
+		var key = this.key;
+		var checkedKeys = {};
+		array.forEach(function (item) {
+			checkedKeys[(item || {})[key]] = true;
+		});
+
+		this._setCheckedKeys(key, leafOnly, checkedKeys);
+	};
+
+	TreeStore.prototype.setCheckedKeys = function setCheckedKeys(keys) {
+		var leafOnly = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+
+		this.defaultCheckedKeys = keys;
+		var key = this.key;
+		var checkedKeys = {};
+		keys.forEach(function (key) {
+			checkedKeys[key] = true;
+		});
+
+		this._setCheckedKeys(key, leafOnly, checkedKeys);
+	};
+
+	TreeStore.prototype.setDefaultExpandedKeys = function setDefaultExpandedKeys(keys) {
+		var _this6 = this;
+
+		keys = keys || [];
+		this.defaultExpandedKeys = keys;
+
+		keys.forEach(function (key) {
+			var node = _this6.getNode(key);
+			if (node) node.expand(null, _this6.autoExpandParent);
+		});
+	};
+
+	TreeStore.prototype.setChecked = function setChecked(data, checked, deep) {
+		var node = this.getNode(data);
+
+		if (node) {
+			node.setChecked(!!checked, deep);
+		}
+	};
+
+	TreeStore.prototype.getCurrentNode = function getCurrentNode() {
+		return this.currentNode;
+	};
+
+	TreeStore.prototype.setCurrentNode = function setCurrentNode(currentNode) {
+		var prevCurrentNode = this.currentNode;
+		if (prevCurrentNode) {
+			prevCurrentNode.isCurrent = false;
+		}
+		this.currentNode = currentNode;
+		this.currentNode.isCurrent = true;
+	};
+
+	TreeStore.prototype.setUserCurrentNode = function setUserCurrentNode(node) {
+		var key = node[this.key];
+		var currNode = this.nodesMap[key];
+		this.setCurrentNode(currNode);
+	};
+
+	TreeStore.prototype.setCurrentNodeKey = function setCurrentNodeKey(key) {
+		if (key === null || key === undefined) {
+			this.currentNode && (this.currentNode.isCurrent = false);
+			this.currentNode = null;
+			return;
+		}
+		var node = this.getNode(key);
+		if (node) {
+			this.setCurrentNode(node);
+		}
+	};
+
+	return TreeStore;
+}();
+
+/* harmony default export */ var tree_store = (tree_store_TreeStore);
+;
+// CONCATENATED MODULE: ./node_modules/vue-loader/lib/loaders/templateLoader.js??vue-loader-options!./node_modules/vue-loader/lib??vue-loader-options!./packages/tree/src/tree-node.vue?vue&type=template&id=769053c6
+var tree_nodevue_type_template_id_769053c6_render = function () {
+  var this$1 = this
+  var _vm = this
+  var _h = _vm.$createElement
+  var _c = _vm._self._c || _h
+  return _c(
+    "div",
+    {
+      directives: [
+        {
+          name: "show",
+          rawName: "v-show",
+          value: _vm.node.visible,
+          expression: "node.visible",
+        },
+      ],
+      ref: "node",
+      staticClass: "el-tree-node",
+      class: {
+        "is-expanded": _vm.expanded,
+        "is-current": _vm.node.isCurrent,
+        "is-hidden": !_vm.node.visible,
+        "is-focusable": !_vm.node.disabled,
+        "is-checked": !_vm.node.disabled && _vm.node.checked,
+      },
+      attrs: {
+        role: "treeitem",
+        tabindex: "-1",
+        "aria-expanded": _vm.expanded,
+        "aria-disabled": _vm.node.disabled,
+        "aria-checked": _vm.node.checked,
+        draggable: _vm.tree.draggable,
+      },
+      on: {
+        click: function ($event) {
+          $event.stopPropagation()
+          return _vm.handleClick($event)
+        },
+        contextmenu: function ($event) {
+          return this$1.handleContextMenu($event)
+        },
+        dragstart: function ($event) {
+          $event.stopPropagation()
+          return _vm.handleDragStart($event)
+        },
+        dragover: function ($event) {
+          $event.stopPropagation()
+          return _vm.handleDragOver($event)
+        },
+        dragend: function ($event) {
+          $event.stopPropagation()
+          return _vm.handleDragEnd($event)
+        },
+        drop: function ($event) {
+          $event.stopPropagation()
+          return _vm.handleDrop($event)
+        },
+      },
+    },
+    [
+      _c(
+        "div",
+        {
+          staticClass: "el-tree-node__content",
+          style: {
+            "padding-left": (_vm.node.level - 1) * _vm.tree.indent + "px",
+          },
+        },
+        [
+          _c("span", {
+            class: [
+              {
+                "is-leaf": _vm.node.isLeaf,
+                expanded: !_vm.node.isLeaf && _vm.expanded,
+              },
+              "el-tree-node__expand-icon",
+              _vm.tree.iconClass ? _vm.tree.iconClass : "el-icon-caret-right",
+            ],
+            on: {
+              click: function ($event) {
+                $event.stopPropagation()
+                return _vm.handleExpandIconClick($event)
+              },
+            },
+          }),
+          _vm.showCheckbox
+            ? _c("el-checkbox", {
+                attrs: {
+                  indeterminate: _vm.node.indeterminate,
+                  disabled: !!_vm.node.disabled,
+                },
+                on: { change: _vm.handleCheckChange },
+                nativeOn: {
+                  click: function ($event) {
+                    $event.stopPropagation()
+                  },
+                },
+                model: {
+                  value: _vm.node.checked,
+                  callback: function ($$v) {
+                    _vm.$set(_vm.node, "checked", $$v)
+                  },
+                  expression: "node.checked",
+                },
+              })
+            : _vm._e(),
+          _vm.node.loading
+            ? _c("span", {
+                staticClass: "el-tree-node__loading-icon el-icon-loading",
+              })
+            : _vm._e(),
+          _c("node-content", { attrs: { node: _vm.node } }),
+        ],
+        1
+      ),
+      _c("el-collapse-transition", [
+        !_vm.renderAfterExpand || _vm.childNodeRendered
+          ? _c(
+              "div",
+              {
+                directives: [
+                  {
+                    name: "show",
+                    rawName: "v-show",
+                    value: _vm.expanded,
+                    expression: "expanded",
+                  },
+                ],
+                staticClass: "el-tree-node__children",
+                attrs: { role: "group", "aria-expanded": _vm.expanded },
+              },
+              _vm._l(_vm.node.childNodes, function (child) {
+                return _c("el-tree-node", {
+                  key: _vm.getNodeKey(child),
+                  attrs: {
+                    "render-content": _vm.renderContent,
+                    "render-after-expand": _vm.renderAfterExpand,
+                    "show-checkbox": _vm.showCheckbox,
+                    node: child,
+                  },
+                  on: { "node-expand": _vm.handleChildNodeExpand },
+                })
+              }),
+              1
+            )
+          : _vm._e(),
+      ]),
+    ],
+    1
+  )
+}
+var tree_nodevue_type_template_id_769053c6_staticRenderFns = []
+tree_nodevue_type_template_id_769053c6_render._withStripped = true
+
+
+// CONCATENATED MODULE: ./packages/tree/src/tree-node.vue?vue&type=template&id=769053c6
+
+// EXTERNAL MODULE: external "element-ui/lib/transitions/collapse-transition"
+var collapse_transition_ = __webpack_require__(27);
+var collapse_transition_default = /*#__PURE__*/__webpack_require__.n(collapse_transition_);
+
+// EXTERNAL MODULE: ./packages/checkbox/index.js + 5 modules
+var packages_checkbox = __webpack_require__(16);
+
+// 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/lib!./node_modules/vue-loader/lib??vue-loader-options!./packages/tree/src/tree-node.vue?vue&type=script&lang=js
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+
+
+
+
+
+
+/* harmony default export */ var tree_nodevue_type_script_lang_js = ({
+	name: 'ElTreeNode',
+
+	componentName: 'ElTreeNode',
+
+	mixins: [emitter_default.a],
+
+	props: {
+		node: {
+			default: function _default() {
+				return {};
+			}
+		},
+		props: {},
+		renderContent: Function,
+		renderAfterExpand: {
+			type: Boolean,
+			default: true
+		},
+		showCheckbox: {
+			type: Boolean,
+			default: false
+		}
+	},
+
+	components: {
+		ElCollapseTransition: collapse_transition_default.a,
+		ElCheckbox: packages_checkbox["default"],
+		NodeContent: {
+			props: {
+				node: {
+					required: true
+				}
+			},
+			render: function render(h) {
+				var parent = this.$parent;
+				var tree = parent.tree;
+				var node = this.node;
+				var data = node.data,
+				    store = node.store;
+
+				return parent.renderContent ? parent.renderContent.call(parent._renderProxy, h, { _self: tree.$vnode.context, node: node, data: data, store: store }) : tree.$scopedSlots.default ? tree.$scopedSlots.default({ node: node, data: data }) : h(
+					'span',
+					{ 'class': 'el-tree-node__label' },
+					[node.label]
+				);
+			}
+		}
+	},
+
+	data: function data() {
+		return {
+			tree: null,
+			expanded: false,
+			childNodeRendered: false,
+			oldChecked: null,
+			oldIndeterminate: null
+		};
+	},
+
+
+	watch: {
+		'node.indeterminate': function nodeIndeterminate(val) {
+			this.handleSelectChange(this.node.checked, val);
+		},
+		'node.checked': function nodeChecked(val) {
+			this.handleSelectChange(val, this.node.indeterminate);
+		},
+		'node.expanded': function nodeExpanded(val) {
+			var _this = this;
+
+			this.$nextTick(function () {
+				return _this.expanded = val;
+			});
+			if (val) {
+				this.childNodeRendered = true;
+			}
+		}
+	},
+
+	methods: {
+		getNodeKey: function getNodeKey(node) {
+			return util_getNodeKey(this.tree.nodeKey, node.data);
+		},
+		handleSelectChange: function handleSelectChange(checked, indeterminate) {
+			if (this.oldChecked !== checked && this.oldIndeterminate !== indeterminate) {
+				this.tree.$emit('check-change', this.node.data, checked, indeterminate);
+			}
+			this.oldChecked = checked;
+			this.indeterminate = indeterminate;
+		},
+		handleClick: function handleClick() {
+			var store = this.tree.store;
+			store.setCurrentNode(this.node);
+			this.tree.$emit('current-change', store.currentNode ? store.currentNode.data : null, store.currentNode);
+			this.tree.currentNode = this;
+			if (this.tree.expandOnClickNode) {
+				this.handleExpandIconClick();
+			}
+			if (this.tree.checkOnClickNode && !this.node.disabled) {
+				this.handleCheckChange(null, {
+					target: { checked: !this.node.checked }
+				});
+			}
+			this.tree.$emit('node-click', this.node.data, this.node, this);
+		},
+		handleContextMenu: function handleContextMenu(event) {
+			if (this.tree._events['node-contextmenu'] && this.tree._events['node-contextmenu'].length > 0) {
+				event.stopPropagation();
+				event.preventDefault();
+			}
+			this.tree.$emit('node-contextmenu', event, this.node.data, this.node, this);
+		},
+		handleExpandIconClick: function handleExpandIconClick() {
+			if (this.node.isLeaf) return;
+			if (this.expanded) {
+				this.tree.$emit('node-collapse', this.node.data, this.node, this);
+				this.node.collapse();
+			} else {
+				this.node.expand();
+				this.$emit('node-expand', this.node.data, this.node, this);
+			}
+		},
+		handleCheckChange: function handleCheckChange(value, ev) {
+			var _this2 = this;
+
+			this.node.setChecked(ev.target.checked, !this.tree.checkStrictly);
+			this.$nextTick(function () {
+				var store = _this2.tree.store;
+				_this2.tree.$emit('check', _this2.node.data, {
+					checkedNodes: store.getCheckedNodes(),
+					checkedKeys: store.getCheckedKeys(),
+					halfCheckedNodes: store.getHalfCheckedNodes(),
+					halfCheckedKeys: store.getHalfCheckedKeys()
+				});
+			});
+		},
+		handleChildNodeExpand: function handleChildNodeExpand(nodeData, node, instance) {
+			this.broadcast('ElTreeNode', 'tree-node-expand', node);
+			this.tree.$emit('node-expand', nodeData, node, instance);
+		},
+		handleDragStart: function handleDragStart(event) {
+			if (!this.tree.draggable) return;
+			this.tree.$emit('tree-node-drag-start', event, this);
+		},
+		handleDragOver: function handleDragOver(event) {
+			if (!this.tree.draggable) return;
+			this.tree.$emit('tree-node-drag-over', event, this);
+			event.preventDefault();
+		},
+		handleDrop: function handleDrop(event) {
+			event.preventDefault();
+		},
+		handleDragEnd: function handleDragEnd(event) {
+			if (!this.tree.draggable) return;
+			this.tree.$emit('tree-node-drag-end', event, this);
+		}
+	},
+
+	created: function created() {
+		var _this3 = this;
+
+		var parent = this.$parent;
+
+		if (parent.isTree) {
+			this.tree = parent;
+		} else {
+			this.tree = parent.tree;
+		}
+
+		var tree = this.tree;
+		if (!tree) {
+			console.warn('Can not find node\'s tree.');
+		}
+
+		var props = tree.props || {};
+		var childrenKey = props['children'] || 'children';
+
+		this.$watch('node.data.' + childrenKey, function () {
+			_this3.node.updateChildren();
+		});
+
+		if (this.node.expanded) {
+			this.expanded = true;
+			this.childNodeRendered = true;
+		}
+
+		if (this.tree.accordion) {
+			this.$on('tree-node-expand', function (node) {
+				if (_this3.node !== node) {
+					_this3.node.collapse();
+				}
+			});
+		}
+	}
+});
+// CONCATENATED MODULE: ./packages/tree/src/tree-node.vue?vue&type=script&lang=js
+ /* harmony default export */ var src_tree_nodevue_type_script_lang_js = (tree_nodevue_type_script_lang_js); 
+// EXTERNAL MODULE: ./node_modules/vue-loader/lib/runtime/componentNormalizer.js
+var componentNormalizer = __webpack_require__(0);
+
+// CONCATENATED MODULE: ./packages/tree/src/tree-node.vue
+
+
+
+
+
+/* normalize component */
+
+var component = Object(componentNormalizer["a" /* default */])(
+  src_tree_nodevue_type_script_lang_js,
+  tree_nodevue_type_template_id_769053c6_render,
+  tree_nodevue_type_template_id_769053c6_staticRenderFns,
+  false,
+  null,
+  null,
+  null
+  
+)
+
+/* harmony default export */ var tree_node = (component.exports);
+// EXTERNAL MODULE: external "element-ui/lib/locale"
+var locale_ = __webpack_require__(22);
+
+// EXTERNAL MODULE: external "element-ui/lib/utils/dom"
+var dom_ = __webpack_require__(1);
+
+// CONCATENATED MODULE: ./node_modules/babel-loader/lib!./node_modules/vue-loader/lib??vue-loader-options!./packages/tree/src/tree.vue?vue&type=script&lang=js
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+//
+
+
+
+
+
+
+
+
+/* harmony default export */ var treevue_type_script_lang_js = ({
+	name: 'ElTree',
+
+	mixins: [emitter_default.a],
+
+	components: {
+		ElTreeNode: tree_node
+	},
+
+	data: function data() {
+		return {
+			store: null,
+			root: null,
+			currentNode: null,
+			treeItems: null,
+			checkboxItems: [],
+			dragState: {
+				showDropIndicator: false,
+				draggingNode: null,
+				dropNode: null,
+				allowDrop: true
+			}
+		};
+	},
+
+
+	props: {
+		data: {
+			type: Array
+		},
+		emptyText: {
+			type: String,
+			default: function _default() {
+				return Object(locale_["t"])('el.tree.emptyText');
+			}
+		},
+		renderAfterExpand: {
+			type: Boolean,
+			default: true
+		},
+		nodeKey: String,
+		checkStrictly: Boolean,
+		defaultExpandAll: Boolean,
+		expandOnClickNode: {
+			type: Boolean,
+			default: true
+		},
+		checkOnClickNode: Boolean,
+		checkDescendants: {
+			type: Boolean,
+			default: false
+		},
+		autoExpandParent: {
+			type: Boolean,
+			default: true
+		},
+		defaultCheckedKeys: Array,
+		defaultExpandedKeys: Array,
+		currentNodeKey: [String, Number],
+		renderContent: Function,
+		showCheckbox: {
+			type: Boolean,
+			default: false
+		},
+		draggable: {
+			type: Boolean,
+			default: false
+		},
+		allowDrag: Function,
+		allowDrop: Function,
+		props: {
+			default: function _default() {
+				return {
+					children: 'children',
+					label: 'label',
+					disabled: 'disabled'
+				};
+			}
+		},
+		lazy: {
+			type: Boolean,
+			default: false
+		},
+		highlightCurrent: Boolean,
+		load: Function,
+		filterNodeMethod: Function,
+		accordion: Boolean,
+		indent: {
+			type: Number,
+			default: 18
+		},
+		iconClass: String
+	},
+
+	computed: {
+		children: {
+			set: function set(value) {
+				this.data = value;
+			},
+			get: function get() {
+				return this.data;
+			}
+		},
+
+		treeItemArray: function treeItemArray() {
+			return Array.prototype.slice.call(this.treeItems);
+		},
+		isEmpty: function isEmpty() {
+			var childNodes = this.root.childNodes;
+
+			return !childNodes || childNodes.length === 0 || childNodes.every(function (_ref) {
+				var visible = _ref.visible;
+				return !visible;
+			});
+		}
+	},
+
+	watch: {
+		defaultCheckedKeys: function defaultCheckedKeys(newVal) {
+			this.store.setDefaultCheckedKey(newVal);
+		},
+		defaultExpandedKeys: function defaultExpandedKeys(newVal) {
+			this.store.defaultExpandedKeys = newVal;
+			this.store.setDefaultExpandedKeys(newVal);
+		},
+		data: function data(newVal) {
+			this.store.setData(newVal);
+		},
+		checkboxItems: function checkboxItems(val) {
+			Array.prototype.forEach.call(val, function (checkbox) {
+				checkbox.setAttribute('tabindex', -1);
+			});
+		},
+		checkStrictly: function checkStrictly(newVal) {
+			this.store.checkStrictly = newVal;
+		}
+	},
+
+	methods: {
+		filter: function filter(value) {
+			if (!this.filterNodeMethod) throw new Error('[Tree] filterNodeMethod is required when filter');
+			this.store.filter(value);
+		},
+		getNodeKey: function getNodeKey(node) {
+			return util_getNodeKey(this.nodeKey, node.data);
+		},
+		getNodePath: function getNodePath(data) {
+			if (!this.nodeKey) throw new Error('[Tree] nodeKey is required in getNodePath');
+			var node = this.store.getNode(data);
+			if (!node) return [];
+			var path = [node.data];
+			var parent = node.parent;
+			while (parent && parent !== this.root) {
+				path.push(parent.data);
+				parent = parent.parent;
+			}
+			return path.reverse();
+		},
+		getCheckedNodes: function getCheckedNodes(leafOnly, includeHalfChecked) {
+			return this.store.getCheckedNodes(leafOnly, includeHalfChecked);
+		},
+		getCheckedKeys: function getCheckedKeys(leafOnly) {
+			return this.store.getCheckedKeys(leafOnly);
+		},
+		getCurrentNode: function getCurrentNode() {
+			var currentNode = this.store.getCurrentNode();
+			return currentNode ? currentNode.data : null;
+		},
+		getCurrentKey: function getCurrentKey() {
+			if (!this.nodeKey) throw new Error('[Tree] nodeKey is required in getCurrentKey');
+			var currentNode = this.getCurrentNode();
+			return currentNode ? currentNode[this.nodeKey] : null;
+		},
+		setCheckedNodes: function setCheckedNodes(nodes, leafOnly) {
+			if (!this.nodeKey) throw new Error('[Tree] nodeKey is required in setCheckedNodes');
+			this.store.setCheckedNodes(nodes, leafOnly);
+		},
+		setCheckedKeys: function setCheckedKeys(keys, leafOnly) {
+			if (!this.nodeKey) throw new Error('[Tree] nodeKey is required in setCheckedKeys');
+			this.store.setCheckedKeys(keys, leafOnly);
+		},
+		setChecked: function setChecked(data, checked, deep) {
+			this.store.setChecked(data, checked, deep);
+		},
+		getHalfCheckedNodes: function getHalfCheckedNodes() {
+			return this.store.getHalfCheckedNodes();
+		},
+		getHalfCheckedKeys: function getHalfCheckedKeys() {
+			return this.store.getHalfCheckedKeys();
+		},
+		setCurrentNode: function setCurrentNode(node) {
+			if (!this.nodeKey) throw new Error('[Tree] nodeKey is required in setCurrentNode');
+			this.store.setUserCurrentNode(node);
+		},
+		setCurrentKey: function setCurrentKey(key) {
+			if (!this.nodeKey) throw new Error('[Tree] nodeKey is required in setCurrentKey');
+			this.store.setCurrentNodeKey(key);
+		},
+		getNode: function getNode(data) {
+			return this.store.getNode(data);
+		},
+		remove: function remove(data) {
+			this.store.remove(data);
+		},
+		append: function append(data, parentNode) {
+			this.store.append(data, parentNode);
+		},
+		insertBefore: function insertBefore(data, refNode) {
+			this.store.insertBefore(data, refNode);
+		},
+		insertAfter: function insertAfter(data, refNode) {
+			this.store.insertAfter(data, refNode);
+		},
+		handleNodeExpand: function handleNodeExpand(nodeData, node, instance) {
+			this.broadcast('ElTreeNode', 'tree-node-expand', node);
+			this.$emit('node-expand', nodeData, node, instance);
+		},
+		updateKeyChildren: function updateKeyChildren(key, data) {
+			if (!this.nodeKey) throw new Error('[Tree] nodeKey is required in updateKeyChild');
+			this.store.updateChildren(key, data);
+		},
+		initTabIndex: function initTabIndex() {
+			this.treeItems = this.$el.querySelectorAll('.is-focusable[role=treeitem]');
+			this.checkboxItems = this.$el.querySelectorAll('input[type=checkbox]');
+			var checkedItem = this.$el.querySelectorAll('.is-checked[role=treeitem]');
+			if (checkedItem.length) {
+				checkedItem[0].setAttribute('tabindex', 0);
+				return;
+			}
+			this.treeItems[0] && this.treeItems[0].setAttribute('tabindex', 0);
+		},
+		handleKeydown: function handleKeydown(ev) {
+			var currentItem = ev.target;
+			if (currentItem.className.indexOf('el-tree-node') === -1) return;
+			var keyCode = ev.keyCode;
+			this.treeItems = this.$el.querySelectorAll('.is-focusable[role=treeitem]');
+			var currentIndex = this.treeItemArray.indexOf(currentItem);
+			var nextIndex = void 0;
+			if ([38, 40].indexOf(keyCode) > -1) {
+				// up、down
+				ev.preventDefault();
+				if (keyCode === 38) {
+					// up
+					nextIndex = currentIndex !== 0 ? currentIndex - 1 : 0;
+				} else {
+					nextIndex = currentIndex < this.treeItemArray.length - 1 ? currentIndex + 1 : 0;
+				}
+				this.treeItemArray[nextIndex].focus(); // 选中
+			}
+			if ([37, 39].indexOf(keyCode) > -1) {
+				// left、right 展开
+				ev.preventDefault();
+				currentItem.click(); // 选中
+			}
+			var hasInput = currentItem.querySelector('[type="checkbox"]');
+			if ([13, 32].indexOf(keyCode) > -1 && hasInput) {
+				// space enter选中checkbox
+				ev.preventDefault();
+				hasInput.click();
+			}
+		}
+	},
+
+	created: function created() {
+		var _this = this;
+
+		this.isTree = true;
+
+		this.store = new tree_store({
+			key: this.nodeKey,
+			data: this.data,
+			lazy: this.lazy,
+			props: this.props,
+			load: this.load,
+			currentNodeKey: this.currentNodeKey,
+			checkStrictly: this.checkStrictly,
+			checkDescendants: this.checkDescendants,
+			defaultCheckedKeys: this.defaultCheckedKeys,
+			defaultExpandedKeys: this.defaultExpandedKeys,
+			autoExpandParent: this.autoExpandParent,
+			defaultExpandAll: this.defaultExpandAll,
+			filterNodeMethod: this.filterNodeMethod
+		});
+
+		this.root = this.store.root;
+
+		var dragState = this.dragState;
+		this.$on('tree-node-drag-start', function (event, treeNode) {
+			if (typeof _this.allowDrag === 'function' && !_this.allowDrag(treeNode.node)) {
+				event.preventDefault();
+				return false;
+			}
+			event.dataTransfer.effectAllowed = 'move';
+
+			// wrap in try catch to address IE's error when first param is 'text/plain'
+			try {
+				// setData is required for draggable to work in FireFox
+				// the content has to be '' so dragging a node out of the tree won't open a new tab in FireFox
+				event.dataTransfer.setData('text/plain', '');
+			} catch (e) {}
+			dragState.draggingNode = treeNode;
+			_this.$emit('node-drag-start', treeNode.node, event);
+		});
+
+		this.$on('tree-node-drag-over', function (event, treeNode) {
+			var dropNode = findNearestComponent(event.target, 'ElTreeNode');
+			var oldDropNode = dragState.dropNode;
+			if (oldDropNode && oldDropNode !== dropNode) {
+				Object(dom_["removeClass"])(oldDropNode.$el, 'is-drop-inner');
+			}
+			var draggingNode = dragState.draggingNode;
+			if (!draggingNode || !dropNode) return;
+
+			var dropPrev = true;
+			var dropInner = true;
+			var dropNext = true;
+			var userAllowDropInner = true;
+			if (typeof _this.allowDrop === 'function') {
+				dropPrev = _this.allowDrop(draggingNode.node, dropNode.node, 'prev');
+				userAllowDropInner = dropInner = _this.allowDrop(draggingNode.node, dropNode.node, 'inner');
+				dropNext = _this.allowDrop(draggingNode.node, dropNode.node, 'next');
+			}
+			event.dataTransfer.dropEffect = dropInner ? 'move' : 'none';
+			if ((dropPrev || dropInner || dropNext) && oldDropNode !== dropNode) {
+				if (oldDropNode) {
+					_this.$emit('node-drag-leave', draggingNode.node, oldDropNode.node, event);
+				}
+				_this.$emit('node-drag-enter', draggingNode.node, dropNode.node, event);
+			}
+
+			if (dropPrev || dropInner || dropNext) {
+				dragState.dropNode = dropNode;
+			}
+
+			if (dropNode.node.nextSibling === draggingNode.node) {
+				dropNext = false;
+			}
+			if (dropNode.node.previousSibling === draggingNode.node) {
+				dropPrev = false;
+			}
+			if (dropNode.node.contains(draggingNode.node, false)) {
+				dropInner = false;
+			}
+			if (draggingNode.node === dropNode.node || draggingNode.node.contains(dropNode.node)) {
+				dropPrev = false;
+				dropInner = false;
+				dropNext = false;
+			}
+
+			var targetPosition = dropNode.$el.getBoundingClientRect();
+			var treePosition = _this.$el.getBoundingClientRect();
+
+			var dropType = void 0;
+			var prevPercent = dropPrev ? dropInner ? 0.25 : dropNext ? 0.45 : 1 : -1;
+			var nextPercent = dropNext ? dropInner ? 0.75 : dropPrev ? 0.55 : 0 : 1;
+
+			var indicatorTop = -9999;
+			var distance = event.clientY - targetPosition.top;
+			if (distance < targetPosition.height * prevPercent) {
+				dropType = 'before';
+			} else if (distance > targetPosition.height * nextPercent) {
+				dropType = 'after';
+			} else if (dropInner) {
+				dropType = 'inner';
+			} else {
+				dropType = 'none';
+			}
+
+			var iconPosition = dropNode.$el.querySelector('.el-tree-node__expand-icon').getBoundingClientRect();
+			var dropIndicator = _this.$refs.dropIndicator;
+			if (dropType === 'before') {
+				indicatorTop = iconPosition.top - treePosition.top;
+			} else if (dropType === 'after') {
+				indicatorTop = iconPosition.bottom - treePosition.top;
+			}
+			dropIndicator.style.top = indicatorTop + 'px';
+			dropIndicator.style.left = iconPosition.right - treePosition.left + 'px';
+
+			if (dropType === 'inner') {
+				Object(dom_["addClass"])(dropNode.$el, 'is-drop-inner');
+			} else {
+				Object(dom_["removeClass"])(dropNode.$el, 'is-drop-inner');
+			}
+
+			dragState.showDropIndicator = dropType === 'before' || dropType === 'after';
+			dragState.allowDrop = dragState.showDropIndicator || userAllowDropInner;
+			dragState.dropType = dropType;
+			_this.$emit('node-drag-over', draggingNode.node, dropNode.node, event);
+		});
+
+		this.$on('tree-node-drag-end', function (event) {
+			var draggingNode = dragState.draggingNode,
+			    dropType = dragState.dropType,
+			    dropNode = dragState.dropNode;
+
+			event.preventDefault();
+			event.dataTransfer.dropEffect = 'move';
+
+			if (draggingNode && dropNode) {
+				var draggingNodeCopy = { data: draggingNode.node.data };
+				if (dropType !== 'none') {
+					draggingNode.node.remove();
+				}
+				if (dropType === 'before') {
+					dropNode.node.parent.insertBefore(draggingNodeCopy, dropNode.node);
+				} else if (dropType === 'after') {
+					dropNode.node.parent.insertAfter(draggingNodeCopy, dropNode.node);
+				} else if (dropType === 'inner') {
+					dropNode.node.insertChild(draggingNodeCopy);
+				}
+				if (dropType !== 'none') {
+					_this.store.registerNode(draggingNodeCopy);
+				}
+
+				Object(dom_["removeClass"])(dropNode.$el, 'is-drop-inner');
+
+				_this.$emit('node-drag-end', draggingNode.node, dropNode.node, dropType, event);
+				if (dropType !== 'none') {
+					_this.$emit('node-drop', draggingNode.node, dropNode.node, dropType, event);
+				}
+			}
+			if (draggingNode && !dropNode) {
+				_this.$emit('node-drag-end', draggingNode.node, null, dropType, event);
+			}
+
+			dragState.showDropIndicator = false;
+			dragState.draggingNode = null;
+			dragState.dropNode = null;
+			dragState.allowDrop = true;
+		});
+	},
+	mounted: function mounted() {
+		this.initTabIndex();
+		this.$el.addEventListener('keydown', this.handleKeydown);
+	},
+	updated: function updated() {
+		this.treeItems = this.$el.querySelectorAll('[role=treeitem]');
+		this.checkboxItems = this.$el.querySelectorAll('input[type=checkbox]');
+	}
+});
+// CONCATENATED MODULE: ./packages/tree/src/tree.vue?vue&type=script&lang=js
+ /* harmony default export */ var src_treevue_type_script_lang_js = (treevue_type_script_lang_js); 
+// CONCATENATED MODULE: ./packages/tree/src/tree.vue
+
+
+
+
+
+/* normalize component */
+
+var tree_component = Object(componentNormalizer["a" /* default */])(
+  src_treevue_type_script_lang_js,
+  render,
+  staticRenderFns,
+  false,
+  null,
+  null,
+  null
+  
+)
+
+/* harmony default export */ var tree = (tree_component.exports);
+// CONCATENATED MODULE: ./packages/tree/index.js
+
+
+/* istanbul ignore next */
+tree.install = function (Vue) {
+	Vue.component(tree.name, tree);
+};
+
+/* harmony default export */ var packages_tree = __webpack_exports__["default"] = (tree);
+
+/***/ }),
+
+/***/ 5:
+/***/ (function(module, exports) {
+
+module.exports = require("element-ui/lib/utils/vue-popper");
+
+/***/ }),
+
+/***/ 6:
+/***/ (function(module, exports) {
+
+module.exports = require("element-ui/lib/utils/merge");
+
+/***/ }),
+
+/***/ 7:
+/***/ (function(module, exports) {
+
+module.exports = require("element-ui/lib/mixins/migrating");
+
+/***/ }),
+
+/***/ 8:
+/***/ (function(module, exports) {
+
+module.exports = require("vue");
+
+/***/ })
+
+/******/ });