front-ui-admin 1.1.20 → 1.1.21

package/front-ui-admin.common.js

@@ -7510,6 +7510,10 @@ __webpack_require__.d(__webpack_exports__, "POptionGroup", function() { return /
 __webpack_require__.d(__webpack_exports__, "PSelectDropdown", function() { return /* reexport */ select_dropdown; });
 __webpack_require__.d(__webpack_exports__, "PTableColumn", function() { return /* reexport */ Table_column; });
 __webpack_require__.d(__webpack_exports__, "PTestButton", function() { return /* reexport */ p_test_button; });
+__webpack_require__.d(__webpack_exports__, "PCascader", function() { return /* reexport */ p_cascader; });
+__webpack_require__.d(__webpack_exports__, "PCascaderPanel", function() { return /* reexport */ p_cascader_panel; });
+__webpack_require__.d(__webpack_exports__, "PCheckbox", function() { return /* reexport */ p_checkbox; });
+__webpack_require__.d(__webpack_exports__, "PRadio", function() { return /* reexport */ p_radio; });
 __webpack_require__.d(__webpack_exports__, "use", function() { return /* reexport */ use; });
 __webpack_require__.d(__webpack_exports__, "t", function() { return /* reexport */ t; });
 __webpack_require__.d(__webpack_exports__, "i18n", function() { return /* reexport */ i18n; });
@@ -8782,7 +8786,7 @@ const util_isEqual = function (value1, value2) {
   }
   return looseEqual(value1, value2);
 };
-const isEmpty = function (val) {
+const util_isEmpty = function (val) {
   // null or undefined
   if (val == null) return true;
   if (typeof val === 'boolean') return false;
@@ -8824,7 +8828,7 @@ function objToArray(obj) {
   if (Array.isArray(obj)) {
     return obj;
   }
-  return isEmpty(obj) ? [] : [obj];
+  return util_isEmpty(obj) ? [] : [obj];
 }
 const isMac = function () {
   return !external_root_Vue_commonjs_vue_commonjs2_vue_amd_vue_default.a.prototype.$isServer && /macintosh|mac os x/i.test(navigator.userAgent);
@@ -9341,7 +9345,7 @@ function walkTreeNode(root, cb, childrenKey = 'children', lazyKey = 'hasChildren
 // CONCATENATED MODULE: ./src/package-admin/p-table/src/store/current.js
 
 
-/* harmony default export */ var current = ({
+/* harmony default export */ var store_current = ({
   data() {
     return {
       states: {
@@ -9725,7 +9729,7 @@ const doFlattenColumns = columns => {
       }
     };
   },
-  mixins: [expand, current, tree],
+  mixins: [expand, store_current, tree],
   methods: {
     // 检查 rowKey 是否存在
     assertRowKey() {
@@ -14294,15 +14298,15 @@ var input_component = normalizeComponent(
   
 )
 
-/* harmony default export */ var input = (input_component.exports);
+/* harmony default export */ var src_input = (input_component.exports);
 // CONCATENATED MODULE: ./src/package-admin/p-input/index.js
 
 
 /* istanbul ignore next */
-input.install = function (Vue) {
-  Vue.component(input.name, input);
+src_input.install = function (Vue) {
+  Vue.component(src_input.name, src_input);
 };
-/* harmony default export */ var p_input = (input);
+/* harmony default export */ var p_input = (src_input);
 // CONCATENATED MODULE: ./node_modules/cache-loader/dist/cjs.js??ref--13-0!./node_modules/babel-loader/lib!./node_modules/cache-loader/dist/cjs.js??ref--1-0!./node_modules/vue-loader/lib??vue-loader-options!./src/package-admin/p-tag/src/tag.vue?vue&type=script&lang=js
 /* harmony default export */ var tagvue_type_script_lang_js = ({
   name: 'PTag',
@@ -14386,15 +14390,15 @@ var tag_component = normalizeComponent(
   
 )
 
-/* harmony default export */ var tag = (tag_component.exports);
+/* harmony default export */ var src_tag = (tag_component.exports);
 // CONCATENATED MODULE: ./src/package-admin/p-tag/index.js
 
 
 /* istanbul ignore next */
-tag.install = function (Vue) {
-  Vue.component(tag.name, tag);
+src_tag.install = function (Vue) {
+  Vue.component(src_tag.name, src_tag);
 };
-/* harmony default export */ var p_tag = (tag);
+/* harmony default export */ var p_tag = (src_tag);
 // CONCATENATED MODULE: ./node_modules/cache-loader/dist/cjs.js?{"cacheDirectory":"node_modules/.cache/vue-loader","cacheIdentifier":"75b11e11-vue-loader-template"}!./node_modules/cache-loader/dist/cjs.js??ref--13-0!./node_modules/babel-loader/lib!./node_modules/vue-loader/lib/loaders/templateLoader.js??ref--6!./node_modules/cache-loader/dist/cjs.js??ref--1-0!./node_modules/vue-loader/lib??vue-loader-options!./src/package-admin/p-select/src/select.vue?vue&type=template&id=37c882d6
 var selectvue_type_template_id_37c882d6_render = function render() {
   var _vm = this,
@@ -16433,6 +16437,2506 @@ var p_test_button_component = normalizeComponent(
 )
 
 /* harmony default export */ var p_test_button = (p_test_button_component.exports);
+// CONCATENATED MODULE: ./node_modules/cache-loader/dist/cjs.js?{"cacheDirectory":"node_modules/.cache/vue-loader","cacheIdentifier":"75b11e11-vue-loader-template"}!./node_modules/cache-loader/dist/cjs.js??ref--13-0!./node_modules/babel-loader/lib!./node_modules/vue-loader/lib/loaders/templateLoader.js??ref--6!./node_modules/cache-loader/dist/cjs.js??ref--1-0!./node_modules/vue-loader/lib??vue-loader-options!./src/package-admin/p-cascader/src/cascader.vue?vue&type=template&id=93427a92
+var cascadervue_type_template_id_93427a92_render = function render() {
+  var _vm = this,
+    _c = _vm._self._c;
+  return _c('div', {
+    directives: [{
+      name: "clickoutside",
+      rawName: "v-clickoutside",
+      value: () => _vm.toggleDropDownVisible(false),
+      expression: "() => toggleDropDownVisible(false)"
+    }],
+    ref: "reference",
+    class: ['p-cascader', _vm.realSize && `p-cascader--${_vm.realSize}`, {
+      'is-disabled': _vm.isDisabled
+    }],
+    on: {
+      "mouseenter": function ($event) {
+        _vm.inputHover = true;
+      },
+      "mouseleave": function ($event) {
+        _vm.inputHover = false;
+      },
+      "click": () => _vm.toggleDropDownVisible(_vm.readonly ? undefined : true),
+      "keydown": _vm.handleKeyDown
+    }
+  }, [_c('p-input', {
+    ref: "input",
+    class: {
+      'is-focus': _vm.dropDownVisible
+    },
+    attrs: {
+      "value": _vm.multiple ? _vm.presentText : _vm.inputValue,
+      "size": _vm.realSize,
+      "placeholder": _vm.placeholder,
+      "readonly": _vm.readonly,
+      "disabled": _vm.isDisabled,
+      "validate-event": false
+    },
+    on: {
+      "focus": _vm.handleFocus,
+      "blur": _vm.handleBlur,
+      "input": _vm.handleInput
+    }
+  }, [_c('template', {
+    slot: "suffix"
+  }, [_vm.clearBtnVisible ? _c('i', {
+    key: "clear",
+    staticClass: "el-input__icon el-icon-circle-close",
+    on: {
+      "click": function ($event) {
+        $event.stopPropagation();
+        return _vm.handleClear.apply(null, arguments);
+      }
+    }
+  }) : _c('i', {
+    key: "arrow-down",
+    class: ['el-input__icon', 'el-icon-arrow-down', _vm.dropDownVisible && 'is-reverse'],
+    on: {
+      "click": function ($event) {
+        $event.stopPropagation();
+        return _vm.toggleDropDownVisible();
+      }
+    }
+  })])], 2), _vm.multiple ? _c('div', {
+    staticClass: "p-cascader__tags"
+  }, [_vm._l(_vm.presentTags, function (tag) {
+    return _c('p-tag', {
+      key: tag.key,
+      attrs: {
+        "type": "info",
+        "size": _vm.tagSize,
+        "hit": tag.hitState,
+        "closable": tag.closable,
+        "disable-transitions": ""
+      },
+      on: {
+        "close": function ($event) {
+          return _vm.deleteTag(tag);
+        }
+      }
+    }, [_c('span', [_vm._v(_vm._s(tag.text))])]);
+  }), _vm.filterable && !_vm.isDisabled ? _c('input', {
+    directives: [{
+      name: "model",
+      rawName: "v-model.trim",
+      value: _vm.inputValue,
+      expression: "inputValue",
+      modifiers: {
+        "trim": true
+      }
+    }],
+    staticClass: "p-cascader__search-input",
+    attrs: {
+      "type": "text",
+      "placeholder": _vm.presentTags.length ? '' : _vm.placeholder
+    },
+    domProps: {
+      "value": _vm.inputValue
+    },
+    on: {
+      "input": [function ($event) {
+        if ($event.target.composing) return;
+        _vm.inputValue = $event.target.value.trim();
+      }, e => _vm.handleInput(_vm.inputValue, e)],
+      "click": function ($event) {
+        $event.stopPropagation();
+        return _vm.toggleDropDownVisible(true);
+      },
+      "keydown": function ($event) {
+        if (!$event.type.indexOf('key') && _vm._k($event.keyCode, "delete", [8, 46], $event.key, ["Backspace", "Delete", "Del"])) return null;
+        return _vm.handleDelete.apply(null, arguments);
+      },
+      "blur": function ($event) {
+        return _vm.$forceUpdate();
+      }
+    }
+  }) : _vm._e()], 2) : _vm._e(), _c('transition', {
+    attrs: {
+      "name": "el-zoom-in-top"
+    },
+    on: {
+      "after-leave": _vm.handleDropdownLeave
+    }
+  }, [_c('div', {
+    directives: [{
+      name: "show",
+      rawName: "v-show",
+      value: _vm.dropDownVisible,
+      expression: "dropDownVisible"
+    }],
+    ref: "popper",
+    class: ['el-popper', 'p-cascader__dropdown', _vm.popperClass]
+  }, [_c('p-cascader-panel', {
+    directives: [{
+      name: "show",
+      rawName: "v-show",
+      value: !_vm.filtering,
+      expression: "!filtering"
+    }],
+    ref: "panel",
+    attrs: {
+      "options": _vm.options,
+      "props": _vm.config,
+      "border": false,
+      "render-label": _vm.$scopedSlots.default
+    },
+    on: {
+      "expand-change": _vm.handleExpandChange,
+      "close": function ($event) {
+        return _vm.toggleDropDownVisible(false);
+      }
+    },
+    model: {
+      value: _vm.checkedValue,
+      callback: function ($$v) {
+        _vm.checkedValue = $$v;
+      },
+      expression: "checkedValue"
+    }
+  }), _vm.filterable ? _c('p-scrollbar', {
+    directives: [{
+      name: "show",
+      rawName: "v-show",
+      value: _vm.filtering,
+      expression: "filtering"
+    }],
+    ref: "suggestionPanel",
+    staticClass: "p-cascader__suggestion-panel",
+    attrs: {
+      "tag": "ul",
+      "view-class": "p-cascader__suggestion-list"
+    },
+    nativeOn: {
+      "keydown": function ($event) {
+        return _vm.handleSuggestionKeyDown.apply(null, arguments);
+      }
+    }
+  }, [_vm.suggestions.length ? _vm._l(_vm.suggestions, function (item, index) {
+    return _c('li', {
+      key: item.uid,
+      class: ['p-cascader__suggestion-item', item.checked && 'is-checked'],
+      attrs: {
+        "tabindex": -1
+      },
+      on: {
+        "click": function ($event) {
+          return _vm.handleSuggestionClick(index);
+        }
+      }
+    }, [_c('span', [_vm._v(_vm._s(item.text))]), item.checked ? _c('i', {
+      staticClass: "el-icon-check"
+    }) : _vm._e()]);
+  }) : _vm._t("empty", function () {
+    return [_c('li', {
+      staticClass: "p-cascader__empty-text"
+    }, [_vm._v(_vm._s(_vm.t('el.cascader.noMatch')))])];
+  })], 2) : _vm._e()], 1)])], 1);
+};
+var cascadervue_type_template_id_93427a92_staticRenderFns = [];
+
+// CONCATENATED MODULE: ./src/package-admin/p-cascader/src/cascader.vue?vue&type=template&id=93427a92
+
+// CONCATENATED MODULE: ./node_modules/cache-loader/dist/cjs.js?{"cacheDirectory":"node_modules/.cache/vue-loader","cacheIdentifier":"75b11e11-vue-loader-template"}!./node_modules/cache-loader/dist/cjs.js??ref--13-0!./node_modules/babel-loader/lib!./node_modules/vue-loader/lib/loaders/templateLoader.js??ref--6!./node_modules/cache-loader/dist/cjs.js??ref--1-0!./node_modules/vue-loader/lib??vue-loader-options!./src/package-admin/p-cascader-panel/src/cascader-panel.vue?vue&type=template&id=4484171a
+var cascader_panelvue_type_template_id_4484171a_render = function render() {
+  var _vm = this,
+    _c = _vm._self._c;
+  return _c('div', {
+    class: ['p-cascader-panel', _vm.border && 'is-bordered'],
+    on: {
+      "keydown": _vm.handleKeyDown
+    }
+  }, _vm._l(_vm.menus, function (menu, index) {
+    return _c('cascader-menu', {
+      key: index,
+      ref: "menu",
+      refInFor: true,
+      attrs: {
+        "index": index,
+        "nodes": menu
+      }
+    });
+  }), 1);
+};
+var cascader_panelvue_type_template_id_4484171a_staticRenderFns = [];
+
+// CONCATENATED MODULE: ./src/package-admin/p-cascader-panel/src/cascader-panel.vue?vue&type=template&id=4484171a
+
+// CONCATENATED MODULE: ./node_modules/cache-loader/dist/cjs.js?{"cacheDirectory":"node_modules/.cache/vue-loader","cacheIdentifier":"75b11e11-vue-loader-template"}!./node_modules/cache-loader/dist/cjs.js??ref--13-0!./node_modules/babel-loader/lib!./node_modules/vue-loader/lib/loaders/templateLoader.js??ref--6!./node_modules/cache-loader/dist/cjs.js??ref--1-0!./node_modules/vue-loader/lib??vue-loader-options!./src/package-admin/p-checkbox/src/checkbox.vue?vue&type=template&id=7233fbeb
+var checkboxvue_type_template_id_7233fbeb_render = function render() {
+  var _vm = this,
+    _c = _vm._self._c;
+  return _c('label', {
+    staticClass: "p-checkbox",
+    class: [_vm.border && _vm.checkboxSize ? 'p-checkbox--' + _vm.checkboxSize : '', {
+      'is-disabled': _vm.isDisabled
+    }, {
+      'is-bordered': _vm.border
+    }, {
+      'is-checked': _vm.isChecked
+    }],
+    attrs: {
+      "id": _vm.id
+    }
+  }, [_c('span', {
+    staticClass: "p-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: "p-checkbox__inner"
+  }), _vm.trueLabel || _vm.falseLabel ? _c('input', {
+    directives: [{
+      name: "model",
+      rawName: "v-model",
+      value: _vm.model,
+      expression: "model"
+    }],
+    staticClass: "p-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: "p-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: "p-checkbox__label"
+  }, [_vm._t("default"), !_vm.$slots.default ? [_vm._v(_vm._s(_vm.label))] : _vm._e()], 2) : _vm._e()]);
+};
+var checkboxvue_type_template_id_7233fbeb_staticRenderFns = [];
+
+// CONCATENATED MODULE: ./src/package-admin/p-checkbox/src/checkbox.vue?vue&type=template&id=7233fbeb
+
+// CONCATENATED MODULE: ./node_modules/cache-loader/dist/cjs.js??ref--13-0!./node_modules/babel-loader/lib!./node_modules/cache-loader/dist/cjs.js??ref--1-0!./node_modules/vue-loader/lib??vue-loader-options!./src/package-admin/p-checkbox/src/checkbox.vue?vue&type=script&lang=js
+
+
+/* harmony default export */ var p_checkbox_src_checkboxvue_type_script_lang_js = ({
+  name: 'PCheckbox',
+  mixins: [emitter],
+  inject: {
+    elForm: {
+      default: ''
+    },
+    elFormItem: {
+      default: ''
+    }
+  },
+  componentName: 'PCheckbox',
+  data() {
+    return {
+      selfModel: false,
+      focus: false,
+      isLimitExceeded: false
+    };
+  },
+  computed: {
+    model: {
+      get() {
+        return this.isGroup ? this.store : this.value !== undefined ? this.value : this.selfModel;
+      },
+      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('PCheckboxGroup', 'input', [val]);
+        } else {
+          this.$emit('input', val);
+          this.selfModel = val;
+        }
+      }
+    },
+    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() {
+      let parent = this.$parent;
+      while (parent) {
+        if (parent.$options.componentName !== 'PCheckboxGroup') {
+          parent = parent.$parent;
+        } else {
+          this._checkboxGroup = parent;
+          return true;
+        }
+      }
+      return false;
+    },
+    store() {
+      return this._checkboxGroup ? this._checkboxGroup.value : this.value;
+    },
+    /* used to make the isDisabled judgment under max/min props */
+    isLimitDisabled() {
+      const {
+        max,
+        min
+      } = this._checkboxGroup;
+      return !!(max || min) && this.model.length >= max && !this.isChecked || this.model.length <= min && this.isChecked;
+    },
+    isDisabled() {
+      return this.isGroup ? this._checkboxGroup.disabled || this.disabled || (this.elForm || {}).disabled || this.isLimitDisabled : this.disabled || (this.elForm || {}).disabled;
+    },
+    _elFormItemSize() {
+      return (this.elFormItem || {}).elFormItemSize;
+    },
+    checkboxSize() {
+      const 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() {
+      if (Array.isArray(this.model) && this.model.indexOf(this.label) === -1) {
+        this.model.push(this.label);
+      } else {
+        this.model = this.trueLabel || true;
+      }
+    },
+    handleChange(ev) {
+      if (this.isLimitExceeded) return;
+      let value;
+      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(() => {
+        if (this.isGroup) {
+          this.dispatch('PCheckboxGroup', 'change', [this._checkboxGroup.value]);
+        }
+      });
+    }
+  },
+  created() {
+    this.checked && this.addToStore();
+  },
+  mounted() {
+    // 为indeterminate元素 添加aria-controls 属性
+    if (this.indeterminate) {
+      this.$el.setAttribute('aria-controls', this.controls);
+    }
+  },
+  watch: {
+    value(value) {
+      this.dispatch('ElFormItem', 'el.form.change', value);
+    }
+  }
+});
+// CONCATENATED MODULE: ./src/package-admin/p-checkbox/src/checkbox.vue?vue&type=script&lang=js
+ /* harmony default export */ var package_admin_p_checkbox_src_checkboxvue_type_script_lang_js = (p_checkbox_src_checkboxvue_type_script_lang_js); 
+// CONCATENATED MODULE: ./src/package-admin/p-checkbox/src/checkbox.vue
+
+
+
+
+
+/* normalize component */
+
+var checkbox_component = normalizeComponent(
+  package_admin_p_checkbox_src_checkboxvue_type_script_lang_js,
+  checkboxvue_type_template_id_7233fbeb_render,
+  checkboxvue_type_template_id_7233fbeb_staticRenderFns,
+  false,
+  null,
+  null,
+  null
+  
+)
+
+/* harmony default export */ var p_checkbox_src_checkbox = (checkbox_component.exports);
+// CONCATENATED MODULE: ./src/package-admin/p-checkbox/index.js
+
+
+/* istanbul ignore next */
+p_checkbox_src_checkbox.install = function (Vue) {
+  Vue.component(p_checkbox_src_checkbox.name, p_checkbox_src_checkbox);
+};
+/* harmony default export */ var p_checkbox = (p_checkbox_src_checkbox);
+// CONCATENATED MODULE: ./node_modules/cache-loader/dist/cjs.js?{"cacheDirectory":"node_modules/.cache/vue-loader","cacheIdentifier":"75b11e11-vue-loader-template"}!./node_modules/cache-loader/dist/cjs.js??ref--13-0!./node_modules/babel-loader/lib!./node_modules/vue-loader/lib/loaders/templateLoader.js??ref--6!./node_modules/cache-loader/dist/cjs.js??ref--1-0!./node_modules/vue-loader/lib??vue-loader-options!./src/package-admin/p-radio/src/radio.vue?vue&type=template&id=768f701d
+var radiovue_type_template_id_768f701d_render = function render() {
+  var _vm = this,
+    _c = _vm._self._c;
+  return _c('label', {
+    staticClass: "p-radio",
+    class: [_vm.border && _vm.radioSize ? 'p-radio--' + _vm.radioSize : '', {
+      'is-disabled': _vm.isDisabled
+    }, {
+      'is-focus': _vm.focus
+    }, {
+      'is-bordered': _vm.border
+    }, {
+      'is-checked': _vm.model === _vm.label
+    }],
+    attrs: {
+      "role": "radio",
+      "aria-checked": _vm.model === _vm.label,
+      "aria-disabled": _vm.isDisabled,
+      "tabindex": _vm.tabIndex
+    },
+    on: {
+      "keydown": function ($event) {
+        if (!$event.type.indexOf('key') && _vm._k($event.keyCode, "space", 32, $event.key, [" ", "Spacebar"])) return null;
+        $event.stopPropagation();
+        $event.preventDefault();
+        _vm.model = _vm.isDisabled ? _vm.model : _vm.label;
+      }
+    }
+  }, [_c('span', {
+    staticClass: "p-radio__input",
+    class: {
+      'is-disabled': _vm.isDisabled,
+      'is-checked': _vm.model === _vm.label
+    }
+  }, [_c('span', {
+    staticClass: "p-radio__inner"
+  }), _c('input', {
+    directives: [{
+      name: "model",
+      rawName: "v-model",
+      value: _vm.model,
+      expression: "model"
+    }],
+    ref: "radio",
+    staticClass: "p-radio__original",
+    attrs: {
+      "type": "radio",
+      "aria-hidden": "true",
+      "name": _vm.name,
+      "disabled": _vm.isDisabled,
+      "tabindex": "-1",
+      "autocomplete": "off"
+    },
+    domProps: {
+      "value": _vm.label,
+      "checked": _vm._q(_vm.model, _vm.label)
+    },
+    on: {
+      "focus": function ($event) {
+        _vm.focus = true;
+      },
+      "blur": function ($event) {
+        _vm.focus = false;
+      },
+      "change": [function ($event) {
+        _vm.model = _vm.label;
+      }, _vm.handleChange]
+    }
+  })]), _c('span', {
+    staticClass: "p-radio__label",
+    on: {
+      "keydown": function ($event) {
+        $event.stopPropagation();
+      }
+    }
+  }, [_vm._t("default"), !_vm.$slots.default ? [_vm._v(_vm._s(_vm.label))] : _vm._e()], 2)]);
+};
+var radiovue_type_template_id_768f701d_staticRenderFns = [];
+
+// CONCATENATED MODULE: ./src/package-admin/p-radio/src/radio.vue?vue&type=template&id=768f701d
+
+// CONCATENATED MODULE: ./node_modules/cache-loader/dist/cjs.js??ref--13-0!./node_modules/babel-loader/lib!./node_modules/cache-loader/dist/cjs.js??ref--1-0!./node_modules/vue-loader/lib??vue-loader-options!./src/package-admin/p-radio/src/radio.vue?vue&type=script&lang=js
+
+/* harmony default export */ var radiovue_type_script_lang_js = ({
+  name: 'PRadio',
+  mixins: [emitter],
+  inject: {
+    elForm: {
+      default: ''
+    },
+    elFormItem: {
+      default: ''
+    }
+  },
+  componentName: 'PRadio',
+  props: {
+    value: {},
+    label: {},
+    disabled: Boolean,
+    name: String,
+    border: Boolean,
+    size: String
+  },
+  data() {
+    return {
+      focus: false
+    };
+  },
+  computed: {
+    isGroup() {
+      let parent = this.$parent;
+      while (parent) {
+        if (parent.$options.componentName !== 'PRadioGroup') {
+          parent = parent.$parent;
+        } else {
+          this._radioGroup = parent;
+          return true;
+        }
+      }
+      return false;
+    },
+    model: {
+      get() {
+        return this.isGroup ? this._radioGroup.value : this.value;
+      },
+      set(val) {
+        if (this.isGroup) {
+          this.dispatch('PRadioGroup', 'input', [val]);
+        } else {
+          this.$emit('input', val);
+        }
+        this.$refs.radio && (this.$refs.radio.checked = this.model === this.label);
+      }
+    },
+    _elFormItemSize() {
+      return (this.elFormItem || {}).elFormItemSize;
+    },
+    radioSize() {
+      const temRadioSize = this.size || this._elFormItemSize || (this.$ELEMENT || {}).size;
+      return this.isGroup ? this._radioGroup.radioGroupSize || temRadioSize : temRadioSize;
+    },
+    isDisabled() {
+      return this.isGroup ? this._radioGroup.disabled || this.disabled || (this.elForm || {}).disabled : this.disabled || (this.elForm || {}).disabled;
+    },
+    tabIndex() {
+      return this.isDisabled || this.isGroup && this.model !== this.label ? -1 : 0;
+    }
+  },
+  methods: {
+    handleChange() {
+      this.$nextTick(() => {
+        this.$emit('change', this.model);
+        this.isGroup && this.dispatch('PRadioGroup', 'handleChange', this.model);
+      });
+    }
+  }
+});
+// CONCATENATED MODULE: ./src/package-admin/p-radio/src/radio.vue?vue&type=script&lang=js
+ /* harmony default export */ var src_radiovue_type_script_lang_js = (radiovue_type_script_lang_js); 
+// CONCATENATED MODULE: ./src/package-admin/p-radio/src/radio.vue
+
+
+
+
+
+/* normalize component */
+
+var radio_component = normalizeComponent(
+  src_radiovue_type_script_lang_js,
+  radiovue_type_template_id_768f701d_render,
+  radiovue_type_template_id_768f701d_staticRenderFns,
+  false,
+  null,
+  null,
+  null
+  
+)
+
+/* harmony default export */ var src_radio = (radio_component.exports);
+// CONCATENATED MODULE: ./src/package-admin/p-radio/index.js
+
+
+/* istanbul ignore next */
+src_radio.install = function (Vue) {
+  Vue.component(src_radio.name, src_radio);
+};
+/* harmony default export */ var p_radio = (src_radio);
+// CONCATENATED MODULE: ./node_modules/cache-loader/dist/cjs.js??ref--13-0!./node_modules/babel-loader/lib!./node_modules/cache-loader/dist/cjs.js??ref--1-0!./node_modules/vue-loader/lib??vue-loader-options!./src/package-admin/p-cascader-panel/src/cascader-node.vue?vue&type=script&lang=js
+
+
+
+
+
+
+const stopPropagation = e => e.stopPropagation();
+/* harmony default export */ var cascader_nodevue_type_script_lang_js = ({
+  inject: ['panel'],
+  components: {
+    PCheckbox: p_checkbox,
+    PRadio: p_radio
+  },
+  props: {
+    node: {
+      required: true
+    },
+    nodeId: String
+  },
+  computed: {
+    config() {
+      return this.panel.config;
+    },
+    isLeaf() {
+      return this.node.isLeaf;
+    },
+    isDisabled() {
+      return this.node.isDisabled;
+    },
+    checkedValue() {
+      return this.panel.checkedValue;
+    },
+    isChecked() {
+      return this.node.isSameNode(this.checkedValue);
+    },
+    inActivePath() {
+      return this.isInPath(this.panel.activePath);
+    },
+    inCheckedPath() {
+      if (!this.config.checkStrictly) return false;
+      return this.panel.checkedNodePaths.some(checkedPath => this.isInPath(checkedPath));
+    },
+    value() {
+      return this.node.getValueByOption();
+    }
+  },
+  methods: {
+    handleExpand() {
+      const {
+        panel,
+        node,
+        isDisabled,
+        config
+      } = this;
+      const {
+        multiple,
+        checkStrictly
+      } = config;
+      if (!checkStrictly && isDisabled || node.loading) return;
+      if (config.lazy && !node.loaded) {
+        panel.lazyLoad(node, () => {
+          // do not use cached leaf value here, invoke this.isLeaf to get new value.
+          const {
+            isLeaf
+          } = this;
+          if (!isLeaf) this.handleExpand();
+          if (multiple) {
+            // if leaf sync checked state, else clear checked state
+            const checked = isLeaf ? node.checked : false;
+            this.handleMultiCheckChange(checked);
+          }
+        });
+      } else {
+        panel.handleExpand(node);
+      }
+    },
+    handleCheckChange() {
+      const {
+        panel,
+        value,
+        node
+      } = this;
+      panel.handleCheckChange(value);
+      panel.handleExpand(node);
+    },
+    handleMultiCheckChange(checked) {
+      this.node.doCheck(checked);
+      this.panel.calculateMultiCheckedValue();
+    },
+    isInPath(pathNodes) {
+      const {
+        node
+      } = this;
+      const selectedPathNode = pathNodes[node.level - 1] || {};
+      return selectedPathNode.uid === node.uid;
+    },
+    renderPrefix(h) {
+      const {
+        isLeaf,
+        isChecked,
+        config
+      } = this;
+      const {
+        checkStrictly,
+        multiple
+      } = config;
+      if (multiple) {
+        return this.renderCheckbox(h);
+      } else if (checkStrictly) {
+        return this.renderRadio(h);
+      } else if (isLeaf && isChecked) {
+        return this.renderCheckIcon(h);
+      }
+      return null;
+    },
+    renderPostfix(h) {
+      const {
+        node,
+        isLeaf
+      } = this;
+      if (node.loading) {
+        return this.renderLoadingIcon(h);
+      } else if (!isLeaf) {
+        return this.renderExpandIcon(h);
+      }
+      return null;
+    },
+    renderCheckbox(h) {
+      const {
+        node,
+        config,
+        isDisabled
+      } = this;
+      const events = {
+        on: {
+          change: this.handleMultiCheckChange
+        },
+        nativeOn: {}
+      };
+      if (config.checkStrictly) {
+        // when every node is selectable, click event should not trigger expand event.
+        events.nativeOn.click = stopPropagation;
+      }
+      return h("p-checkbox", helper_default()([{
+        "attrs": {
+          "value": node.checked,
+          "indeterminate": node.indeterminate,
+          "disabled": isDisabled
+        }
+      }, events]));
+    },
+    renderRadio(h) {
+      let {
+        checkedValue,
+        value,
+        isDisabled
+      } = this;
+
+      // to keep same reference if value cause radio's checked state is calculated by reference comparision;
+      if (util_isEqual(value, checkedValue)) {
+        value = checkedValue;
+      }
+      return h("p-radio", {
+        "attrs": {
+          "value": checkedValue,
+          "label": value,
+          "disabled": isDisabled
+        },
+        "on": {
+          "change": this.handleCheckChange
+        },
+        "nativeOn": {
+          "click": stopPropagation
+        }
+      }, [h("span")]);
+    },
+    renderCheckIcon(h) {
+      return h("i", {
+        "class": "el-icon-check p-cascader-node__prefix"
+      });
+    },
+    renderLoadingIcon(h) {
+      return h("i", {
+        "class": "el-icon-loading p-cascader-node__postfix"
+      });
+    },
+    renderExpandIcon(h) {
+      return h("i", {
+        "class": "el-icon-arrow-right p-cascader-node__postfix"
+      });
+    },
+    renderContent(h) {
+      const {
+        panel,
+        node
+      } = this;
+      const render = panel.renderLabelFn;
+      const vnode = render ? render({
+        node,
+        data: node.data
+      }) : null;
+      return h("span", {
+        "class": "p-cascader-node__label"
+      }, [vnode || node.label]);
+    }
+  },
+  render(h) {
+    const {
+      inActivePath,
+      inCheckedPath,
+      isChecked,
+      isLeaf,
+      isDisabled,
+      config,
+      nodeId
+    } = this;
+    const {
+      expandTrigger,
+      checkStrictly,
+      multiple
+    } = config;
+    const disabled = !checkStrictly && isDisabled;
+    const events = {
+      on: {}
+    };
+    if (expandTrigger === 'click') {
+      events.on.click = this.handleExpand;
+    } else {
+      events.on.mouseenter = e => {
+        this.handleExpand();
+        this.$emit('expand', e);
+      };
+      events.on.focus = e => {
+        this.handleExpand();
+        this.$emit('expand', e);
+      };
+    }
+    if (isLeaf && !isDisabled && !checkStrictly && !multiple) {
+      events.on.click = this.handleCheckChange;
+    }
+    return h("li", helper_default()([{
+      "attrs": {
+        "role": "menuitem",
+        "id": nodeId,
+        "aria-expanded": inActivePath,
+        "tabindex": disabled ? null : -1
+      },
+      "class": {
+        'p-cascader-node': true,
+        'is-selectable': checkStrictly,
+        'in-active-path': inActivePath,
+        'in-checked-path': inCheckedPath,
+        'is-active': isChecked,
+        'is-disabled': disabled
+      }
+    }, events]), [this.renderPrefix(h), this.renderContent(h), this.renderPostfix(h)]);
+  }
+});
+// CONCATENATED MODULE: ./src/package-admin/p-cascader-panel/src/cascader-node.vue?vue&type=script&lang=js
+ /* harmony default export */ var src_cascader_nodevue_type_script_lang_js = (cascader_nodevue_type_script_lang_js); 
+// CONCATENATED MODULE: ./src/package-admin/p-cascader-panel/src/cascader-node.vue
+var cascader_node_render, cascader_node_staticRenderFns
+
+
+
+
+/* normalize component */
+
+var cascader_node_component = normalizeComponent(
+  src_cascader_nodevue_type_script_lang_js,
+  cascader_node_render,
+  cascader_node_staticRenderFns,
+  false,
+  null,
+  null,
+  null
+  
+)
+
+/* harmony default export */ var cascader_node = (cascader_node_component.exports);
+// CONCATENATED MODULE: ./node_modules/cache-loader/dist/cjs.js??ref--13-0!./node_modules/babel-loader/lib!./node_modules/cache-loader/dist/cjs.js??ref--1-0!./node_modules/vue-loader/lib??vue-loader-options!./src/package-admin/p-cascader-panel/src/cascader-menu.vue?vue&type=script&lang=js
+
+
+
+
+
+
+
+/* harmony default export */ var cascader_menuvue_type_script_lang_js = ({
+  name: 'PCascaderMenu',
+  mixins: [mixins_locale],
+  inject: ['panel'],
+  components: {
+    PScrollbar: p_scrollbar,
+    CascaderNode: cascader_node
+  },
+  props: {
+    nodes: {
+      type: Array,
+      required: true
+    },
+    index: Number
+  },
+  data() {
+    return {
+      activeNode: null,
+      hoverTimer: null,
+      id: generateId()
+    };
+  },
+  computed: {
+    isEmpty() {
+      return !this.nodes.length;
+    },
+    menuId() {
+      return `cascader-menu-${this.id}-${this.index}`;
+    }
+  },
+  methods: {
+    handleExpand(e) {
+      this.activeNode = e.target;
+    },
+    handleMouseMove(e) {
+      const {
+        activeNode,
+        hoverTimer
+      } = this;
+      const {
+        hoverZone
+      } = this.$refs;
+      if (!activeNode || !hoverZone) return;
+      if (activeNode.contains(e.target)) {
+        clearTimeout(hoverTimer);
+        const {
+          left
+        } = this.$el.getBoundingClientRect();
+        const startX = e.clientX - left;
+        const {
+          offsetWidth,
+          offsetHeight
+        } = this.$el;
+        const top = activeNode.offsetTop;
+        const bottom = top + activeNode.offsetHeight;
+        hoverZone.innerHTML = `
+          <path style="pointer-events: auto;" fill="transparent" d="M${startX} ${top} L${offsetWidth} 0 V${top} Z" />
+          <path style="pointer-events: auto;" fill="transparent" d="M${startX} ${bottom} L${offsetWidth} ${offsetHeight} V${bottom} Z" />
+        `;
+      } else if (!hoverTimer) {
+        this.hoverTimer = setTimeout(this.clearHoverZone, this.panel.config.hoverThreshold);
+      }
+    },
+    clearHoverZone() {
+      const {
+        hoverZone
+      } = this.$refs;
+      if (!hoverZone) return;
+      hoverZone.innerHTML = '';
+    },
+    renderEmptyText(h) {
+      return h("div", {
+        "class": "p-cascader-menu__empty-text"
+      }, [this.t('el.cascader.noData')]);
+    },
+    renderNodeList(h) {
+      const {
+        menuId
+      } = this;
+      const {
+        isHoverMenu
+      } = this.panel;
+      const events = {
+        on: {}
+      };
+      if (isHoverMenu) {
+        events.on.expand = this.handleExpand;
+      }
+      const nodes = this.nodes.map((node, index) => {
+        const {
+          hasChildren
+        } = node;
+        return h("cascader-node", helper_default()([{
+          "key": node.uid,
+          "attrs": {
+            "node": node,
+            "node-id": `${menuId}-${index}`,
+            "aria-haspopup": hasChildren,
+            "aria-owns": hasChildren ? menuId : null
+          }
+        }, events]));
+      });
+      return [...nodes, isHoverMenu ? h("svg", {
+        "ref": 'hoverZone',
+        "class": 'p-cascader-menu__hover-zone'
+      }) : null];
+    }
+  },
+  render(h) {
+    const {
+      isEmpty,
+      menuId
+    } = this;
+    const events = {
+      nativeOn: {}
+    };
+
+    // optimize hover to expand experience (#8010)
+    if (this.panel.isHoverMenu) {
+      events.nativeOn.mousemove = this.handleMouseMove;
+      // events.nativeOn.mouseleave = this.clearHoverZone;
+    }
+    return h("p-scrollbar", helper_default()([{
+      "attrs": {
+        "tag": "ul",
+        "role": "menu",
+        "id": menuId,
+        "wrap-class": "p-cascader-menu__wrap",
+        "view-class": {
+          'p-cascader-menu__list': true,
+          'is-empty': isEmpty
+        }
+      },
+      "class": "p-cascader-menu"
+    }, events]), [isEmpty ? this.renderEmptyText(h) : this.renderNodeList(h)]);
+  }
+});
+// CONCATENATED MODULE: ./src/package-admin/p-cascader-panel/src/cascader-menu.vue?vue&type=script&lang=js
+ /* harmony default export */ var src_cascader_menuvue_type_script_lang_js = (cascader_menuvue_type_script_lang_js); 
+// CONCATENATED MODULE: ./src/package-admin/p-cascader-panel/src/cascader-menu.vue
+var cascader_menu_render, cascader_menu_staticRenderFns
+
+
+
+
+/* normalize component */
+
+var cascader_menu_component = normalizeComponent(
+  src_cascader_menuvue_type_script_lang_js,
+  cascader_menu_render,
+  cascader_menu_staticRenderFns,
+  false,
+  null,
+  null,
+  null
+  
+)
+
+/* harmony default export */ var cascader_menu = (cascader_menu_component.exports);
+// CONCATENATED MODULE: ./src/package-admin/p-cascader-panel/src/node.js
+
+
+
+
+
+
+
+
+
+
+let uid = 0;
+class node_Node {
+  constructor(data, config, parentNode) {
+    this.data = data;
+    this.config = config;
+    this.parent = parentNode || null;
+    this.level = !this.parent ? 1 : this.parent.level + 1;
+    this.uid = uid++;
+    this.initState();
+    this.initChildren();
+  }
+  initState() {
+    const {
+      value: valueKey,
+      label: labelKey
+    } = this.config;
+    this.value = this.data[valueKey];
+    this.label = this.data[labelKey];
+    this.pathNodes = this.calculatePathNodes();
+    this.path = this.pathNodes.map(node => node.value);
+    this.pathLabels = this.pathNodes.map(node => node.label);
+
+    // lazy load
+    this.loading = false;
+    this.loaded = false;
+  }
+  initChildren() {
+    const {
+      config
+    } = this;
+    const childrenKey = config.children;
+    const childrenData = this.data[childrenKey];
+    this.hasChildren = Array.isArray(childrenData);
+    this.children = (childrenData || []).map(child => new node_Node(child, config, this));
+  }
+  get isDisabled() {
+    const {
+      data,
+      parent,
+      config
+    } = this;
+    const disabledKey = config.disabled;
+    const {
+      checkStrictly
+    } = config;
+    return data[disabledKey] || !checkStrictly && parent && parent.isDisabled;
+  }
+  get isLeaf() {
+    const {
+      data,
+      loaded,
+      hasChildren,
+      children
+    } = this;
+    const {
+      lazy,
+      leaf: leafKey
+    } = this.config;
+    if (lazy) {
+      const isLeaf = isDef(data[leafKey]) ? data[leafKey] : loaded ? !children.length : false;
+      this.hasChildren = !isLeaf;
+      return isLeaf;
+    }
+    return !hasChildren;
+  }
+  calculatePathNodes() {
+    const nodes = [this];
+    let parent = this.parent;
+    while (parent) {
+      nodes.unshift(parent);
+      parent = parent.parent;
+    }
+    return nodes;
+  }
+  getPath() {
+    return this.path;
+  }
+  getValue() {
+    return this.value;
+  }
+  getValueByOption() {
+    return this.config.emitPath ? this.getPath() : this.getValue();
+  }
+  getText(allLevels, separator, showLastLevels = null) {
+    if (showLastLevels !== null && Number.isInteger(showLastLevels) && showLastLevels > 0) {
+      // 显示最后N个层级
+      const labels = this.pathLabels;
+      const startIndex = Math.max(0, labels.length - showLastLevels);
+      return labels.slice(startIndex).join(separator);
+    }
+    return allLevels ? this.pathLabels.join(separator) : this.label;
+  }
+  isSameNode(checkedValue) {
+    const value = this.getValueByOption();
+    return this.config.multiple && Array.isArray(checkedValue) ? checkedValue.some(val => util_isEqual(val, value)) : util_isEqual(checkedValue, value);
+  }
+  broadcast(event, ...args) {
+    const handlerName = `onParent${capitalize(event)}`;
+    this.children.forEach(child => {
+      if (child) {
+        // bottom up
+        child.broadcast(event, ...args);
+        child[handlerName] && child[handlerName](...args);
+      }
+    });
+  }
+  emit(event, ...args) {
+    const {
+      parent
+    } = this;
+    const handlerName = `onChild${capitalize(event)}`;
+    if (parent) {
+      parent[handlerName] && parent[handlerName](...args);
+      parent.emit(event, ...args);
+    }
+  }
+  onParentCheck(checked) {
+    if (!this.isDisabled) {
+      this.setCheckState(checked);
+    }
+  }
+  onChildCheck() {
+    const {
+      children
+    } = this;
+    const validChildren = children.filter(child => !child.isDisabled);
+    const checked = validChildren.length ? validChildren.every(child => child.checked) : false;
+    this.setCheckState(checked);
+  }
+  setCheckState(checked) {
+    const totalNum = this.children.length;
+    const checkedNum = this.children.reduce((c, p) => {
+      const num = p.checked ? 1 : p.indeterminate ? 0.5 : 0;
+      return c + num;
+    }, 0);
+    this.checked = checked;
+    this.indeterminate = checkedNum !== totalNum && checkedNum > 0;
+  }
+  syncCheckState(checkedValue) {
+    const value = this.getValueByOption();
+    const checked = this.isSameNode(checkedValue, value);
+    this.doCheck(checked);
+  }
+  doCheck(checked) {
+    if (this.checked !== checked) {
+      if (this.config.checkStrictly) {
+        this.checked = checked;
+      } else {
+        // bottom up to unify the calculation of the indeterminate state
+        this.broadcast('check', checked);
+        this.setCheckState(checked);
+        this.emit('check');
+      }
+    }
+  }
+}
+// CONCATENATED MODULE: ./src/package-admin/p-cascader-panel/src/store.js
+
+
+
+
+
+
+
+
+
+const flatNodes = (data, leafOnly) => {
+  return data.reduce((res, node) => {
+    if (node.isLeaf) {
+      res.push(node);
+    } else {
+      !leafOnly && res.push(node);
+      res = res.concat(flatNodes(node.children, leafOnly));
+    }
+    return res;
+  }, []);
+};
+class store_Store {
+  constructor(data, config) {
+    this.config = config;
+    this.initNodes(data);
+  }
+  initNodes(data) {
+    data = coerceTruthyValueToArray(data);
+    this.nodes = data.map(nodeData => new node_Node(nodeData, this.config));
+    this.flattedNodes = this.getFlattedNodes(false, false);
+    this.leafNodes = this.getFlattedNodes(true, false);
+  }
+  appendNode(nodeData, parentNode) {
+    const node = new node_Node(nodeData, this.config, parentNode);
+    const children = parentNode ? parentNode.children : this.nodes;
+    children.push(node);
+  }
+  appendNodes(nodeDataList, parentNode) {
+    nodeDataList = coerceTruthyValueToArray(nodeDataList);
+    nodeDataList.forEach(nodeData => this.appendNode(nodeData, parentNode));
+  }
+  getNodes() {
+    return this.nodes;
+  }
+  getFlattedNodes(leafOnly, cached = true) {
+    const cachedNodes = leafOnly ? this.leafNodes : this.flattedNodes;
+    return cached ? cachedNodes : flatNodes(this.nodes, leafOnly);
+  }
+  getNodeByValue(value) {
+    const nodes = this.getFlattedNodes(false, !this.config.lazy).filter(node => valueEquals(node.path, value) || node.value === value);
+    return nodes && nodes.length ? nodes[0] : null;
+  }
+}
+// CONCATENATED MODULE: ./src/utils/aria-utils.js
+var aria = aria || {};
+aria.Utils = aria.Utils || {};
+
+/**
+ * @desc Set focus on descendant nodes until the first focusable element is
+ *       found.
+ * @param element
+ *          DOM node for which to find the first focusable descendant.
+ * @returns
+ *  true if a focusable element is found and focus is set.
+ */
+aria.Utils.focusFirstDescendant = function (element) {
+  for (var i = 0; i < element.childNodes.length; i++) {
+    var child = element.childNodes[i];
+    if (aria.Utils.attemptFocus(child) || aria.Utils.focusFirstDescendant(child)) {
+      return true;
+    }
+  }
+  return false;
+};
+
+/**
+ * @desc Find the last descendant node that is focusable.
+ * @param element
+ *          DOM node for which to find the last focusable descendant.
+ * @returns
+ *  true if a focusable element is found and focus is set.
+ */
+
+aria.Utils.focusLastDescendant = function (element) {
+  for (var i = element.childNodes.length - 1; i >= 0; i--) {
+    var child = element.childNodes[i];
+    if (aria.Utils.attemptFocus(child) || aria.Utils.focusLastDescendant(child)) {
+      return true;
+    }
+  }
+  return false;
+};
+
+/**
+ * @desc Set Attempt to set focus on the current node.
+ * @param element
+ *          The node to attempt to focus on.
+ * @returns
+ *  true if element is focused.
+ */
+aria.Utils.attemptFocus = function (element) {
+  if (!aria.Utils.isFocusable(element)) {
+    return false;
+  }
+  aria.Utils.IgnoreUtilFocusChanges = true;
+  try {
+    element.focus();
+  } catch (e) {}
+  aria.Utils.IgnoreUtilFocusChanges = false;
+  return document.activeElement === element;
+};
+aria.Utils.isFocusable = function (element) {
+  if (element.tabIndex > 0 || element.tabIndex === 0 && element.getAttribute('tabIndex') !== null) {
+    return true;
+  }
+  if (element.disabled) {
+    return false;
+  }
+  switch (element.nodeName) {
+    case 'A':
+      return !!element.href && element.rel !== 'ignore';
+    case 'INPUT':
+      return element.type !== 'hidden' && element.type !== 'file';
+    case 'BUTTON':
+    case 'SELECT':
+    case 'TEXTAREA':
+      return true;
+    default:
+      return false;
+  }
+};
+
+/**
+ * 触发一个事件
+ * mouseenter, mouseleave, mouseover, keyup, change, click 等
+ * @param  {Element} elm
+ * @param  {String} name
+ * @param  {*} opts
+ */
+aria.Utils.triggerEvent = function (elm, name, ...opts) {
+  let eventName;
+  if (/^mouse|click/.test(name)) {
+    eventName = 'MouseEvents';
+  } else if (/^key/.test(name)) {
+    eventName = 'KeyboardEvent';
+  } else {
+    eventName = 'HTMLEvents';
+  }
+  const evt = document.createEvent(eventName);
+  evt.initEvent(name, ...opts);
+  elm.dispatchEvent ? elm.dispatchEvent(evt) : elm.fireEvent('on' + name, evt);
+  return elm;
+};
+aria.Utils.keys = {
+  tab: 9,
+  enter: 13,
+  space: 32,
+  left: 37,
+  up: 38,
+  right: 39,
+  down: 40,
+  esc: 27
+};
+/* harmony default export */ var aria_utils = (aria.Utils);
+// CONCATENATED MODULE: ./node_modules/cache-loader/dist/cjs.js??ref--13-0!./node_modules/babel-loader/lib!./node_modules/cache-loader/dist/cjs.js??ref--1-0!./node_modules/vue-loader/lib??vue-loader-options!./src/package-admin/p-cascader-panel/src/cascader-panel.vue?vue&type=script&lang=js
+
+
+
+
+
+
+
+
+
+
+
+const {
+  keys: KeyCode
+} = aria_utils;
+const DefaultProps = {
+  expandTrigger: 'click',
+  // or hover
+  multiple: false,
+  checkStrictly: false,
+  // whether all nodes can be selected
+  emitPath: true,
+  // wether to emit an array of all levels value in which node is located
+  lazy: false,
+  lazyLoad: noop,
+  value: 'value',
+  label: 'label',
+  children: 'children',
+  leaf: 'leaf',
+  disabled: 'disabled',
+  hoverThreshold: 500
+};
+const cascader_panelvue_type_script_lang_js_isLeaf = el => !el.getAttribute('aria-owns');
+const getSibling = (el, distance) => {
+  const {
+    parentNode
+  } = el;
+  if (parentNode) {
+    const siblings = parentNode.querySelectorAll('.p-cascader-node[tabindex="-1"]');
+    const index = Array.prototype.indexOf.call(siblings, el);
+    return siblings[index + distance] || null;
+  }
+  return null;
+};
+const getMenuIndex = (el, distance) => {
+  if (!el) return;
+  const pieces = el.id.split('-');
+  return Number(pieces[pieces.length - 2]);
+};
+const focusNode = el => {
+  if (!el) return;
+  el.focus();
+  !cascader_panelvue_type_script_lang_js_isLeaf(el) && el.click();
+};
+const checkNode = el => {
+  if (!el) return;
+  const input = el.querySelector('input');
+  if (input) {
+    input.click();
+  } else if (cascader_panelvue_type_script_lang_js_isLeaf(el)) {
+    el.click();
+  }
+};
+/* harmony default export */ var cascader_panelvue_type_script_lang_js = ({
+  name: 'PCascaderPanel',
+  components: {
+    CascaderMenu: cascader_menu
+  },
+  props: {
+    value: {},
+    options: Array,
+    props: Object,
+    border: {
+      type: Boolean,
+      default: true
+    },
+    renderLabel: Function
+  },
+  provide() {
+    return {
+      panel: this
+    };
+  },
+  data() {
+    return {
+      checkedValue: null,
+      checkedNodePaths: [],
+      store: [],
+      menus: [],
+      activePath: [],
+      loadCount: 0
+    };
+  },
+  computed: {
+    config() {
+      return merge({
+        ...DefaultProps
+      }, this.props || {});
+    },
+    multiple() {
+      return this.config.multiple;
+    },
+    checkStrictly() {
+      return this.config.checkStrictly;
+    },
+    leafOnly() {
+      return !this.checkStrictly;
+    },
+    isHoverMenu() {
+      return this.config.expandTrigger === 'hover';
+    },
+    renderLabelFn() {
+      return this.renderLabel || this.$scopedSlots.default;
+    }
+  },
+  watch: {
+    value() {
+      this.syncCheckedValue();
+      this.checkStrictly && this.calculateCheckedNodePaths();
+    },
+    options: {
+      handler: function () {
+        this.initStore();
+      },
+      immediate: true,
+      deep: true
+    },
+    checkedValue(val) {
+      if (!util_isEqual(val, this.value)) {
+        this.checkStrictly && this.calculateCheckedNodePaths();
+        this.$emit('input', val);
+        this.$emit('change', val);
+      }
+    }
+  },
+  mounted() {
+    if (!this.isEmptyValue(this.value)) {
+      this.syncCheckedValue();
+    }
+  },
+  methods: {
+    initStore() {
+      const {
+        config,
+        options
+      } = this;
+      if (config.lazy && util_isEmpty(options)) {
+        this.lazyLoad();
+      } else {
+        this.store = new store_Store(options, config);
+        this.menus = [this.store.getNodes()];
+        this.syncMenuState();
+      }
+    },
+    syncCheckedValue() {
+      const {
+        value,
+        checkedValue
+      } = this;
+      if (!util_isEqual(value, checkedValue)) {
+        this.activePath = [];
+        this.checkedValue = value;
+        this.syncMenuState();
+      }
+    },
+    syncMenuState() {
+      const {
+        multiple,
+        checkStrictly
+      } = this;
+      this.syncActivePath();
+      multiple && this.syncMultiCheckState();
+      checkStrictly && this.calculateCheckedNodePaths();
+      this.$nextTick(this.scrollIntoView);
+    },
+    syncMultiCheckState() {
+      const nodes = this.getFlattedNodes(this.leafOnly);
+      nodes.forEach(node => {
+        node.syncCheckState(this.checkedValue);
+      });
+    },
+    isEmptyValue(val) {
+      const {
+        multiple,
+        config
+      } = this;
+      const {
+        emitPath
+      } = config;
+      if (multiple || emitPath) {
+        return util_isEmpty(val);
+      }
+      return false;
+    },
+    syncActivePath() {
+      const {
+        store,
+        multiple,
+        activePath,
+        checkedValue
+      } = this;
+      if (!util_isEmpty(activePath)) {
+        const nodes = activePath.map(node => this.getNodeByValue(node.getValue()));
+        this.expandNodes(nodes);
+      } else if (!this.isEmptyValue(checkedValue)) {
+        const value = multiple ? checkedValue[0] : checkedValue;
+        const checkedNode = this.getNodeByValue(value) || {};
+        const nodes = (checkedNode.pathNodes || []).slice(0, -1);
+        this.expandNodes(nodes);
+      } else {
+        this.activePath = [];
+        this.menus = [store.getNodes()];
+      }
+    },
+    expandNodes(nodes) {
+      nodes.forEach(node => this.handleExpand(node, true /* silent */));
+    },
+    calculateCheckedNodePaths() {
+      const {
+        checkedValue,
+        multiple
+      } = this;
+      const checkedValues = multiple ? coerceTruthyValueToArray(checkedValue) : [checkedValue];
+      this.checkedNodePaths = checkedValues.map(v => {
+        const checkedNode = this.getNodeByValue(v);
+        return checkedNode ? checkedNode.pathNodes : [];
+      });
+    },
+    handleKeyDown(e) {
+      const {
+        target,
+        keyCode
+      } = e;
+      switch (keyCode) {
+        case KeyCode.up:
+          const prev = getSibling(target, -1);
+          focusNode(prev);
+          break;
+        case KeyCode.down:
+          const next = getSibling(target, 1);
+          focusNode(next);
+          break;
+        case KeyCode.left:
+          const preMenu = this.$refs.menu[getMenuIndex(target) - 1];
+          if (preMenu) {
+            const expandedNode = preMenu.$el.querySelector('.p-cascader-node[aria-expanded="true"]');
+            focusNode(expandedNode);
+          }
+          break;
+        case KeyCode.right:
+          const nextMenu = this.$refs.menu[getMenuIndex(target) + 1];
+          if (nextMenu) {
+            const firstNode = nextMenu.$el.querySelector('.p-cascader-node[tabindex="-1"]');
+            focusNode(firstNode);
+          }
+          break;
+        case KeyCode.enter:
+          checkNode(target);
+          break;
+        case KeyCode.esc:
+        case KeyCode.tab:
+          this.$emit('close');
+          break;
+        default:
+          return;
+      }
+    },
+    handleExpand(node, silent) {
+      const {
+        activePath
+      } = this;
+      const {
+        level
+      } = node;
+      const path = activePath.slice(0, level - 1);
+      const menus = this.menus.slice(0, level);
+      if (!node.isLeaf) {
+        path.push(node);
+        menus.push(node.children);
+      }
+      this.activePath = path;
+      this.menus = menus;
+      if (!silent) {
+        const pathValues = path.map(node => node.getValue());
+        const activePathValues = activePath.map(node => node.getValue());
+        if (!valueEquals(pathValues, activePathValues)) {
+          this.$emit('active-item-change', pathValues); // Deprecated
+          this.$emit('expand-change', pathValues);
+        }
+      }
+    },
+    handleCheckChange(value) {
+      this.checkedValue = value;
+    },
+    lazyLoad(node, onFullfiled) {
+      const {
+        config
+      } = this;
+      if (!node) {
+        node = node || {
+          root: true,
+          level: 0
+        };
+        this.store = new store_Store([], config);
+        this.menus = [this.store.getNodes()];
+      }
+      node.loading = true;
+      const resolve = dataList => {
+        const parent = node.root ? null : node;
+        dataList && dataList.length && this.store.appendNodes(dataList, parent);
+        node.loading = false;
+        node.loaded = true;
+
+        // dispose default value on lazy load mode
+        if (Array.isArray(this.checkedValue)) {
+          const nodeValue = this.checkedValue[this.loadCount++];
+          const valueKey = this.config.value;
+          const leafKey = this.config.leaf;
+          if (Array.isArray(dataList) && dataList.filter(item => item[valueKey] === nodeValue).length > 0) {
+            const checkedNode = this.store.getNodeByValue(nodeValue);
+            if (!checkedNode.data[leafKey]) {
+              this.lazyLoad(checkedNode, () => {
+                this.handleExpand(checkedNode);
+              });
+            }
+            if (this.loadCount === this.checkedValue.length) {
+              this.$parent.computePresentText();
+            }
+          }
+        }
+        onFullfiled && onFullfiled(dataList);
+      };
+      config.lazyLoad(node, resolve);
+    },
+    /**
+     * public methods
+    */
+    calculateMultiCheckedValue() {
+      this.checkedValue = this.getCheckedNodes(this.leafOnly).map(node => node.getValueByOption());
+    },
+    scrollIntoView() {
+      if (this.$isServer) return;
+      const menus = this.$refs.menu || [];
+      menus.forEach(menu => {
+        const menuElement = menu.$el;
+        if (menuElement) {
+          const container = menuElement.querySelector('.el-scrollbar__wrap');
+          const activeNode = menuElement.querySelector('.p-cascader-node.is-active') || menuElement.querySelector('.p-cascader-node.in-active-path');
+          scroll_into_view_default()(container, activeNode);
+        }
+      });
+    },
+    getNodeByValue(val) {
+      return this.store.getNodeByValue(val);
+    },
+    getFlattedNodes(leafOnly) {
+      const cached = !this.config.lazy;
+      return this.store.getFlattedNodes(leafOnly, cached);
+    },
+    getCheckedNodes(leafOnly) {
+      const {
+        checkedValue,
+        multiple
+      } = this;
+      if (multiple) {
+        const nodes = this.getFlattedNodes(leafOnly);
+        return nodes.filter(node => node.checked);
+      } else {
+        return this.isEmptyValue(checkedValue) ? [] : [this.getNodeByValue(checkedValue)];
+      }
+    },
+    clearCheckedNodes() {
+      const {
+        config,
+        leafOnly
+      } = this;
+      const {
+        multiple,
+        emitPath
+      } = config;
+      if (multiple) {
+        this.getCheckedNodes(leafOnly).filter(node => !node.isDisabled).forEach(node => node.doCheck(false));
+        this.calculateMultiCheckedValue();
+      } else {
+        this.checkedValue = emitPath ? [] : null;
+      }
+    }
+  }
+});
+// CONCATENATED MODULE: ./src/package-admin/p-cascader-panel/src/cascader-panel.vue?vue&type=script&lang=js
+ /* harmony default export */ var src_cascader_panelvue_type_script_lang_js = (cascader_panelvue_type_script_lang_js); 
+// CONCATENATED MODULE: ./src/package-admin/p-cascader-panel/src/cascader-panel.vue
+
+
+
+
+
+/* normalize component */
+
+var cascader_panel_component = normalizeComponent(
+  src_cascader_panelvue_type_script_lang_js,
+  cascader_panelvue_type_template_id_4484171a_render,
+  cascader_panelvue_type_template_id_4484171a_staticRenderFns,
+  false,
+  null,
+  null,
+  null
+  
+)
+
+/* harmony default export */ var cascader_panel = (cascader_panel_component.exports);
+// CONCATENATED MODULE: ./src/package-admin/p-cascader-panel/index.js
+
+
+/* istanbul ignore next */
+cascader_panel.install = function (Vue) {
+  Vue.component(cascader_panel.name, cascader_panel);
+};
+/* harmony default export */ var p_cascader_panel = (cascader_panel);
+// CONCATENATED MODULE: ./node_modules/cache-loader/dist/cjs.js??ref--13-0!./node_modules/babel-loader/lib!./node_modules/cache-loader/dist/cjs.js??ref--1-0!./node_modules/vue-loader/lib??vue-loader-options!./src/package-admin/p-cascader/src/cascader.vue?vue&type=script&lang=js
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+const {
+  keys: cascadervue_type_script_lang_js_KeyCode
+} = aria_utils;
+const MigratingProps = {
+  expandTrigger: {
+    newProp: 'expandTrigger',
+    type: String
+  },
+  changeOnSelect: {
+    newProp: 'checkStrictly',
+    type: Boolean
+  },
+  hoverThreshold: {
+    newProp: 'hoverThreshold',
+    type: Number
+  }
+};
+const PopperMixin = {
+  props: {
+    placement: {
+      type: String,
+      default: 'bottom-start'
+    },
+    appendToBody: vue_popper.props.appendToBody,
+    visibleArrow: {
+      type: Boolean,
+      default: true
+    },
+    arrowOffset: vue_popper.props.arrowOffset,
+    offset: vue_popper.props.offset,
+    boundariesPadding: vue_popper.props.boundariesPadding,
+    popperOptions: vue_popper.props.popperOptions,
+    transformOrigin: vue_popper.props.transformOrigin
+  },
+  methods: vue_popper.methods,
+  data: vue_popper.data,
+  beforeDestroy: vue_popper.beforeDestroy
+};
+const InputSizeMap = {
+  medium: 36,
+  small: 32,
+  mini: 28
+};
+/* harmony default export */ var cascadervue_type_script_lang_js = ({
+  name: 'PCascader',
+  directives: {
+    Clickoutside: clickoutside
+  },
+  mixins: [PopperMixin, emitter, mixins_locale, migrating],
+  inject: {
+    elForm: {
+      default: ''
+    },
+    elFormItem: {
+      default: ''
+    }
+  },
+  components: {
+    PInput: p_input,
+    PTag: p_tag,
+    PScrollbar: p_scrollbar,
+    PCascaderPanel: p_cascader_panel
+  },
+  props: {
+    value: {},
+    options: Array,
+    props: Object,
+    size: String,
+    placeholder: {
+      type: String,
+      default: () => t('el.cascader.placeholder')
+    },
+    disabled: Boolean,
+    clearable: Boolean,
+    filterable: Boolean,
+    filterMethod: Function,
+    separator: {
+      type: String,
+      default: ' / '
+    },
+    showAllLevels: {
+      type: Boolean,
+      default: true
+    },
+    showLastLevels: {
+      type: Number,
+      default: null,
+      validator: val => val === null || Number.isInteger(val) && val > 0
+    },
+    collapseTags: Boolean,
+    debounce: {
+      type: Number,
+      default: 300
+    },
+    beforeFilter: {
+      type: Function,
+      default: () => () => {}
+    },
+    popperClass: String
+  },
+  data() {
+    return {
+      dropDownVisible: false,
+      checkedValue: this.value,
+      inputHover: false,
+      inputValue: null,
+      presentText: null,
+      presentTags: [],
+      checkedNodes: [],
+      filtering: false,
+      suggestions: [],
+      inputInitialHeight: 0,
+      pressDeleteCount: 0
+    };
+  },
+  computed: {
+    realSize() {
+      const _elFormItemSize = (this.elFormItem || {}).elFormItemSize;
+      return this.size || _elFormItemSize || (this.$ELEMENT || {}).size;
+    },
+    tagSize() {
+      return ['small', 'mini'].indexOf(this.realSize) > -1 ? 'mini' : 'small';
+    },
+    isDisabled() {
+      return this.disabled || (this.elForm || {}).disabled;
+    },
+    config() {
+      const config = this.props || {};
+      const {
+        $attrs
+      } = this;
+      Object.keys(MigratingProps).forEach(oldProp => {
+        const {
+          newProp,
+          type
+        } = MigratingProps[oldProp];
+        let oldValue = $attrs[oldProp] || $attrs[kebabCase(oldProp)];
+        if (isDef(oldProp) && !isDef(config[newProp])) {
+          if (type === Boolean && oldValue === '') {
+            oldValue = true;
+          }
+          config[newProp] = oldValue;
+        }
+      });
+      return config;
+    },
+    multiple() {
+      return this.config.multiple;
+    },
+    leafOnly() {
+      return !this.config.checkStrictly;
+    },
+    readonly() {
+      return !this.filterable || this.multiple;
+    },
+    clearBtnVisible() {
+      if (!this.clearable || this.isDisabled || this.filtering || !this.inputHover) {
+        return false;
+      }
+      return this.multiple ? !!this.checkedNodes.filter(node => !node.isDisabled).length : !!this.presentText;
+    },
+    panel() {
+      return this.$refs.panel;
+    }
+  },
+  watch: {
+    disabled() {
+      this.computePresentContent();
+    },
+    value(val) {
+      if (!util_isEqual(val, this.checkedValue)) {
+        this.checkedValue = val;
+        this.computePresentContent();
+      }
+    },
+    checkedValue(val) {
+      const {
+        value,
+        dropDownVisible
+      } = this;
+      const {
+        checkStrictly,
+        multiple
+      } = this.config;
+      if (!util_isEqual(val, value) || types_isUndefined(value)) {
+        this.computePresentContent();
+        // hide dropdown when single mode
+        if (!multiple && !checkStrictly && dropDownVisible) {
+          this.toggleDropDownVisible(false);
+        }
+        this.$emit('input', val);
+        this.$emit('change', val);
+        this.dispatch('ElFormItem', 'el.form.change', [val]);
+      }
+    },
+    options: {
+      handler: function () {
+        this.$nextTick(this.computePresentContent);
+      },
+      deep: true
+    },
+    presentText(val) {
+      this.inputValue = val;
+    },
+    presentTags(val, oldVal) {
+      if (this.multiple && (val.length || oldVal.length)) {
+        this.$nextTick(this.updateStyle);
+      }
+    },
+    filtering(val) {
+      this.$nextTick(this.updatePopper);
+    }
+  },
+  mounted() {
+    const {
+      input
+    } = this.$refs;
+    if (input && input.$el) {
+      this.inputInitialHeight = input.$el.offsetHeight || InputSizeMap[this.realSize] || 40;
+    }
+    if (!this.isEmptyValue(this.value)) {
+      this.computePresentContent();
+    }
+    this.filterHandler = debounce_default()(this.debounce, () => {
+      const {
+        inputValue
+      } = this;
+      if (!inputValue) {
+        this.filtering = false;
+        return;
+      }
+      const before = this.beforeFilter(inputValue);
+      if (before && before.then) {
+        before.then(this.getSuggestions);
+      } else if (before !== false) {
+        this.getSuggestions();
+      } else {
+        this.filtering = false;
+      }
+    });
+    addResizeListener(this.$el, this.updateStyle);
+  },
+  beforeDestroy() {
+    removeResizeListener(this.$el, this.updateStyle);
+  },
+  methods: {
+    getMigratingConfig() {
+      return {
+        props: {
+          'expand-trigger': 'expand-trigger is removed, use `props.expandTrigger` instead.',
+          'change-on-select': 'change-on-select is removed, use `props.checkStrictly` instead.',
+          'hover-threshold': 'hover-threshold is removed, use `props.hoverThreshold` instead'
+        },
+        events: {
+          'active-item-change': 'active-item-change is renamed to expand-change'
+        }
+      };
+    },
+    toggleDropDownVisible(visible) {
+      if (this.isDisabled) return;
+      const {
+        dropDownVisible
+      } = this;
+      const {
+        input
+      } = this.$refs;
+      visible = isDef(visible) ? visible : !dropDownVisible;
+      if (visible !== dropDownVisible) {
+        this.dropDownVisible = visible;
+        if (visible) {
+          this.$nextTick(() => {
+            this.updatePopper();
+            this.panel.scrollIntoView();
+          });
+        }
+        input.$refs.input.setAttribute('aria-expanded', visible);
+        this.$emit('visible-change', visible);
+      }
+    },
+    handleDropdownLeave() {
+      this.filtering = false;
+      this.inputValue = this.presentText;
+      this.doDestroy();
+    },
+    handleKeyDown(event) {
+      switch (event.keyCode) {
+        case cascadervue_type_script_lang_js_KeyCode.enter:
+          this.toggleDropDownVisible();
+          break;
+        case cascadervue_type_script_lang_js_KeyCode.down:
+          this.toggleDropDownVisible(true);
+          this.focusFirstNode();
+          event.preventDefault();
+          break;
+        case cascadervue_type_script_lang_js_KeyCode.esc:
+        case cascadervue_type_script_lang_js_KeyCode.tab:
+          this.toggleDropDownVisible(false);
+          break;
+      }
+    },
+    handleFocus(e) {
+      this.$emit('focus', e);
+    },
+    handleBlur(e) {
+      this.$emit('blur', e);
+    },
+    handleInput(val, event) {
+      !this.dropDownVisible && this.toggleDropDownVisible(true);
+      if (event && event.isComposing) return;
+      if (val) {
+        this.filterHandler();
+      } else {
+        this.filtering = false;
+      }
+    },
+    handleClear() {
+      this.presentText = '';
+      this.panel.clearCheckedNodes();
+    },
+    handleExpandChange(value) {
+      this.$nextTick(this.updatePopper.bind(this));
+      this.$emit('expand-change', value);
+      this.$emit('active-item-change', value); // Deprecated
+    },
+    focusFirstNode() {
+      this.$nextTick(() => {
+        const {
+          filtering
+        } = this;
+        const {
+          popper,
+          suggestionPanel
+        } = this.$refs;
+        let firstNode = null;
+        if (filtering && suggestionPanel) {
+          firstNode = suggestionPanel.$el.querySelector('.p-cascader__suggestion-item');
+        } else {
+          const firstMenu = popper.querySelector('.p-cascader-menu');
+          firstNode = firstMenu.querySelector('.p-cascader-node[tabindex="-1"]');
+        }
+        if (firstNode) {
+          firstNode.focus();
+          !filtering && firstNode.click();
+        }
+      });
+    },
+    computePresentContent() {
+      // nextTick is required, because checked nodes may not change right now
+      this.$nextTick(() => {
+        if (this.config.multiple) {
+          this.computePresentTags();
+          this.presentText = this.presentTags.length ? ' ' : null;
+        } else {
+          this.computePresentText();
+        }
+      });
+    },
+    isEmptyValue(val) {
+      const {
+        multiple
+      } = this;
+      const {
+        emitPath
+      } = this.panel.config;
+      if (multiple || emitPath) {
+        return util_isEmpty(val);
+      }
+      return false;
+    },
+    computePresentText() {
+      const {
+        checkedValue,
+        config
+      } = this;
+      if (!this.isEmptyValue(checkedValue)) {
+        const node = this.panel.getNodeByValue(checkedValue);
+        if (node && (config.checkStrictly || node.isLeaf)) {
+          this.presentText = node.getText(this.showAllLevels, this.separator, this.showLastLevels);
+          return;
+        }
+      }
+      this.presentText = null;
+    },
+    computePresentTags() {
+      const {
+        isDisabled,
+        leafOnly,
+        showAllLevels,
+        separator,
+        collapseTags
+      } = this;
+      const checkedNodes = this.getCheckedNodes(leafOnly);
+      const tags = [];
+      const genTag = node => ({
+        node,
+        key: node.uid,
+        text: node.getText(showAllLevels, separator, this.showLastLevels),
+        hitState: false,
+        closable: !isDisabled && !node.isDisabled
+      });
+      if (checkedNodes.length) {
+        const [first, ...rest] = checkedNodes;
+        const restCount = rest.length;
+        tags.push(genTag(first));
+        if (restCount) {
+          if (collapseTags) {
+            tags.push({
+              key: -1,
+              text: `+ ${restCount}`,
+              closable: false
+            });
+          } else {
+            rest.forEach(node => tags.push(genTag(node)));
+          }
+        }
+      }
+      this.checkedNodes = checkedNodes;
+      this.presentTags = tags;
+    },
+    getSuggestions() {
+      let {
+        filterMethod
+      } = this;
+      if (!isFunction(filterMethod)) {
+        filterMethod = (node, keyword) => node.text.includes(keyword);
+      }
+      const suggestions = this.panel.getFlattedNodes(this.leafOnly).filter(node => {
+        if (node.isDisabled) return false;
+        node.text = node.getText(this.showAllLevels, this.separator, this.showLastLevels) || '';
+        return filterMethod(node, this.inputValue);
+      });
+      if (this.multiple) {
+        this.presentTags.forEach(tag => {
+          tag.hitState = false;
+        });
+      } else {
+        suggestions.forEach(node => {
+          node.checked = util_isEqual(this.checkedValue, node.getValueByOption());
+        });
+      }
+      this.filtering = true;
+      this.suggestions = suggestions;
+      this.$nextTick(this.updatePopper);
+    },
+    handleSuggestionKeyDown(event) {
+      const {
+        keyCode,
+        target
+      } = event;
+      switch (keyCode) {
+        case cascadervue_type_script_lang_js_KeyCode.enter:
+          target.click();
+          break;
+        case cascadervue_type_script_lang_js_KeyCode.up:
+          const prev = target.previousElementSibling;
+          prev && prev.focus();
+          break;
+        case cascadervue_type_script_lang_js_KeyCode.down:
+          const next = target.nextElementSibling;
+          next && next.focus();
+          break;
+        case cascadervue_type_script_lang_js_KeyCode.esc:
+        case cascadervue_type_script_lang_js_KeyCode.tab:
+          this.toggleDropDownVisible(false);
+          break;
+      }
+    },
+    handleDelete() {
+      const {
+        inputValue,
+        pressDeleteCount,
+        presentTags
+      } = this;
+      const lastIndex = presentTags.length - 1;
+      const lastTag = presentTags[lastIndex];
+      this.pressDeleteCount = inputValue ? 0 : pressDeleteCount + 1;
+      if (!lastTag) return;
+      if (this.pressDeleteCount) {
+        if (lastTag.hitState) {
+          this.deleteTag(lastTag);
+        } else {
+          lastTag.hitState = true;
+        }
+      }
+    },
+    handleSuggestionClick(index) {
+      const {
+        multiple
+      } = this;
+      const targetNode = this.suggestions[index];
+      if (multiple) {
+        const {
+          checked
+        } = targetNode;
+        targetNode.doCheck(!checked);
+        this.panel.calculateMultiCheckedValue();
+      } else {
+        this.checkedValue = targetNode.getValueByOption();
+        this.toggleDropDownVisible(false);
+      }
+    },
+    deleteTag(tag) {
+      const {
+        checkedValue
+      } = this;
+      const current = tag.node.getValueByOption();
+      const val = checkedValue.find(n => util_isEqual(n, current));
+      this.checkedValue = checkedValue.filter(n => !util_isEqual(n, current));
+      this.$emit('remove-tag', val);
+    },
+    updateStyle() {
+      const {
+        $el,
+        inputInitialHeight
+      } = this;
+      if (this.$isServer || !$el) return;
+      const {
+        suggestionPanel
+      } = this.$refs;
+      const inputInner = $el.querySelector('.el-input__inner');
+      if (!inputInner) return;
+      const tags = $el.querySelector('.p-cascader__tags');
+      let suggestionPanelEl = null;
+      if (suggestionPanel && (suggestionPanelEl = suggestionPanel.$el)) {
+        const suggestionList = suggestionPanelEl.querySelector('.p-cascader__suggestion-list');
+        suggestionList.style.minWidth = inputInner.offsetWidth + 'px';
+      }
+      if (tags) {
+        const offsetHeight = Math.round(tags.getBoundingClientRect().height);
+        const height = Math.max(offsetHeight + 6, inputInitialHeight) + 'px';
+        inputInner.style.height = height;
+        if (this.dropDownVisible) {
+          this.updatePopper();
+        }
+      }
+    },
+    /**
+     * public methods
+    */
+    getCheckedNodes(leafOnly) {
+      return this.panel.getCheckedNodes(leafOnly);
+    }
+  }
+});
+// CONCATENATED MODULE: ./src/package-admin/p-cascader/src/cascader.vue?vue&type=script&lang=js
+ /* harmony default export */ var src_cascadervue_type_script_lang_js = (cascadervue_type_script_lang_js); 
+// CONCATENATED MODULE: ./src/package-admin/p-cascader/src/cascader.vue
+
+
+
+
+
+/* normalize component */
+
+var cascader_component = normalizeComponent(
+  src_cascadervue_type_script_lang_js,
+  cascadervue_type_template_id_93427a92_render,
+  cascadervue_type_template_id_93427a92_staticRenderFns,
+  false,
+  null,
+  null,
+  null
+  
+)
+
+/* harmony default export */ var cascader = (cascader_component.exports);
+// CONCATENATED MODULE: ./src/package-admin/p-cascader/index.js
+
+
+/* istanbul ignore next */
+cascader.install = function (Vue) {
+  Vue.component(cascader.name, cascader);
+};
+/* harmony default export */ var p_cascader = (cascader);
 // EXTERNAL MODULE: ./src/theme-chalk/src/index.scss
 var theme_chalk_src = __webpack_require__("b531");
 
@@ -16450,6 +18954,10 @@ var theme_chalk_src = __webpack_require__("b531");
 
 
 
+
+
+
+
 // 导入语言包
 
 
@@ -16457,7 +18965,7 @@ var theme_chalk_src = __webpack_require__("b531");
 
 
 // 所有组件
-const components = [p_table, p_input, p_tag, p_tooltip, p_scrollbar, p_select, p_option, p_option_group, select_dropdown, Table_column, p_test_button];
+const components = [p_table, p_input, p_tag, p_tooltip, p_scrollbar, p_select, p_option, p_option_group, select_dropdown, Table_column, p_test_button, p_cascader, p_cascader_panel, p_checkbox, p_radio];
 
 // install 方法
 const install = function (Vue) {