fangguo-component 1.1.2 → 1.1.4

package/dist/SelectTree-DHbWogEU.js

@@ -0,0 +1,1276 @@
+import './SelectTree.css';var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+import { ElPopover, ElTreeV2, ElTag, ElIcon } from "element-plus/es";
+import { _ as _sfc_main$1 } from "./LazyPopover.vue_vue_type_script_setup_true_lang-B2vtU4f4.js";
+import { defineComponent, ref, computed, watch, nextTick, onMounted, resolveComponent, openBlock, createBlock, withCtx, createElementBlock, toDisplayString, createCommentVNode, createVNode, createElementVNode, normalizeStyle, normalizeClass, createTextVNode, withDirectives, withModifiers, vModelText, toRaw } from "vue";
+import { _ as _export_sfc } from "./_plugin-vue_export-helper-1tPrXgE0.js";
+const global = globalThis || void 0 || self;
+function listCacheClear() {
+  this.__data__ = [];
+  this.size = 0;
+}
+function eq(value, other) {
+  return value === other || value !== value && other !== other;
+}
+function assocIndexOf(array, key) {
+  var length = array.length;
+  while (length--) {
+    if (eq(array[length][0], key)) {
+      return length;
+    }
+  }
+  return -1;
+}
+var arrayProto = Array.prototype;
+var splice = arrayProto.splice;
+function listCacheDelete(key) {
+  var data = this.__data__, index = assocIndexOf(data, key);
+  if (index < 0) {
+    return false;
+  }
+  var lastIndex = data.length - 1;
+  if (index == lastIndex) {
+    data.pop();
+  } else {
+    splice.call(data, index, 1);
+  }
+  --this.size;
+  return true;
+}
+function listCacheGet(key) {
+  var data = this.__data__, index = assocIndexOf(data, key);
+  return index < 0 ? void 0 : data[index][1];
+}
+function listCacheHas(key) {
+  return assocIndexOf(this.__data__, key) > -1;
+}
+function listCacheSet(key, value) {
+  var data = this.__data__, index = assocIndexOf(data, key);
+  if (index < 0) {
+    ++this.size;
+    data.push([key, value]);
+  } else {
+    data[index][1] = value;
+  }
+  return this;
+}
+function ListCache(entries) {
+  var index = -1, length = entries == null ? 0 : entries.length;
+  this.clear();
+  while (++index < length) {
+    var entry = entries[index];
+    this.set(entry[0], entry[1]);
+  }
+}
+ListCache.prototype.clear = listCacheClear;
+ListCache.prototype["delete"] = listCacheDelete;
+ListCache.prototype.get = listCacheGet;
+ListCache.prototype.has = listCacheHas;
+ListCache.prototype.set = listCacheSet;
+function stackClear() {
+  this.__data__ = new ListCache();
+  this.size = 0;
+}
+function stackDelete(key) {
+  var data = this.__data__, result = data["delete"](key);
+  this.size = data.size;
+  return result;
+}
+function stackGet(key) {
+  return this.__data__.get(key);
+}
+function stackHas(key) {
+  return this.__data__.has(key);
+}
+var freeGlobal = typeof global == "object" && global && global.Object === Object && global;
+var freeSelf = typeof self == "object" && self && self.Object === Object && self;
+var root = freeGlobal || freeSelf || Function("return this")();
+var Symbol$1 = root.Symbol;
+var objectProto$b = Object.prototype;
+var hasOwnProperty$8 = objectProto$b.hasOwnProperty;
+var nativeObjectToString$1 = objectProto$b.toString;
+var symToStringTag$1 = Symbol$1 ? Symbol$1.toStringTag : void 0;
+function getRawTag(value) {
+  var isOwn = hasOwnProperty$8.call(value, symToStringTag$1), tag = value[symToStringTag$1];
+  try {
+    value[symToStringTag$1] = void 0;
+    var unmasked = true;
+  } catch (e) {
+  }
+  var result = nativeObjectToString$1.call(value);
+  if (unmasked) {
+    if (isOwn) {
+      value[symToStringTag$1] = tag;
+    } else {
+      delete value[symToStringTag$1];
+    }
+  }
+  return result;
+}
+var objectProto$a = Object.prototype;
+var nativeObjectToString = objectProto$a.toString;
+function objectToString(value) {
+  return nativeObjectToString.call(value);
+}
+var nullTag = "[object Null]", undefinedTag = "[object Undefined]";
+var symToStringTag = Symbol$1 ? Symbol$1.toStringTag : void 0;
+function baseGetTag(value) {
+  if (value == null) {
+    return value === void 0 ? undefinedTag : nullTag;
+  }
+  return symToStringTag && symToStringTag in Object(value) ? getRawTag(value) : objectToString(value);
+}
+function isObject(value) {
+  var type = typeof value;
+  return value != null && (type == "object" || type == "function");
+}
+var asyncTag = "[object AsyncFunction]", funcTag$2 = "[object Function]", genTag$1 = "[object GeneratorFunction]", proxyTag = "[object Proxy]";
+function isFunction(value) {
+  if (!isObject(value)) {
+    return false;
+  }
+  var tag = baseGetTag(value);
+  return tag == funcTag$2 || tag == genTag$1 || tag == asyncTag || tag == proxyTag;
+}
+var coreJsData = root["__core-js_shared__"];
+var maskSrcKey = (function() {
+  var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || "");
+  return uid ? "Symbol(src)_1." + uid : "";
+})();
+function isMasked(func) {
+  return !!maskSrcKey && maskSrcKey in func;
+}
+var funcProto$1 = Function.prototype;
+var funcToString$1 = funcProto$1.toString;
+function toSource(func) {
+  if (func != null) {
+    try {
+      return funcToString$1.call(func);
+    } catch (e) {
+    }
+    try {
+      return func + "";
+    } catch (e) {
+    }
+  }
+  return "";
+}
+var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
+var reIsHostCtor = /^\[object .+?Constructor\]$/;
+var funcProto = Function.prototype, objectProto$9 = Object.prototype;
+var funcToString = funcProto.toString;
+var hasOwnProperty$7 = objectProto$9.hasOwnProperty;
+var reIsNative = RegExp(
+  "^" + funcToString.call(hasOwnProperty$7).replace(reRegExpChar, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$"
+);
+function baseIsNative(value) {
+  if (!isObject(value) || isMasked(value)) {
+    return false;
+  }
+  var pattern = isFunction(value) ? reIsNative : reIsHostCtor;
+  return pattern.test(toSource(value));
+}
+function getValue(object, key) {
+  return object == null ? void 0 : object[key];
+}
+function getNative(object, key) {
+  var value = getValue(object, key);
+  return baseIsNative(value) ? value : void 0;
+}
+var Map = getNative(root, "Map");
+var nativeCreate = getNative(Object, "create");
+function hashClear() {
+  this.__data__ = nativeCreate ? nativeCreate(null) : {};
+  this.size = 0;
+}
+function hashDelete(key) {
+  var result = this.has(key) && delete this.__data__[key];
+  this.size -= result ? 1 : 0;
+  return result;
+}
+var HASH_UNDEFINED$1 = "__lodash_hash_undefined__";
+var objectProto$8 = Object.prototype;
+var hasOwnProperty$6 = objectProto$8.hasOwnProperty;
+function hashGet(key) {
+  var data = this.__data__;
+  if (nativeCreate) {
+    var result = data[key];
+    return result === HASH_UNDEFINED$1 ? void 0 : result;
+  }
+  return hasOwnProperty$6.call(data, key) ? data[key] : void 0;
+}
+var objectProto$7 = Object.prototype;
+var hasOwnProperty$5 = objectProto$7.hasOwnProperty;
+function hashHas(key) {
+  var data = this.__data__;
+  return nativeCreate ? data[key] !== void 0 : hasOwnProperty$5.call(data, key);
+}
+var HASH_UNDEFINED = "__lodash_hash_undefined__";
+function hashSet(key, value) {
+  var data = this.__data__;
+  this.size += this.has(key) ? 0 : 1;
+  data[key] = nativeCreate && value === void 0 ? HASH_UNDEFINED : value;
+  return this;
+}
+function Hash(entries) {
+  var index = -1, length = entries == null ? 0 : entries.length;
+  this.clear();
+  while (++index < length) {
+    var entry = entries[index];
+    this.set(entry[0], entry[1]);
+  }
+}
+Hash.prototype.clear = hashClear;
+Hash.prototype["delete"] = hashDelete;
+Hash.prototype.get = hashGet;
+Hash.prototype.has = hashHas;
+Hash.prototype.set = hashSet;
+function mapCacheClear() {
+  this.size = 0;
+  this.__data__ = {
+    "hash": new Hash(),
+    "map": new (Map || ListCache)(),
+    "string": new Hash()
+  };
+}
+function isKeyable(value) {
+  var type = typeof value;
+  return type == "string" || type == "number" || type == "symbol" || type == "boolean" ? value !== "__proto__" : value === null;
+}
+function getMapData(map, key) {
+  var data = map.__data__;
+  return isKeyable(key) ? data[typeof key == "string" ? "string" : "hash"] : data.map;
+}
+function mapCacheDelete(key) {
+  var result = getMapData(this, key)["delete"](key);
+  this.size -= result ? 1 : 0;
+  return result;
+}
+function mapCacheGet(key) {
+  return getMapData(this, key).get(key);
+}
+function mapCacheHas(key) {
+  return getMapData(this, key).has(key);
+}
+function mapCacheSet(key, value) {
+  var data = getMapData(this, key), size = data.size;
+  data.set(key, value);
+  this.size += data.size == size ? 0 : 1;
+  return this;
+}
+function MapCache(entries) {
+  var index = -1, length = entries == null ? 0 : entries.length;
+  this.clear();
+  while (++index < length) {
+    var entry = entries[index];
+    this.set(entry[0], entry[1]);
+  }
+}
+MapCache.prototype.clear = mapCacheClear;
+MapCache.prototype["delete"] = mapCacheDelete;
+MapCache.prototype.get = mapCacheGet;
+MapCache.prototype.has = mapCacheHas;
+MapCache.prototype.set = mapCacheSet;
+var LARGE_ARRAY_SIZE = 200;
+function stackSet(key, value) {
+  var data = this.__data__;
+  if (data instanceof ListCache) {
+    var pairs = data.__data__;
+    if (!Map || pairs.length < LARGE_ARRAY_SIZE - 1) {
+      pairs.push([key, value]);
+      this.size = ++data.size;
+      return this;
+    }
+    data = this.__data__ = new MapCache(pairs);
+  }
+  data.set(key, value);
+  this.size = data.size;
+  return this;
+}
+function Stack(entries) {
+  var data = this.__data__ = new ListCache(entries);
+  this.size = data.size;
+}
+Stack.prototype.clear = stackClear;
+Stack.prototype["delete"] = stackDelete;
+Stack.prototype.get = stackGet;
+Stack.prototype.has = stackHas;
+Stack.prototype.set = stackSet;
+function arrayEach(array, iteratee) {
+  var index = -1, length = array == null ? 0 : array.length;
+  while (++index < length) {
+    if (iteratee(array[index], index, array) === false) {
+      break;
+    }
+  }
+  return array;
+}
+var defineProperty = (function() {
+  try {
+    var func = getNative(Object, "defineProperty");
+    func({}, "", {});
+    return func;
+  } catch (e) {
+  }
+})();
+function baseAssignValue(object, key, value) {
+  if (key == "__proto__" && defineProperty) {
+    defineProperty(object, key, {
+      "configurable": true,
+      "enumerable": true,
+      "value": value,
+      "writable": true
+    });
+  } else {
+    object[key] = value;
+  }
+}
+var objectProto$6 = Object.prototype;
+var hasOwnProperty$4 = objectProto$6.hasOwnProperty;
+function assignValue(object, key, value) {
+  var objValue = object[key];
+  if (!(hasOwnProperty$4.call(object, key) && eq(objValue, value)) || value === void 0 && !(key in object)) {
+    baseAssignValue(object, key, value);
+  }
+}
+function baseTimes(n, iteratee) {
+  var index = -1, result = Array(n);
+  while (++index < n) {
+    result[index] = iteratee(index);
+  }
+  return result;
+}
+function isObjectLike(value) {
+  return value != null && typeof value == "object";
+}
+var argsTag$2 = "[object Arguments]";
+function baseIsArguments(value) {
+  return isObjectLike(value) && baseGetTag(value) == argsTag$2;
+}
+var objectProto$5 = Object.prototype;
+var hasOwnProperty$3 = objectProto$5.hasOwnProperty;
+var propertyIsEnumerable$1 = objectProto$5.propertyIsEnumerable;
+var isArguments = baseIsArguments(/* @__PURE__ */ (function() {
+  return arguments;
+})()) ? baseIsArguments : function(value) {
+  return isObjectLike(value) && hasOwnProperty$3.call(value, "callee") && !propertyIsEnumerable$1.call(value, "callee");
+};
+var isArray = Array.isArray;
+function stubFalse() {
+  return false;
+}
+var freeExports$2 = typeof exports == "object" && exports && !exports.nodeType && exports;
+var freeModule$2 = freeExports$2 && typeof module == "object" && module && !module.nodeType && module;
+var moduleExports$2 = freeModule$2 && freeModule$2.exports === freeExports$2;
+var Buffer$1 = moduleExports$2 ? root.Buffer : void 0;
+var nativeIsBuffer = Buffer$1 ? Buffer$1.isBuffer : void 0;
+var isBuffer = nativeIsBuffer || stubFalse;
+var MAX_SAFE_INTEGER$1 = 9007199254740991;
+var reIsUint = /^(?:0|[1-9]\d*)$/;
+function isIndex(value, length) {
+  var type = typeof value;
+  length = length == null ? MAX_SAFE_INTEGER$1 : length;
+  return !!length && (type == "number" || type != "symbol" && reIsUint.test(value)) && (value > -1 && value % 1 == 0 && value < length);
+}
+var MAX_SAFE_INTEGER = 9007199254740991;
+function isLength(value) {
+  return typeof value == "number" && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
+}
+var argsTag$1 = "[object Arguments]", arrayTag$1 = "[object Array]", boolTag$2 = "[object Boolean]", dateTag$2 = "[object Date]", errorTag$1 = "[object Error]", funcTag$1 = "[object Function]", mapTag$4 = "[object Map]", numberTag$2 = "[object Number]", objectTag$2 = "[object Object]", regexpTag$2 = "[object RegExp]", setTag$4 = "[object Set]", stringTag$2 = "[object String]", weakMapTag$2 = "[object WeakMap]";
+var arrayBufferTag$2 = "[object ArrayBuffer]", dataViewTag$3 = "[object DataView]", float32Tag$2 = "[object Float32Array]", float64Tag$2 = "[object Float64Array]", int8Tag$2 = "[object Int8Array]", int16Tag$2 = "[object Int16Array]", int32Tag$2 = "[object Int32Array]", uint8Tag$2 = "[object Uint8Array]", uint8ClampedTag$2 = "[object Uint8ClampedArray]", uint16Tag$2 = "[object Uint16Array]", uint32Tag$2 = "[object Uint32Array]";
+var typedArrayTags = {};
+typedArrayTags[float32Tag$2] = typedArrayTags[float64Tag$2] = typedArrayTags[int8Tag$2] = typedArrayTags[int16Tag$2] = typedArrayTags[int32Tag$2] = typedArrayTags[uint8Tag$2] = typedArrayTags[uint8ClampedTag$2] = typedArrayTags[uint16Tag$2] = typedArrayTags[uint32Tag$2] = true;
+typedArrayTags[argsTag$1] = typedArrayTags[arrayTag$1] = typedArrayTags[arrayBufferTag$2] = typedArrayTags[boolTag$2] = typedArrayTags[dataViewTag$3] = typedArrayTags[dateTag$2] = typedArrayTags[errorTag$1] = typedArrayTags[funcTag$1] = typedArrayTags[mapTag$4] = typedArrayTags[numberTag$2] = typedArrayTags[objectTag$2] = typedArrayTags[regexpTag$2] = typedArrayTags[setTag$4] = typedArrayTags[stringTag$2] = typedArrayTags[weakMapTag$2] = false;
+function baseIsTypedArray(value) {
+  return isObjectLike(value) && isLength(value.length) && !!typedArrayTags[baseGetTag(value)];
+}
+function baseUnary(func) {
+  return function(value) {
+    return func(value);
+  };
+}
+var freeExports$1 = typeof exports == "object" && exports && !exports.nodeType && exports;
+var freeModule$1 = freeExports$1 && typeof module == "object" && module && !module.nodeType && module;
+var moduleExports$1 = freeModule$1 && freeModule$1.exports === freeExports$1;
+var freeProcess = moduleExports$1 && freeGlobal.process;
+var nodeUtil = (function() {
+  try {
+    var types = freeModule$1 && freeModule$1.require && freeModule$1.require("util").types;
+    if (types) {
+      return types;
+    }
+    return freeProcess && freeProcess.binding && freeProcess.binding("util");
+  } catch (e) {
+  }
+})();
+var nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;
+var isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;
+var objectProto$4 = Object.prototype;
+var hasOwnProperty$2 = objectProto$4.hasOwnProperty;
+function arrayLikeKeys(value, inherited) {
+  var isArr = isArray(value), isArg = !isArr && isArguments(value), isBuff = !isArr && !isArg && isBuffer(value), isType = !isArr && !isArg && !isBuff && isTypedArray(value), skipIndexes = isArr || isArg || isBuff || isType, result = skipIndexes ? baseTimes(value.length, String) : [], length = result.length;
+  for (var key in value) {
+    if (hasOwnProperty$2.call(value, key) && !(skipIndexes && // Safari 9 has enumerable `arguments.length` in strict mode.
+    (key == "length" || // Node.js 0.10 has enumerable non-index properties on buffers.
+    isBuff && (key == "offset" || key == "parent") || // PhantomJS 2 has enumerable non-index properties on typed arrays.
+    isType && (key == "buffer" || key == "byteLength" || key == "byteOffset") || // Skip index properties.
+    isIndex(key, length)))) {
+      result.push(key);
+    }
+  }
+  return result;
+}
+var objectProto$3 = Object.prototype;
+function isPrototype(value) {
+  var Ctor = value && value.constructor, proto = typeof Ctor == "function" && Ctor.prototype || objectProto$3;
+  return value === proto;
+}
+function overArg(func, transform) {
+  return function(arg) {
+    return func(transform(arg));
+  };
+}
+var nativeKeys = overArg(Object.keys, Object);
+var objectProto$2 = Object.prototype;
+var hasOwnProperty$1 = objectProto$2.hasOwnProperty;
+function baseKeys(object) {
+  if (!isPrototype(object)) {
+    return nativeKeys(object);
+  }
+  var result = [];
+  for (var key in Object(object)) {
+    if (hasOwnProperty$1.call(object, key) && key != "constructor") {
+      result.push(key);
+    }
+  }
+  return result;
+}
+function isArrayLike(value) {
+  return value != null && isLength(value.length) && !isFunction(value);
+}
+function keys(object) {
+  return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);
+}
+var freeExports = typeof exports == "object" && exports && !exports.nodeType && exports;
+var freeModule = freeExports && typeof module == "object" && module && !module.nodeType && module;
+var moduleExports = freeModule && freeModule.exports === freeExports;
+var Buffer2 = moduleExports ? root.Buffer : void 0;
+Buffer2 ? Buffer2.allocUnsafe : void 0;
+function cloneBuffer(buffer, isDeep) {
+  {
+    return buffer.slice();
+  }
+}
+function arrayFilter(array, predicate) {
+  var index = -1, length = array == null ? 0 : array.length, resIndex = 0, result = [];
+  while (++index < length) {
+    var value = array[index];
+    if (predicate(value, index, array)) {
+      result[resIndex++] = value;
+    }
+  }
+  return result;
+}
+function stubArray() {
+  return [];
+}
+var objectProto$1 = Object.prototype;
+var propertyIsEnumerable = objectProto$1.propertyIsEnumerable;
+var nativeGetSymbols = Object.getOwnPropertySymbols;
+var getSymbols = !nativeGetSymbols ? stubArray : function(object) {
+  if (object == null) {
+    return [];
+  }
+  object = Object(object);
+  return arrayFilter(nativeGetSymbols(object), function(symbol) {
+    return propertyIsEnumerable.call(object, symbol);
+  });
+};
+function arrayPush(array, values) {
+  var index = -1, length = values.length, offset = array.length;
+  while (++index < length) {
+    array[offset + index] = values[index];
+  }
+  return array;
+}
+var getPrototype = overArg(Object.getPrototypeOf, Object);
+function baseGetAllKeys(object, keysFunc, symbolsFunc) {
+  var result = keysFunc(object);
+  return isArray(object) ? result : arrayPush(result, symbolsFunc(object));
+}
+function getAllKeys(object) {
+  return baseGetAllKeys(object, keys, getSymbols);
+}
+var DataView = getNative(root, "DataView");
+var Promise$1 = getNative(root, "Promise");
+var Set$1 = getNative(root, "Set");
+var WeakMap = getNative(root, "WeakMap");
+var mapTag$3 = "[object Map]", objectTag$1 = "[object Object]", promiseTag = "[object Promise]", setTag$3 = "[object Set]", weakMapTag$1 = "[object WeakMap]";
+var dataViewTag$2 = "[object DataView]";
+var dataViewCtorString = toSource(DataView), mapCtorString = toSource(Map), promiseCtorString = toSource(Promise$1), setCtorString = toSource(Set$1), weakMapCtorString = toSource(WeakMap);
+var getTag = baseGetTag;
+if (DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag$2 || Map && getTag(new Map()) != mapTag$3 || Promise$1 && getTag(Promise$1.resolve()) != promiseTag || Set$1 && getTag(new Set$1()) != setTag$3 || WeakMap && getTag(new WeakMap()) != weakMapTag$1) {
+  getTag = function(value) {
+    var result = baseGetTag(value), Ctor = result == objectTag$1 ? value.constructor : void 0, ctorString = Ctor ? toSource(Ctor) : "";
+    if (ctorString) {
+      switch (ctorString) {
+        case dataViewCtorString:
+          return dataViewTag$2;
+        case mapCtorString:
+          return mapTag$3;
+        case promiseCtorString:
+          return promiseTag;
+        case setCtorString:
+          return setTag$3;
+        case weakMapCtorString:
+          return weakMapTag$1;
+      }
+    }
+    return result;
+  };
+}
+var objectProto = Object.prototype;
+var hasOwnProperty = objectProto.hasOwnProperty;
+function initCloneArray(array) {
+  var length = array.length, result = new array.constructor(length);
+  if (length && typeof array[0] == "string" && hasOwnProperty.call(array, "index")) {
+    result.index = array.index;
+    result.input = array.input;
+  }
+  return result;
+}
+var Uint8Array2 = root.Uint8Array;
+function cloneArrayBuffer(arrayBuffer) {
+  var result = new arrayBuffer.constructor(arrayBuffer.byteLength);
+  new Uint8Array2(result).set(new Uint8Array2(arrayBuffer));
+  return result;
+}
+function cloneDataView(dataView, isDeep) {
+  var buffer = cloneArrayBuffer(dataView.buffer);
+  return new dataView.constructor(buffer, dataView.byteOffset, dataView.byteLength);
+}
+var reFlags = /\w*$/;
+function cloneRegExp(regexp) {
+  var result = new regexp.constructor(regexp.source, reFlags.exec(regexp));
+  result.lastIndex = regexp.lastIndex;
+  return result;
+}
+var symbolProto = Symbol$1 ? Symbol$1.prototype : void 0, symbolValueOf = symbolProto ? symbolProto.valueOf : void 0;
+function cloneSymbol(symbol) {
+  return symbolValueOf ? Object(symbolValueOf.call(symbol)) : {};
+}
+function cloneTypedArray(typedArray, isDeep) {
+  var buffer = cloneArrayBuffer(typedArray.buffer);
+  return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length);
+}
+var boolTag$1 = "[object Boolean]", dateTag$1 = "[object Date]", mapTag$2 = "[object Map]", numberTag$1 = "[object Number]", regexpTag$1 = "[object RegExp]", setTag$2 = "[object Set]", stringTag$1 = "[object String]", symbolTag$1 = "[object Symbol]";
+var arrayBufferTag$1 = "[object ArrayBuffer]", dataViewTag$1 = "[object DataView]", float32Tag$1 = "[object Float32Array]", float64Tag$1 = "[object Float64Array]", int8Tag$1 = "[object Int8Array]", int16Tag$1 = "[object Int16Array]", int32Tag$1 = "[object Int32Array]", uint8Tag$1 = "[object Uint8Array]", uint8ClampedTag$1 = "[object Uint8ClampedArray]", uint16Tag$1 = "[object Uint16Array]", uint32Tag$1 = "[object Uint32Array]";
+function initCloneByTag(object, tag, isDeep) {
+  var Ctor = object.constructor;
+  switch (tag) {
+    case arrayBufferTag$1:
+      return cloneArrayBuffer(object);
+    case boolTag$1:
+    case dateTag$1:
+      return new Ctor(+object);
+    case dataViewTag$1:
+      return cloneDataView(object);
+    case float32Tag$1:
+    case float64Tag$1:
+    case int8Tag$1:
+    case int16Tag$1:
+    case int32Tag$1:
+    case uint8Tag$1:
+    case uint8ClampedTag$1:
+    case uint16Tag$1:
+    case uint32Tag$1:
+      return cloneTypedArray(object);
+    case mapTag$2:
+      return new Ctor();
+    case numberTag$1:
+    case stringTag$1:
+      return new Ctor(object);
+    case regexpTag$1:
+      return cloneRegExp(object);
+    case setTag$2:
+      return new Ctor();
+    case symbolTag$1:
+      return cloneSymbol(object);
+  }
+}
+var objectCreate = Object.create;
+var baseCreate = /* @__PURE__ */ (function() {
+  function object() {
+  }
+  return function(proto) {
+    if (!isObject(proto)) {
+      return {};
+    }
+    if (objectCreate) {
+      return objectCreate(proto);
+    }
+    object.prototype = proto;
+    var result = new object();
+    object.prototype = void 0;
+    return result;
+  };
+})();
+function initCloneObject(object) {
+  return typeof object.constructor == "function" && !isPrototype(object) ? baseCreate(getPrototype(object)) : {};
+}
+var mapTag$1 = "[object Map]";
+function baseIsMap(value) {
+  return isObjectLike(value) && getTag(value) == mapTag$1;
+}
+var nodeIsMap = nodeUtil && nodeUtil.isMap;
+var isMap = nodeIsMap ? baseUnary(nodeIsMap) : baseIsMap;
+var setTag$1 = "[object Set]";
+function baseIsSet(value) {
+  return isObjectLike(value) && getTag(value) == setTag$1;
+}
+var nodeIsSet = nodeUtil && nodeUtil.isSet;
+var isSet = nodeIsSet ? baseUnary(nodeIsSet) : baseIsSet;
+var argsTag = "[object Arguments]", arrayTag = "[object Array]", boolTag = "[object Boolean]", dateTag = "[object Date]", errorTag = "[object Error]", funcTag = "[object Function]", genTag = "[object GeneratorFunction]", mapTag = "[object Map]", numberTag = "[object Number]", objectTag = "[object Object]", regexpTag = "[object RegExp]", setTag = "[object Set]", stringTag = "[object String]", symbolTag = "[object Symbol]", weakMapTag = "[object WeakMap]";
+var arrayBufferTag = "[object ArrayBuffer]", dataViewTag = "[object DataView]", float32Tag = "[object Float32Array]", float64Tag = "[object Float64Array]", int8Tag = "[object Int8Array]", int16Tag = "[object Int16Array]", int32Tag = "[object Int32Array]", uint8Tag = "[object Uint8Array]", uint8ClampedTag = "[object Uint8ClampedArray]", uint16Tag = "[object Uint16Array]", uint32Tag = "[object Uint32Array]";
+var cloneableTags = {};
+cloneableTags[argsTag] = cloneableTags[arrayTag] = cloneableTags[arrayBufferTag] = cloneableTags[dataViewTag] = cloneableTags[boolTag] = cloneableTags[dateTag] = cloneableTags[float32Tag] = cloneableTags[float64Tag] = cloneableTags[int8Tag] = cloneableTags[int16Tag] = cloneableTags[int32Tag] = cloneableTags[mapTag] = cloneableTags[numberTag] = cloneableTags[objectTag] = cloneableTags[regexpTag] = cloneableTags[setTag] = cloneableTags[stringTag] = cloneableTags[symbolTag] = cloneableTags[uint8Tag] = cloneableTags[uint8ClampedTag] = cloneableTags[uint16Tag] = cloneableTags[uint32Tag] = true;
+cloneableTags[errorTag] = cloneableTags[funcTag] = cloneableTags[weakMapTag] = false;
+function baseClone(value, bitmask, customizer, key, object, stack) {
+  var result;
+  if (result !== void 0) {
+    return result;
+  }
+  if (!isObject(value)) {
+    return value;
+  }
+  var isArr = isArray(value);
+  if (isArr) {
+    result = initCloneArray(value);
+  } else {
+    var tag = getTag(value), isFunc = tag == funcTag || tag == genTag;
+    if (isBuffer(value)) {
+      return cloneBuffer(value);
+    }
+    if (tag == objectTag || tag == argsTag || isFunc && !object) {
+      result = isFunc ? {} : initCloneObject(value);
+    } else {
+      if (!cloneableTags[tag]) {
+        return object ? value : {};
+      }
+      result = initCloneByTag(value, tag);
+    }
+  }
+  stack || (stack = new Stack());
+  var stacked = stack.get(value);
+  if (stacked) {
+    return stacked;
+  }
+  stack.set(value, result);
+  if (isSet(value)) {
+    value.forEach(function(subValue) {
+      result.add(baseClone(subValue, bitmask, customizer, subValue, value, stack));
+    });
+  } else if (isMap(value)) {
+    value.forEach(function(subValue, key2) {
+      result.set(key2, baseClone(subValue, bitmask, customizer, key2, value, stack));
+    });
+  }
+  var keysFunc = getAllKeys;
+  var props = isArr ? void 0 : keysFunc(value);
+  arrayEach(props || value, function(subValue, key2) {
+    if (props) {
+      key2 = subValue;
+      subValue = value[key2];
+    }
+    assignValue(result, key2, baseClone(subValue, bitmask, customizer, key2, value, stack));
+  });
+  return result;
+}
+var CLONE_DEEP_FLAG = 1, CLONE_SYMBOLS_FLAG = 4;
+function cloneDeep(value) {
+  return baseClone(value, CLONE_DEEP_FLAG | CLONE_SYMBOLS_FLAG);
+}
+const _hoisted_1 = {
+  key: 0,
+  class: "select-tree-normal-value"
+};
+const _hoisted_2 = { class: "max-h-[280px] overflow-y-auto" };
+const _hoisted_3 = { class: "select-tree-normal-placeholder cursor-default" };
+const _hoisted_4 = ["disabled", "placeholder"];
+const _hoisted_5 = ["title"];
+const MIN_POPOVER_WIDTH = 120;
+const TREE_NODE_PADDING = 56;
+const TREE_LEVEL_INDENT = 18;
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "SelectTree",
+  props: {
+    modelValue: {},
+    placeholder: { default: "请选择" },
+    data: {},
+    checkoutAll: { type: Boolean, default: true },
+    multiple: { type: Boolean, default: true },
+    disabled: { type: Boolean, default: false },
+    props: {},
+    height: {},
+    width: {},
+    calcWidth: {},
+    filter: {},
+    wrapclass: {},
+    inputClass: {},
+    selectAllNode: { type: Boolean, default: false }
+  },
+  emits: ["update:modelValue", "change", "visible-change"],
+  setup(__props, { expose: __expose, emit: __emit }) {
+    const emit = __emit;
+    const prop = __props;
+    const options = ref([]);
+    const inputRef = ref(null);
+    const labelKey = computed(() => {
+      var _a;
+      return ((_a = prop.props) == null ? void 0 : _a.label) || "label";
+    });
+    const popoverWidth = ref(MIN_POPOVER_WIDTH);
+    const referenceStyle = computed(() => {
+      const width = prop.calcWidth || prop.width;
+      const normalizedWidth = normalizeCssWidth(width);
+      if (!normalizedWidth) {
+        return void 0;
+      }
+      return {
+        width: normalizedWidth
+      };
+    });
+    const wrapperWidthStyle = computed(() => {
+      if (prop.calcWidth) {
+        return "100%";
+      }
+      return normalizeCssWidth(prop.width);
+    });
+    const normalizeCssWidth = (width) => {
+      if (width === void 0 || width === null || width === "") {
+        return void 0;
+      }
+      if (typeof width === "number") {
+        return `${width}px`;
+      }
+      return /^\d+(\.\d+)?$/.test(width) ? `${width}px` : width;
+    };
+    const getNumericWidth = (width) => {
+      if (typeof width === "number") {
+        return width;
+      }
+      if (typeof width !== "string") {
+        return 0;
+      }
+      const parsedWidth = Number.parseFloat(width);
+      return Number.isFinite(parsedWidth) ? parsedWidth : 0;
+    };
+    let measureCanvas = null;
+    let cachedFont = "";
+    let cachedCtx = null;
+    const ensureMeasureContext = () => {
+      if (cachedCtx) return cachedCtx;
+      if (typeof document === "undefined") return null;
+      measureCanvas || (measureCanvas = document.createElement("canvas"));
+      cachedCtx = measureCanvas.getContext("2d");
+      return cachedCtx;
+    };
+    const refreshMeasureFont = () => {
+      if (typeof window === "undefined" || !inputRef.value) {
+        cachedFont = "14px sans-serif";
+        return;
+      }
+      const style = window.getComputedStyle(inputRef.value);
+      cachedFont = style.font || `${style.fontWeight} ${style.fontSize} ${style.fontFamily}`;
+    };
+    const getOptionLabel = (item) => {
+      const label = item == null ? void 0 : item[labelKey.value];
+      return label === void 0 || label === null ? "" : String(label);
+    };
+    const getMaxOptionWidth = (list = []) => {
+      let longest = "";
+      let longestDepth = 0;
+      const walk = (nodes, depth) => {
+        for (let i = 0; i < nodes.length; i++) {
+          const item = nodes[i];
+          const text = getOptionLabel(item);
+          const score = text.length + depth * 2;
+          const bestScore = longest.length + longestDepth * 2;
+          if (score > bestScore) {
+            longest = text;
+            longestDepth = depth;
+          }
+          if (Array.isArray(item == null ? void 0 : item.children)) {
+            walk(item.children, depth + 1);
+          }
+        }
+      };
+      walk(list, 0);
+      if (!longest) return 0;
+      const ctx = ensureMeasureContext();
+      if (!ctx) return longest.length * 14;
+      ctx.font = cachedFont;
+      const textWidth = Math.ceil(ctx.measureText(longest).width);
+      return textWidth + TREE_NODE_PADDING + longestDepth * TREE_LEVEL_INDENT + (prop.multiple ? 24 : 0);
+    };
+    let updateTimer = null;
+    const updatePopoverWidth = () => {
+      if (updateTimer) return;
+      updateTimer = setTimeout(() => {
+        updateTimer = null;
+        refreshMeasureFont();
+        const baseWidth = Math.max(getNumericWidth(prop.width), getNumericWidth(prop.calcWidth));
+        popoverWidth.value = Math.max(MIN_POPOVER_WIDTH, baseWidth, getMaxOptionWidth(options.value));
+      }, 0);
+    };
+    const defaultFilter = (query, node) => {
+      var _a, _b;
+      const label = labelKey.value;
+      return ((_a = (node[label] || "").toLowerCase()) == null ? void 0 : _a.includes(query.toLowerCase())) || ((_b = node.searchKey || "") == null ? void 0 : _b.toLocaleLowerCase().includes(query.toLowerCase()));
+    };
+    const isFocused = ref(false);
+    const tree = ref(null);
+    const checkedKeys = ref([]);
+    const _checkedNodes = ref([]);
+    const checkedNodes = ref([]);
+    const filterText = ref("");
+    const allSelected = ref(false);
+    const curLable = ref("");
+    watch(isFocused, (value) => {
+      tree.value.setExpandedKeys([]);
+      emit("visible-change", isFocused.value);
+      if (!value) {
+        filterText.value = "";
+        inputRef.value.blur();
+        if (tree.value) {
+          tree.value.filter("");
+        }
+      } else {
+        inputRef.value.focus();
+      }
+      if (prop.multiple) {
+        return;
+      }
+      filterText.value = curLable.value;
+      tree.value.filter("");
+    });
+    const filterHandle = (query) => {
+      tree.value.filter(query.target.value);
+    };
+    const currentChangeHandle = (e) => {
+      if (prop.multiple) {
+        return;
+      }
+      if (e.children) {
+        return;
+      }
+      curLable.value = e[prop.props && prop.props.label || "label"];
+      filterText.value = e[prop.props && prop.props.label || "label"];
+      isFocused.value = false;
+      emit("update:modelValue", e[valueKey.value]);
+      emit("change", e[valueKey.value], tree.value.getCheckedNodes());
+    };
+    const valueKey = computed(() => {
+      if (prop.props && prop.props.value) {
+        return prop.props.value;
+      }
+      return "id";
+    });
+    const closeHandle = (node) => {
+      tree.value.setChecked(node[valueKey.value], false);
+      setCurNodeData({
+        checkedKeys: tree.value.getCheckedKeys(),
+        checkedNodes: tree.value.getCheckedNodes()
+      });
+      emit(
+        "update:modelValue",
+        checkedNodes.value.map((item) => item[valueKey.value])
+      );
+      emit(
+        "change",
+        checkedNodes.value.map((item) => item[valueKey.value]),
+        tree.value.getCheckedNodes()
+      );
+    };
+    const setCurNodeData = (info) => {
+      checkedKeys.value = info.checkedKeys;
+      _checkedNodes.value = info.checkedNodes;
+      checkedNodes.value = info.checkedNodes.filter((item) => !item.children);
+    };
+    const checkHandle = (e, ee) => {
+      if (prop.multiple) {
+        inputRef.value.focus();
+      }
+      if (!prop.selectAllNode && e && e.children && filterText.value) {
+        const cc = e.children.filter((item) => (prop.filter || defaultFilter)(filterText.value, item)).map((ci) => ci[valueKey.value]);
+        if (!cc.length) {
+          initMultipleData();
+          return;
+        }
+        const checkedSet = new Set(checkedKeys.value);
+        const isCheck = !checkedSet.has(cc[0]);
+        const ccSet = new Set(cc);
+        const val = isCheck ? [...checkedNodes.value.map((item) => item[valueKey.value]), ...cc] : checkedNodes.value.map((item) => item[valueKey.value]).filter((cn) => !ccSet.has(cn));
+        emit("update:modelValue", val);
+        emit("change", val, tree.value.getCheckedNodes());
+        return;
+      }
+      setCurNodeData(ee);
+      emit(
+        "update:modelValue",
+        checkedNodes.value.map((item) => item[valueKey.value])
+      );
+      emit(
+        "change",
+        checkedNodes.value.map((item) => item[valueKey.value]),
+        tree.value.getCheckedNodes()
+      );
+    };
+    watch(allSelected, () => {
+      var _a;
+      if (allSelected.value) {
+        let ids = [];
+        let valids = [];
+        options.value.forEach((item) => {
+          if (prop.selectAllNode && (prop.filter || defaultFilter)(filterText.value, item)) {
+            const { children } = item;
+            ids.push(item[valueKey.value]);
+            ids = ids.concat(children.map((child) => child[valueKey.value]));
+            valids = valids.concat(children.map((child) => child[valueKey.value]));
+          } else {
+            const { children } = item;
+            const cids = [];
+            let isAllCheck = true;
+            children.forEach((child) => {
+              const isCheck = (prop.filter || defaultFilter)(filterText.value, child);
+              if (isCheck) {
+                cids.push(child[valueKey.value]);
+              } else {
+                isAllCheck = false;
+              }
+            });
+            isAllCheck && ids.push(item[valueKey.value]);
+            ids = ids.concat(cids);
+            valids = valids.concat(cids);
+          }
+        });
+        emit("update:modelValue", valids);
+        emit("change", valids, tree.value.getCheckedNodes());
+      } else {
+        (_a = tree.value) == null ? void 0 : _a.setCheckedKeys([]);
+        checkedKeys.value = [];
+        _checkedNodes.value = [];
+        checkedNodes.value = [];
+        emit(
+          "update:modelValue",
+          checkedNodes.value.map((item) => item[valueKey.value])
+        );
+        emit(
+          "change",
+          checkedNodes.value.map((item) => item[valueKey.value]),
+          tree.value.getCheckedNodes()
+        );
+      }
+    });
+    const clearCheaked = () => {
+      var _a;
+      if (!prop.multiple) {
+        curLable.value = "";
+        filterText.value = "";
+        emit("update:modelValue", "");
+        emit("change", "", tree.value.getCheckedNodes());
+        return;
+      }
+      (_a = tree.value) == null ? void 0 : _a.setCheckedKeys([]);
+      checkedKeys.value = [];
+      _checkedNodes.value = [];
+      checkedNodes.value = [];
+      allSelected.value = false;
+      emit(
+        "update:modelValue",
+        checkedNodes.value.map((item) => item[valueKey.value])
+      );
+      emit(
+        "change",
+        checkedNodes.value.map((item) => item[valueKey.value]),
+        tree.value.getCheckedNodes()
+      );
+    };
+    const initMultipleData = () => __async(null, null, function* () {
+      var _a;
+      if (prop.multiple) {
+        const ids = [...prop.modelValue || []];
+        (_a = tree.value) == null ? void 0 : _a.setCheckedKeys([...ids]);
+        yield nextTick();
+        setCurNodeData({
+          checkedKeys: tree.value.getCheckedKeys(),
+          checkedNodes: tree.value.getCheckedNodes()
+        });
+      }
+    });
+    const cloneTreeData = (data) => {
+      const rawData = toRaw(data);
+      if (!Array.isArray(rawData)) {
+        return [];
+      }
+      try {
+        return structuredClone(rawData);
+      } catch (e) {
+        return cloneDeep(rawData);
+      }
+    };
+    watch(
+      () => prop.data,
+      () => __async(null, null, function* () {
+        options.value = cloneTreeData(prop.data);
+        yield nextTick();
+        setFilterText();
+        initMultipleData();
+        updatePopoverWidth();
+      })
+    );
+    watch(
+      () => [prop.width, prop.calcWidth, prop.multiple, labelKey.value],
+      () => {
+        updatePopoverWidth();
+      }
+    );
+    const setFilterText = () => {
+      if (!options.value.length || prop.multiple) {
+        return;
+      }
+      if (prop.modelValue === null || !String(prop.modelValue)) {
+        return filterText.value = "";
+      }
+      getVal(options.value, prop.modelValue);
+    };
+    const getVal = (data, val) => {
+      data.forEach((item) => {
+        if (item.children) {
+          return getVal(item.children, val);
+        }
+        item.id === val && (filterText.value = item[prop.props && prop.props.label || "label"]);
+      });
+    };
+    const togglePopperVisible = (visibleStatus) => {
+      isFocused.value = visibleStatus;
+    };
+    __expose({
+      clearCheaked,
+      togglePopperVisible
+    });
+    const getStringify = (e) => {
+      try {
+        return JSON.stringify(e);
+      } catch (e2) {
+        return e;
+      }
+    };
+    watch(
+      () => prop.modelValue,
+      (e, e1) => __async(null, null, function* () {
+        const _e = getStringify(e);
+        const _e1 = getStringify(e1);
+        if (_e === _e1) {
+          return;
+        }
+        yield nextTick();
+        setFilterText();
+        initMultipleData();
+      })
+    );
+    onMounted(() => __async(null, null, function* () {
+      yield nextTick();
+      options.value = cloneTreeData(prop.data);
+      setFilterText();
+      updatePopoverWidth();
+      setTimeout(() => {
+        initMultipleData();
+      });
+    }));
+    return (_ctx, _cache) => {
+      const _component_el_tag = ElTag;
+      const _component_DynamicScrollerItem = resolveComponent("DynamicScrollerItem");
+      const _component_DynamicScroller = resolveComponent("DynamicScroller");
+      const _component_LazyPopover = _sfc_main$1;
+      const _component_ArrowDown = resolveComponent("ArrowDown");
+      const _component_el_icon = ElIcon;
+      const _component_CircleClose = resolveComponent("CircleClose");
+      const _component_el_tree_v2 = ElTreeV2;
+      const _component_el_popover = ElPopover;
+      return openBlock(), createBlock(_component_el_popover, {
+        visible: isFocused.value,
+        "onUpdate:visible": _cache[4] || (_cache[4] = ($event) => isFocused.value = $event),
+        disabled: __props.disabled,
+        placement: "bottom",
+        trigger: "click",
+        width: popoverWidth.value
+      }, {
+        reference: withCtx(() => [
+          createElementVNode("div", {
+            class: normalizeClass(["select-tree", __props.wrapclass]),
+            style: normalizeStyle(referenceStyle.value)
+          }, [
+            createElementVNode("div", {
+              class: normalizeClass(["select-tree-wrapper", { "is-focused": isFocused.value }]),
+              style: normalizeStyle({ width: wrapperWidthStyle.value, backgroundColor: __props.disabled ? "#F5F9FF" : "" })
+            }, [
+              checkedNodes.value.length ? (openBlock(), createElementBlock("div", _hoisted_1, [
+                createVNode(_component_el_tag, {
+                  class: "m-val-tag mx-[5px]",
+                  type: "info",
+                  title: checkedNodes.value[0][__props.props && __props.props.label || "label"],
+                  closable: "",
+                  onClose: _cache[0] || (_cache[0] = ($event) => closeHandle(checkedNodes.value[0]))
+                }, {
+                  default: withCtx(() => [
+                    createTextVNode(toDisplayString(checkedNodes.value[0][__props.props && __props.props.label || "label"]), 1)
+                  ]),
+                  _: 1
+                }, 8, ["title"]),
+                checkedNodes.value.length > 1 ? (openBlock(), createBlock(_component_LazyPopover, {
+                  key: 0,
+                  width: `${popoverWidth.value}px`
+                }, {
+                  reference: withCtx(() => [
+                    createVNode(_component_el_tag, { type: "info" }, {
+                      default: withCtx(() => [
+                        createTextVNode("+ " + toDisplayString(checkedNodes.value.length - 1), 1)
+                      ]),
+                      _: 1
+                    })
+                  ]),
+                  default: withCtx(() => [
+                    createElementVNode("div", _hoisted_2, [
+                      createVNode(_component_DynamicScroller, {
+                        ref: "DynamicScrollerRef",
+                        class: "dynamic-scroller-ref",
+                        style: { height: "280px" },
+                        keyField: valueKey.value,
+                        items: checkedNodes.value.filter((_, index) => index !== 0),
+                        "min-item-size": 20
+                      }, {
+                        default: withCtx(({ item, index, active }) => [
+                          createVNode(_component_DynamicScrollerItem, {
+                            item,
+                            active,
+                            "data-index": index
+                          }, {
+                            default: withCtx(() => [
+                              createVNode(_component_el_tag, {
+                                class: "mr-[5px] mt-[5px]",
+                                closable: "",
+                                onClose: ($event) => closeHandle(item)
+                              }, {
+                                default: withCtx(() => [
+                                  createTextVNode(toDisplayString(item[__props.props && __props.props.label || "label"]), 1)
+                                ]),
+                                _: 2
+                              }, 1032, ["onClose"])
+                            ]),
+                            _: 2
+                          }, 1032, ["item", "active", "data-index"])
+                        ]),
+                        _: 1
+                      }, 8, ["keyField", "items"])
+                    ])
+                  ]),
+                  _: 1
+                }, 8, ["width"])) : createCommentVNode("", true)
+              ])) : createCommentVNode("", true),
+              createElementVNode("div", _hoisted_3, [
+                withDirectives(createElementVNode("input", {
+                  ref_key: "inputRef",
+                  ref: inputRef,
+                  "onUpdate:modelValue": _cache[1] || (_cache[1] = ($event) => filterText.value = $event),
+                  class: normalizeClass(__props.inputClass),
+                  disabled: __props.disabled,
+                  style: { "height": "24px" },
+                  type: "text",
+                  placeholder: __props.placeholder,
+                  onKeydown: _cache[2] || (_cache[2] = withModifiers(() => {
+                  }, ["stop"])),
+                  onInput: filterHandle
+                }, null, 42, _hoisted_4), [
+                  [vModelText, filterText.value]
+                ])
+              ]),
+              createElementVNode("div", {
+                class: normalizeClass(["select-tree-arrow", { "is-focused": isFocused.value }])
+              }, [
+                createVNode(_component_el_icon, null, {
+                  default: withCtx(() => [
+                    createVNode(_component_ArrowDown)
+                  ]),
+                  _: 1
+                })
+              ], 2),
+              !__props.disabled && (__props.multiple && checkedNodes.value.length || !__props.multiple && __props.modelValue) ? (openBlock(), createElementBlock("div", {
+                key: 1,
+                class: "select-tree-clear",
+                onClick: withModifiers(clearCheaked, ["stop"])
+              }, [
+                createVNode(_component_el_icon, null, {
+                  default: withCtx(() => [
+                    createVNode(_component_CircleClose)
+                  ]),
+                  _: 1
+                })
+              ])) : createCommentVNode("", true)
+            ], 6)
+          ], 6)
+        ]),
+        default: withCtx(() => [
+          __props.multiple && __props.checkoutAll ? (openBlock(), createElementBlock("div", {
+            key: 0,
+            class: "px-[10px] pb-[10px] border-b-[1px] mb-[5px] border-b-[#f5f5f5] cursor-pointer",
+            onClick: _cache[3] || (_cache[3] = ($event) => allSelected.value = !allSelected.value)
+          }, toDisplayString(allSelected.value ? "全部取消" : "全部选择当前"), 1)) : createCommentVNode("", true),
+          createVNode(_component_el_tree_v2, {
+            ref_key: "tree",
+            ref: tree,
+            style: { "width": "100%" },
+            class: "custom-select-tree-box",
+            data: options.value,
+            props: __props.props,
+            "show-checkbox": __props.multiple,
+            height: __props.height,
+            "filter-method": __props.filter || defaultFilter,
+            onNodeClick: currentChangeHandle,
+            onCheck: checkHandle
+          }, {
+            default: withCtx(({ node }) => [
+              createElementVNode("span", {
+                title: node.label
+              }, toDisplayString(node.label), 9, _hoisted_5)
+            ]),
+            _: 1
+          }, 8, ["data", "props", "show-checkbox", "height", "filter-method"])
+        ]),
+        _: 1
+      }, 8, ["visible", "disabled", "width"]);
+    };
+  }
+});
+const SelectTree = /* @__PURE__ */ _export_sfc(_sfc_main, [["__scopeId", "data-v-68f09ab5"]]);
+export {
+  SelectTree as S
+};