xiaoshan/public/assets/addons/shopro/libs/element-plus/index.js

/*! Element Plus v2.2.21 */

(function (global, factory) {
    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('vue')) :
    typeof define === 'function' && define.amd ? define(['exports', 'vue'], factory) :
    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.ElementPlus = {}, global.Vue));
  })(this, (function (exports, vue) { 'use strict';
  
    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$s = Object.prototype;
    var hasOwnProperty$p = objectProto$s.hasOwnProperty;
    var nativeObjectToString$3 = objectProto$s.toString;
    var symToStringTag$1 = Symbol$1 ? Symbol$1.toStringTag : void 0;
    function getRawTag(value) {
      var isOwn = hasOwnProperty$p.call(value, symToStringTag$1), tag = value[symToStringTag$1];
      try {
        value[symToStringTag$1] = void 0;
        var unmasked = true;
      } catch (e) {
      }
      var result = nativeObjectToString$3.call(value);
      if (unmasked) {
        if (isOwn) {
          value[symToStringTag$1] = tag;
        } else {
          delete value[symToStringTag$1];
        }
      }
      return result;
    }
  
    var objectProto$r = Object.prototype;
    var nativeObjectToString$2 = objectProto$r.toString;
    function objectToString$1(value) {
      return nativeObjectToString$2.call(value);
    }
  
    var nullTag = "[object Null]";
    var 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$1(value);
    }
  
    function isObjectLike(value) {
      return value != null && typeof value == "object";
    }
  
    var symbolTag$3 = "[object Symbol]";
    function isSymbol(value) {
      return typeof value == "symbol" || isObjectLike(value) && baseGetTag(value) == symbolTag$3;
    }
  
    var NAN$2 = 0 / 0;
    function baseToNumber(value) {
      if (typeof value == "number") {
        return value;
      }
      if (isSymbol(value)) {
        return NAN$2;
      }
      return +value;
    }
  
    function arrayMap(array, iteratee) {
      var index = -1, length = array == null ? 0 : array.length, result = Array(length);
      while (++index < length) {
        result[index] = iteratee(array[index], index, array);
      }
      return result;
    }
  
    var isArray$1 = Array.isArray;
  
    var INFINITY$5 = 1 / 0;
    var symbolProto$2 = Symbol$1 ? Symbol$1.prototype : void 0;
    var symbolToString = symbolProto$2 ? symbolProto$2.toString : void 0;
    function baseToString(value) {
      if (typeof value == "string") {
        return value;
      }
      if (isArray$1(value)) {
        return arrayMap(value, baseToString) + "";
      }
      if (isSymbol(value)) {
        return symbolToString ? symbolToString.call(value) : "";
      }
      var result = value + "";
      return result == "0" && 1 / value == -INFINITY$5 ? "-0" : result;
    }
  
    function createMathOperation(operator, defaultValue) {
      return function(value, other) {
        var result;
        if (value === void 0 && other === void 0) {
          return defaultValue;
        }
        if (value !== void 0) {
          result = value;
        }
        if (other !== void 0) {
          if (result === void 0) {
            return other;
          }
          if (typeof value == "string" || typeof other == "string") {
            value = baseToString(value);
            other = baseToString(other);
          } else {
            value = baseToNumber(value);
            other = baseToNumber(other);
          }
          result = operator(value, other);
        }
        return result;
      };
    }
  
    var add = createMathOperation(function(augend, addend) {
      return augend + addend;
    }, 0);
  
    var reWhitespace = /\s/;
    function trimmedEndIndex(string) {
      var index = string.length;
      while (index-- && reWhitespace.test(string.charAt(index))) {
      }
      return index;
    }
  
    var reTrimStart$2 = /^\s+/;
    function baseTrim(string) {
      return string ? string.slice(0, trimmedEndIndex(string) + 1).replace(reTrimStart$2, "") : string;
    }
  
    function isObject$2(value) {
      var type = typeof value;
      return value != null && (type == "object" || type == "function");
    }
  
    var NAN$1 = 0 / 0;
    var reIsBadHex = /^[-+]0x[0-9a-f]+$/i;
    var reIsBinary = /^0b[01]+$/i;
    var reIsOctal = /^0o[0-7]+$/i;
    var freeParseInt = parseInt;
    function toNumber(value) {
      if (typeof value == "number") {
        return value;
      }
      if (isSymbol(value)) {
        return NAN$1;
      }
      if (isObject$2(value)) {
        var other = typeof value.valueOf == "function" ? value.valueOf() : value;
        value = isObject$2(other) ? other + "" : other;
      }
      if (typeof value != "string") {
        return value === 0 ? value : +value;
      }
      value = baseTrim(value);
      var isBinary = reIsBinary.test(value);
      return isBinary || reIsOctal.test(value) ? freeParseInt(value.slice(2), isBinary ? 2 : 8) : reIsBadHex.test(value) ? NAN$1 : +value;
    }
  
    var INFINITY$4 = 1 / 0;
    var MAX_INTEGER = 17976931348623157e292;
    function toFinite(value) {
      if (!value) {
        return value === 0 ? value : 0;
      }
      value = toNumber(value);
      if (value === INFINITY$4 || value === -INFINITY$4) {
        var sign = value < 0 ? -1 : 1;
        return sign * MAX_INTEGER;
      }
      return value === value ? value : 0;
    }
  
    function toInteger(value) {
      var result = toFinite(value), remainder = result % 1;
      return result === result ? remainder ? result - remainder : result : 0;
    }
  
    var FUNC_ERROR_TEXT$b = "Expected a function";
    function after(n, func) {
      if (typeof func != "function") {
        throw new TypeError(FUNC_ERROR_TEXT$b);
      }
      n = toInteger(n);
      return function() {
        if (--n < 1) {
          return func.apply(this, arguments);
        }
      };
    }
  
    function identity$1(value) {
      return value;
    }
  
    var asyncTag = "[object AsyncFunction]";
    var funcTag$2 = "[object Function]";
    var genTag$1 = "[object GeneratorFunction]";
    var proxyTag = "[object Proxy]";
    function isFunction$1(value) {
      if (!isObject$2(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$2 = Function.prototype;
    var funcToString$2 = funcProto$2.toString;
    function toSource(func) {
      if (func != null) {
        try {
          return funcToString$2.call(func);
        } catch (e) {
        }
        try {
          return func + "";
        } catch (e) {
        }
      }
      return "";
    }
  
    var reRegExpChar$1 = /[\\^$.*+?()[\]{}|]/g;
    var reIsHostCtor = /^\[object .+?Constructor\]$/;
    var funcProto$1 = Function.prototype;
    var objectProto$q = Object.prototype;
    var funcToString$1 = funcProto$1.toString;
    var hasOwnProperty$o = objectProto$q.hasOwnProperty;
    var reIsNative = RegExp("^" + funcToString$1.call(hasOwnProperty$o).replace(reRegExpChar$1, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$");
    function baseIsNative(value) {
      if (!isObject$2(value) || isMasked(value)) {
        return false;
      }
      var pattern = isFunction$1(value) ? reIsNative : reIsHostCtor;
      return pattern.test(toSource(value));
    }
  
    function getValue$1(object, key) {
      return object == null ? void 0 : object[key];
    }
  
    function getNative(object, key) {
      var value = getValue$1(object, key);
      return baseIsNative(value) ? value : void 0;
    }
  
    var WeakMap = getNative(root, "WeakMap");
  
    var metaMap = WeakMap && new WeakMap();
  
    var baseSetData = !metaMap ? identity$1 : function(func, data) {
      metaMap.set(func, data);
      return func;
    };
  
    var objectCreate = Object.create;
    var baseCreate = function() {
      function object() {
      }
      return function(proto) {
        if (!isObject$2(proto)) {
          return {};
        }
        if (objectCreate) {
          return objectCreate(proto);
        }
        object.prototype = proto;
        var result = new object();
        object.prototype = void 0;
        return result;
      };
    }();
  
    function createCtor(Ctor) {
      return function() {
        var args = arguments;
        switch (args.length) {
          case 0:
            return new Ctor();
          case 1:
            return new Ctor(args[0]);
          case 2:
            return new Ctor(args[0], args[1]);
          case 3:
            return new Ctor(args[0], args[1], args[2]);
          case 4:
            return new Ctor(args[0], args[1], args[2], args[3]);
          case 5:
            return new Ctor(args[0], args[1], args[2], args[3], args[4]);
          case 6:
            return new Ctor(args[0], args[1], args[2], args[3], args[4], args[5]);
          case 7:
            return new Ctor(args[0], args[1], args[2], args[3], args[4], args[5], args[6]);
        }
        var thisBinding = baseCreate(Ctor.prototype), result = Ctor.apply(thisBinding, args);
        return isObject$2(result) ? result : thisBinding;
      };
    }
  
    var WRAP_BIND_FLAG$8 = 1;
    function createBind(func, bitmask, thisArg) {
      var isBind = bitmask & WRAP_BIND_FLAG$8, Ctor = createCtor(func);
      function wrapper() {
        var fn = this && this !== root && this instanceof wrapper ? Ctor : func;
        return fn.apply(isBind ? thisArg : this, arguments);
      }
      return wrapper;
    }
  
    function apply(func, thisArg, args) {
      switch (args.length) {
        case 0:
          return func.call(thisArg);
        case 1:
          return func.call(thisArg, args[0]);
        case 2:
          return func.call(thisArg, args[0], args[1]);
        case 3:
          return func.call(thisArg, args[0], args[1], args[2]);
      }
      return func.apply(thisArg, args);
    }
  
    var nativeMax$g = Math.max;
    function composeArgs(args, partials, holders, isCurried) {
      var argsIndex = -1, argsLength = args.length, holdersLength = holders.length, leftIndex = -1, leftLength = partials.length, rangeLength = nativeMax$g(argsLength - holdersLength, 0), result = Array(leftLength + rangeLength), isUncurried = !isCurried;
      while (++leftIndex < leftLength) {
        result[leftIndex] = partials[leftIndex];
      }
      while (++argsIndex < holdersLength) {
        if (isUncurried || argsIndex < argsLength) {
          result[holders[argsIndex]] = args[argsIndex];
        }
      }
      while (rangeLength--) {
        result[leftIndex++] = args[argsIndex++];
      }
      return result;
    }
  
    var nativeMax$f = Math.max;
    function composeArgsRight(args, partials, holders, isCurried) {
      var argsIndex = -1, argsLength = args.length, holdersIndex = -1, holdersLength = holders.length, rightIndex = -1, rightLength = partials.length, rangeLength = nativeMax$f(argsLength - holdersLength, 0), result = Array(rangeLength + rightLength), isUncurried = !isCurried;
      while (++argsIndex < rangeLength) {
        result[argsIndex] = args[argsIndex];
      }
      var offset = argsIndex;
      while (++rightIndex < rightLength) {
        result[offset + rightIndex] = partials[rightIndex];
      }
      while (++holdersIndex < holdersLength) {
        if (isUncurried || argsIndex < argsLength) {
          result[offset + holders[holdersIndex]] = args[argsIndex++];
        }
      }
      return result;
    }
  
    function countHolders(array, placeholder) {
      var length = array.length, result = 0;
      while (length--) {
        if (array[length] === placeholder) {
          ++result;
        }
      }
      return result;
    }
  
    function baseLodash() {
    }
  
    var MAX_ARRAY_LENGTH$6 = 4294967295;
    function LazyWrapper(value) {
      this.__wrapped__ = value;
      this.__actions__ = [];
      this.__dir__ = 1;
      this.__filtered__ = false;
      this.__iteratees__ = [];
      this.__takeCount__ = MAX_ARRAY_LENGTH$6;
      this.__views__ = [];
    }
    LazyWrapper.prototype = baseCreate(baseLodash.prototype);
    LazyWrapper.prototype.constructor = LazyWrapper;
  
    function noop$1() {
    }
  
    var getData = !metaMap ? noop$1 : function(func) {
      return metaMap.get(func);
    };
  
    var realNames = {};
  
    var objectProto$p = Object.prototype;
    var hasOwnProperty$n = objectProto$p.hasOwnProperty;
    function getFuncName(func) {
      var result = func.name + "", array = realNames[result], length = hasOwnProperty$n.call(realNames, result) ? array.length : 0;
      while (length--) {
        var data = array[length], otherFunc = data.func;
        if (otherFunc == null || otherFunc == func) {
          return data.name;
        }
      }
      return result;
    }
  
    function LodashWrapper(value, chainAll) {
      this.__wrapped__ = value;
      this.__actions__ = [];
      this.__chain__ = !!chainAll;
      this.__index__ = 0;
      this.__values__ = void 0;
    }
    LodashWrapper.prototype = baseCreate(baseLodash.prototype);
    LodashWrapper.prototype.constructor = LodashWrapper;
  
    function copyArray(source, array) {
      var index = -1, length = source.length;
      array || (array = Array(length));
      while (++index < length) {
        array[index] = source[index];
      }
      return array;
    }
  
    function wrapperClone(wrapper) {
      if (wrapper instanceof LazyWrapper) {
        return wrapper.clone();
      }
      var result = new LodashWrapper(wrapper.__wrapped__, wrapper.__chain__);
      result.__actions__ = copyArray(wrapper.__actions__);
      result.__index__ = wrapper.__index__;
      result.__values__ = wrapper.__values__;
      return result;
    }
  
    var objectProto$o = Object.prototype;
    var hasOwnProperty$m = objectProto$o.hasOwnProperty;
    function lodash(value) {
      if (isObjectLike(value) && !isArray$1(value) && !(value instanceof LazyWrapper)) {
        if (value instanceof LodashWrapper) {
          return value;
        }
        if (hasOwnProperty$m.call(value, "__wrapped__")) {
          return wrapperClone(value);
        }
      }
      return new LodashWrapper(value);
    }
    lodash.prototype = baseLodash.prototype;
    lodash.prototype.constructor = lodash;
  
    function isLaziable(func) {
      var funcName = getFuncName(func), other = lodash[funcName];
      if (typeof other != "function" || !(funcName in LazyWrapper.prototype)) {
        return false;
      }
      if (func === other) {
        return true;
      }
      var data = getData(other);
      return !!data && func === data[0];
    }
  
    var HOT_COUNT = 800;
    var HOT_SPAN = 16;
    var nativeNow = Date.now;
    function shortOut(func) {
      var count = 0, lastCalled = 0;
      return function() {
        var stamp = nativeNow(), remaining = HOT_SPAN - (stamp - lastCalled);
        lastCalled = stamp;
        if (remaining > 0) {
          if (++count >= HOT_COUNT) {
            return arguments[0];
          }
        } else {
          count = 0;
        }
        return func.apply(void 0, arguments);
      };
    }
  
    var setData = shortOut(baseSetData);
  
    var reWrapDetails = /\{\n\/\* \[wrapped with (.+)\] \*/;
    var reSplitDetails = /,? & /;
    function getWrapDetails(source) {
      var match = source.match(reWrapDetails);
      return match ? match[1].split(reSplitDetails) : [];
    }
  
    var reWrapComment = /\{(?:\n\/\* \[wrapped with .+\] \*\/)?\n?/;
    function insertWrapDetails(source, details) {
      var length = details.length;
      if (!length) {
        return source;
      }
      var lastIndex = length - 1;
      details[lastIndex] = (length > 1 ? "& " : "") + details[lastIndex];
      details = details.join(length > 2 ? ", " : " ");
      return source.replace(reWrapComment, "{\n/* [wrapped with " + details + "] */\n");
    }
  
    function constant(value) {
      return function() {
        return value;
      };
    }
  
    var defineProperty = function() {
      try {
        var func = getNative(Object, "defineProperty");
        func({}, "", {});
        return func;
      } catch (e) {
      }
    }();
  
    var baseSetToString = !defineProperty ? identity$1 : function(func, string) {
      return defineProperty(func, "toString", {
        "configurable": true,
        "enumerable": false,
        "value": constant(string),
        "writable": true
      });
    };
  
    var setToString = shortOut(baseSetToString);
  
    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;
    }
  
    function baseFindIndex(array, predicate, fromIndex, fromRight) {
      var length = array.length, index = fromIndex + (fromRight ? 1 : -1);
      while (fromRight ? index-- : ++index < length) {
        if (predicate(array[index], index, array)) {
          return index;
        }
      }
      return -1;
    }
  
    function baseIsNaN(value) {
      return value !== value;
    }
  
    function strictIndexOf(array, value, fromIndex) {
      var index = fromIndex - 1, length = array.length;
      while (++index < length) {
        if (array[index] === value) {
          return index;
        }
      }
      return -1;
    }
  
    function baseIndexOf(array, value, fromIndex) {
      return value === value ? strictIndexOf(array, value, fromIndex) : baseFindIndex(array, baseIsNaN, fromIndex);
    }
  
    function arrayIncludes(array, value) {
      var length = array == null ? 0 : array.length;
      return !!length && baseIndexOf(array, value, 0) > -1;
    }
  
    var WRAP_BIND_FLAG$7 = 1;
    var WRAP_BIND_KEY_FLAG$6 = 2;
    var WRAP_CURRY_FLAG$6 = 8;
    var WRAP_CURRY_RIGHT_FLAG$3 = 16;
    var WRAP_PARTIAL_FLAG$6 = 32;
    var WRAP_PARTIAL_RIGHT_FLAG$3 = 64;
    var WRAP_ARY_FLAG$4 = 128;
    var WRAP_REARG_FLAG$3 = 256;
    var WRAP_FLIP_FLAG$2 = 512;
    var wrapFlags = [
      ["ary", WRAP_ARY_FLAG$4],
      ["bind", WRAP_BIND_FLAG$7],
      ["bindKey", WRAP_BIND_KEY_FLAG$6],
      ["curry", WRAP_CURRY_FLAG$6],
      ["curryRight", WRAP_CURRY_RIGHT_FLAG$3],
      ["flip", WRAP_FLIP_FLAG$2],
      ["partial", WRAP_PARTIAL_FLAG$6],
      ["partialRight", WRAP_PARTIAL_RIGHT_FLAG$3],
      ["rearg", WRAP_REARG_FLAG$3]
    ];
    function updateWrapDetails(details, bitmask) {
      arrayEach(wrapFlags, function(pair) {
        var value = "_." + pair[0];
        if (bitmask & pair[1] && !arrayIncludes(details, value)) {
          details.push(value);
        }
      });
      return details.sort();
    }
  
    function setWrapToString(wrapper, reference, bitmask) {
      var source = reference + "";
      return setToString(wrapper, insertWrapDetails(source, updateWrapDetails(getWrapDetails(source), bitmask)));
    }
  
    var WRAP_BIND_FLAG$6 = 1;
    var WRAP_BIND_KEY_FLAG$5 = 2;
    var WRAP_CURRY_BOUND_FLAG$1 = 4;
    var WRAP_CURRY_FLAG$5 = 8;
    var WRAP_PARTIAL_FLAG$5 = 32;
    var WRAP_PARTIAL_RIGHT_FLAG$2 = 64;
    function createRecurry(func, bitmask, wrapFunc, placeholder, thisArg, partials, holders, argPos, ary, arity) {
      var isCurry = bitmask & WRAP_CURRY_FLAG$5, newHolders = isCurry ? holders : void 0, newHoldersRight = isCurry ? void 0 : holders, newPartials = isCurry ? partials : void 0, newPartialsRight = isCurry ? void 0 : partials;
      bitmask |= isCurry ? WRAP_PARTIAL_FLAG$5 : WRAP_PARTIAL_RIGHT_FLAG$2;
      bitmask &= ~(isCurry ? WRAP_PARTIAL_RIGHT_FLAG$2 : WRAP_PARTIAL_FLAG$5);
      if (!(bitmask & WRAP_CURRY_BOUND_FLAG$1)) {
        bitmask &= ~(WRAP_BIND_FLAG$6 | WRAP_BIND_KEY_FLAG$5);
      }
      var newData = [
        func,
        bitmask,
        thisArg,
        newPartials,
        newHolders,
        newPartialsRight,
        newHoldersRight,
        argPos,
        ary,
        arity
      ];
      var result = wrapFunc.apply(void 0, newData);
      if (isLaziable(func)) {
        setData(result, newData);
      }
      result.placeholder = placeholder;
      return setWrapToString(result, func, bitmask);
    }
  
    function getHolder(func) {
      var object = func;
      return object.placeholder;
    }
  
    var MAX_SAFE_INTEGER$5 = 9007199254740991;
    var reIsUint = /^(?:0|[1-9]\d*)$/;
    function isIndex(value, length) {
      var type = typeof value;
      length = length == null ? MAX_SAFE_INTEGER$5 : length;
      return !!length && (type == "number" || type != "symbol" && reIsUint.test(value)) && (value > -1 && value % 1 == 0 && value < length);
    }
  
    var nativeMin$e = Math.min;
    function reorder(array, indexes) {
      var arrLength = array.length, length = nativeMin$e(indexes.length, arrLength), oldArray = copyArray(array);
      while (length--) {
        var index = indexes[length];
        array[length] = isIndex(index, arrLength) ? oldArray[index] : void 0;
      }
      return array;
    }
  
    var PLACEHOLDER$1 = "__lodash_placeholder__";
    function replaceHolders(array, placeholder) {
      var index = -1, length = array.length, resIndex = 0, result = [];
      while (++index < length) {
        var value = array[index];
        if (value === placeholder || value === PLACEHOLDER$1) {
          array[index] = PLACEHOLDER$1;
          result[resIndex++] = index;
        }
      }
      return result;
    }
  
    var WRAP_BIND_FLAG$5 = 1;
    var WRAP_BIND_KEY_FLAG$4 = 2;
    var WRAP_CURRY_FLAG$4 = 8;
    var WRAP_CURRY_RIGHT_FLAG$2 = 16;
    var WRAP_ARY_FLAG$3 = 128;
    var WRAP_FLIP_FLAG$1 = 512;
    function createHybrid(func, bitmask, thisArg, partials, holders, partialsRight, holdersRight, argPos, ary, arity) {
      var isAry = bitmask & WRAP_ARY_FLAG$3, isBind = bitmask & WRAP_BIND_FLAG$5, isBindKey = bitmask & WRAP_BIND_KEY_FLAG$4, isCurried = bitmask & (WRAP_CURRY_FLAG$4 | WRAP_CURRY_RIGHT_FLAG$2), isFlip = bitmask & WRAP_FLIP_FLAG$1, Ctor = isBindKey ? void 0 : createCtor(func);
      function wrapper() {
        var length = arguments.length, args = Array(length), index = length;
        while (index--) {
          args[index] = arguments[index];
        }
        if (isCurried) {
          var placeholder = getHolder(wrapper), holdersCount = countHolders(args, placeholder);
        }
        if (partials) {
          args = composeArgs(args, partials, holders, isCurried);
        }
        if (partialsRight) {
          args = composeArgsRight(args, partialsRight, holdersRight, isCurried);
        }
        length -= holdersCount;
        if (isCurried && length < arity) {
          var newHolders = replaceHolders(args, placeholder);
          return createRecurry(func, bitmask, createHybrid, wrapper.placeholder, thisArg, args, newHolders, argPos, ary, arity - length);
        }
        var thisBinding = isBind ? thisArg : this, fn = isBindKey ? thisBinding[func] : func;
        length = args.length;
        if (argPos) {
          args = reorder(args, argPos);
        } else if (isFlip && length > 1) {
          args.reverse();
        }
        if (isAry && ary < length) {
          args.length = ary;
        }
        if (this && this !== root && this instanceof wrapper) {
          fn = Ctor || createCtor(fn);
        }
        return fn.apply(thisBinding, args);
      }
      return wrapper;
    }
  
    function createCurry(func, bitmask, arity) {
      var Ctor = createCtor(func);
      function wrapper() {
        var length = arguments.length, args = Array(length), index = length, placeholder = getHolder(wrapper);
        while (index--) {
          args[index] = arguments[index];
        }
        var holders = length < 3 && args[0] !== placeholder && args[length - 1] !== placeholder ? [] : replaceHolders(args, placeholder);
        length -= holders.length;
        if (length < arity) {
          return createRecurry(func, bitmask, createHybrid, wrapper.placeholder, void 0, args, holders, void 0, void 0, arity - length);
        }
        var fn = this && this !== root && this instanceof wrapper ? Ctor : func;
        return apply(fn, this, args);
      }
      return wrapper;
    }
  
    var WRAP_BIND_FLAG$4 = 1;
    function createPartial(func, bitmask, thisArg, partials) {
      var isBind = bitmask & WRAP_BIND_FLAG$4, Ctor = createCtor(func);
      function wrapper() {
        var argsIndex = -1, argsLength = arguments.length, leftIndex = -1, leftLength = partials.length, args = Array(leftLength + argsLength), fn = this && this !== root && this instanceof wrapper ? Ctor : func;
        while (++leftIndex < leftLength) {
          args[leftIndex] = partials[leftIndex];
        }
        while (argsLength--) {
          args[leftIndex++] = arguments[++argsIndex];
        }
        return apply(fn, isBind ? thisArg : this, args);
      }
      return wrapper;
    }
  
    var PLACEHOLDER = "__lodash_placeholder__";
    var WRAP_BIND_FLAG$3 = 1;
    var WRAP_BIND_KEY_FLAG$3 = 2;
    var WRAP_CURRY_BOUND_FLAG = 4;
    var WRAP_CURRY_FLAG$3 = 8;
    var WRAP_ARY_FLAG$2 = 128;
    var WRAP_REARG_FLAG$2 = 256;
    var nativeMin$d = Math.min;
    function mergeData(data, source) {
      var bitmask = data[1], srcBitmask = source[1], newBitmask = bitmask | srcBitmask, isCommon = newBitmask < (WRAP_BIND_FLAG$3 | WRAP_BIND_KEY_FLAG$3 | WRAP_ARY_FLAG$2);
      var isCombo = srcBitmask == WRAP_ARY_FLAG$2 && bitmask == WRAP_CURRY_FLAG$3 || srcBitmask == WRAP_ARY_FLAG$2 && bitmask == WRAP_REARG_FLAG$2 && data[7].length <= source[8] || srcBitmask == (WRAP_ARY_FLAG$2 | WRAP_REARG_FLAG$2) && source[7].length <= source[8] && bitmask == WRAP_CURRY_FLAG$3;
      if (!(isCommon || isCombo)) {
        return data;
      }
      if (srcBitmask & WRAP_BIND_FLAG$3) {
        data[2] = source[2];
        newBitmask |= bitmask & WRAP_BIND_FLAG$3 ? 0 : WRAP_CURRY_BOUND_FLAG;
      }
      var value = source[3];
      if (value) {
        var partials = data[3];
        data[3] = partials ? composeArgs(partials, value, source[4]) : value;
        data[4] = partials ? replaceHolders(data[3], PLACEHOLDER) : source[4];
      }
      value = source[5];
      if (value) {
        partials = data[5];
        data[5] = partials ? composeArgsRight(partials, value, source[6]) : value;
        data[6] = partials ? replaceHolders(data[5], PLACEHOLDER) : source[6];
      }
      value = source[7];
      if (value) {
        data[7] = value;
      }
      if (srcBitmask & WRAP_ARY_FLAG$2) {
        data[8] = data[8] == null ? source[8] : nativeMin$d(data[8], source[8]);
      }
      if (data[9] == null) {
        data[9] = source[9];
      }
      data[0] = source[0];
      data[1] = newBitmask;
      return data;
    }
  
    var FUNC_ERROR_TEXT$a = "Expected a function";
    var WRAP_BIND_FLAG$2 = 1;
    var WRAP_BIND_KEY_FLAG$2 = 2;
    var WRAP_CURRY_FLAG$2 = 8;
    var WRAP_CURRY_RIGHT_FLAG$1 = 16;
    var WRAP_PARTIAL_FLAG$4 = 32;
    var WRAP_PARTIAL_RIGHT_FLAG$1 = 64;
    var nativeMax$e = Math.max;
    function createWrap(func, bitmask, thisArg, partials, holders, argPos, ary, arity) {
      var isBindKey = bitmask & WRAP_BIND_KEY_FLAG$2;
      if (!isBindKey && typeof func != "function") {
        throw new TypeError(FUNC_ERROR_TEXT$a);
      }
      var length = partials ? partials.length : 0;
      if (!length) {
        bitmask &= ~(WRAP_PARTIAL_FLAG$4 | WRAP_PARTIAL_RIGHT_FLAG$1);
        partials = holders = void 0;
      }
      ary = ary === void 0 ? ary : nativeMax$e(toInteger(ary), 0);
      arity = arity === void 0 ? arity : toInteger(arity);
      length -= holders ? holders.length : 0;
      if (bitmask & WRAP_PARTIAL_RIGHT_FLAG$1) {
        var partialsRight = partials, holdersRight = holders;
        partials = holders = void 0;
      }
      var data = isBindKey ? void 0 : getData(func);
      var newData = [
        func,
        bitmask,
        thisArg,
        partials,
        holders,
        partialsRight,
        holdersRight,
        argPos,
        ary,
        arity
      ];
      if (data) {
        mergeData(newData, data);
      }
      func = newData[0];
      bitmask = newData[1];
      thisArg = newData[2];
      partials = newData[3];
      holders = newData[4];
      arity = newData[9] = newData[9] === void 0 ? isBindKey ? 0 : func.length : nativeMax$e(newData[9] - length, 0);
      if (!arity && bitmask & (WRAP_CURRY_FLAG$2 | WRAP_CURRY_RIGHT_FLAG$1)) {
        bitmask &= ~(WRAP_CURRY_FLAG$2 | WRAP_CURRY_RIGHT_FLAG$1);
      }
      if (!bitmask || bitmask == WRAP_BIND_FLAG$2) {
        var result = createBind(func, bitmask, thisArg);
      } else if (bitmask == WRAP_CURRY_FLAG$2 || bitmask == WRAP_CURRY_RIGHT_FLAG$1) {
        result = createCurry(func, bitmask, arity);
      } else if ((bitmask == WRAP_PARTIAL_FLAG$4 || bitmask == (WRAP_BIND_FLAG$2 | WRAP_PARTIAL_FLAG$4)) && !holders.length) {
        result = createPartial(func, bitmask, thisArg, partials);
      } else {
        result = createHybrid.apply(void 0, newData);
      }
      var setter = data ? baseSetData : setData;
      return setWrapToString(setter(result, newData), func, bitmask);
    }
  
    var WRAP_ARY_FLAG$1 = 128;
    function ary(func, n, guard) {
      n = guard ? void 0 : n;
      n = func && n == null ? func.length : n;
      return createWrap(func, WRAP_ARY_FLAG$1, void 0, void 0, void 0, void 0, n);
    }
  
    function baseAssignValue(object, key, value) {
      if (key == "__proto__" && defineProperty) {
        defineProperty(object, key, {
          "configurable": true,
          "enumerable": true,
          "value": value,
          "writable": true
        });
      } else {
        object[key] = value;
      }
    }
  
    function eq(value, other) {
      return value === other || value !== value && other !== other;
    }
  
    var objectProto$n = Object.prototype;
    var hasOwnProperty$l = objectProto$n.hasOwnProperty;
    function assignValue(object, key, value) {
      var objValue = object[key];
      if (!(hasOwnProperty$l.call(object, key) && eq(objValue, value)) || value === void 0 && !(key in object)) {
        baseAssignValue(object, key, value);
      }
    }
  
    function copyObject(source, props, object, customizer) {
      var isNew = !object;
      object || (object = {});
      var index = -1, length = props.length;
      while (++index < length) {
        var key = props[index];
        var newValue = customizer ? customizer(object[key], source[key], key, object, source) : void 0;
        if (newValue === void 0) {
          newValue = source[key];
        }
        if (isNew) {
          baseAssignValue(object, key, newValue);
        } else {
          assignValue(object, key, newValue);
        }
      }
      return object;
    }
  
    var nativeMax$d = Math.max;
    function overRest(func, start, transform) {
      start = nativeMax$d(start === void 0 ? func.length - 1 : start, 0);
      return function() {
        var args = arguments, index = -1, length = nativeMax$d(args.length - start, 0), array = Array(length);
        while (++index < length) {
          array[index] = args[start + index];
        }
        index = -1;
        var otherArgs = Array(start + 1);
        while (++index < start) {
          otherArgs[index] = args[index];
        }
        otherArgs[start] = transform(array);
        return apply(func, this, otherArgs);
      };
    }
  
    function baseRest(func, start) {
      return setToString(overRest(func, start, identity$1), func + "");
    }
  
    var MAX_SAFE_INTEGER$4 = 9007199254740991;
    function isLength(value) {
      return typeof value == "number" && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER$4;
    }
  
    function isArrayLike(value) {
      return value != null && isLength(value.length) && !isFunction$1(value);
    }
  
    function isIterateeCall(value, index, object) {
      if (!isObject$2(object)) {
        return false;
      }
      var type = typeof index;
      if (type == "number" ? isArrayLike(object) && isIndex(index, object.length) : type == "string" && index in object) {
        return eq(object[index], value);
      }
      return false;
    }
  
    function createAssigner(assigner) {
      return baseRest(function(object, sources) {
        var index = -1, length = sources.length, customizer = length > 1 ? sources[length - 1] : void 0, guard = length > 2 ? sources[2] : void 0;
        customizer = assigner.length > 3 && typeof customizer == "function" ? (length--, customizer) : void 0;
        if (guard && isIterateeCall(sources[0], sources[1], guard)) {
          customizer = length < 3 ? void 0 : customizer;
          length = 1;
        }
        object = Object(object);
        while (++index < length) {
          var source = sources[index];
          if (source) {
            assigner(object, source, index, customizer);
          }
        }
        return object;
      });
    }
  
    var objectProto$m = Object.prototype;
    function isPrototype(value) {
      var Ctor = value && value.constructor, proto = typeof Ctor == "function" && Ctor.prototype || objectProto$m;
      return value === proto;
    }
  
    function baseTimes(n, iteratee) {
      var index = -1, result = Array(n);
      while (++index < n) {
        result[index] = iteratee(index);
      }
      return result;
    }
  
    var argsTag$3 = "[object Arguments]";
    function baseIsArguments(value) {
      return isObjectLike(value) && baseGetTag(value) == argsTag$3;
    }
  
    var objectProto$l = Object.prototype;
    var hasOwnProperty$k = objectProto$l.hasOwnProperty;
    var propertyIsEnumerable$1 = objectProto$l.propertyIsEnumerable;
    var isArguments = baseIsArguments(function() {
      return arguments;
    }()) ? baseIsArguments : function(value) {
      return isObjectLike(value) && hasOwnProperty$k.call(value, "callee") && !propertyIsEnumerable$1.call(value, "callee");
    };
  
    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 argsTag$2 = "[object Arguments]";
    var arrayTag$2 = "[object Array]";
    var boolTag$4 = "[object Boolean]";
    var dateTag$4 = "[object Date]";
    var errorTag$3 = "[object Error]";
    var funcTag$1 = "[object Function]";
    var mapTag$9 = "[object Map]";
    var numberTag$4 = "[object Number]";
    var objectTag$4 = "[object Object]";
    var regexpTag$4 = "[object RegExp]";
    var setTag$9 = "[object Set]";
    var stringTag$4 = "[object String]";
    var weakMapTag$3 = "[object WeakMap]";
    var arrayBufferTag$4 = "[object ArrayBuffer]";
    var dataViewTag$4 = "[object DataView]";
    var float32Tag$2 = "[object Float32Array]";
    var float64Tag$2 = "[object Float64Array]";
    var int8Tag$2 = "[object Int8Array]";
    var int16Tag$2 = "[object Int16Array]";
    var int32Tag$2 = "[object Int32Array]";
    var uint8Tag$2 = "[object Uint8Array]";
    var uint8ClampedTag$2 = "[object Uint8ClampedArray]";
    var uint16Tag$2 = "[object Uint16Array]";
    var 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$2] = typedArrayTags[arrayTag$2] = typedArrayTags[arrayBufferTag$4] = typedArrayTags[boolTag$4] = typedArrayTags[dataViewTag$4] = typedArrayTags[dateTag$4] = typedArrayTags[errorTag$3] = typedArrayTags[funcTag$1] = typedArrayTags[mapTag$9] = typedArrayTags[numberTag$4] = typedArrayTags[objectTag$4] = typedArrayTags[regexpTag$4] = typedArrayTags[setTag$9] = typedArrayTags[stringTag$4] = typedArrayTags[weakMapTag$3] = 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$k = Object.prototype;
    var hasOwnProperty$j = objectProto$k.hasOwnProperty;
    function arrayLikeKeys(value, inherited) {
      var isArr = isArray$1(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 ((inherited || hasOwnProperty$j.call(value, key)) && !(skipIndexes && (key == "length" || isBuff && (key == "offset" || key == "parent") || isType && (key == "buffer" || key == "byteLength" || key == "byteOffset") || isIndex(key, length)))) {
          result.push(key);
        }
      }
      return result;
    }
  
    function overArg(func, transform) {
      return function(arg) {
        return func(transform(arg));
      };
    }
  
    var nativeKeys = overArg(Object.keys, Object);
  
    var objectProto$j = Object.prototype;
    var hasOwnProperty$i = objectProto$j.hasOwnProperty;
    function baseKeys(object) {
      if (!isPrototype(object)) {
        return nativeKeys(object);
      }
      var result = [];
      for (var key in Object(object)) {
        if (hasOwnProperty$i.call(object, key) && key != "constructor") {
          result.push(key);
        }
      }
      return result;
    }
  
    function keys(object) {
      return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);
    }
  
    var objectProto$i = Object.prototype;
    var hasOwnProperty$h = objectProto$i.hasOwnProperty;
    var assign = createAssigner(function(object, source) {
      if (isPrototype(source) || isArrayLike(source)) {
        copyObject(source, keys(source), object);
        return;
      }
      for (var key in source) {
        if (hasOwnProperty$h.call(source, key)) {
          assignValue(object, key, source[key]);
        }
      }
    });
  
    function nativeKeysIn(object) {
      var result = [];
      if (object != null) {
        for (var key in Object(object)) {
          result.push(key);
        }
      }
      return result;
    }
  
    var objectProto$h = Object.prototype;
    var hasOwnProperty$g = objectProto$h.hasOwnProperty;
    function baseKeysIn(object) {
      if (!isObject$2(object)) {
        return nativeKeysIn(object);
      }
      var isProto = isPrototype(object), result = [];
      for (var key in object) {
        if (!(key == "constructor" && (isProto || !hasOwnProperty$g.call(object, key)))) {
          result.push(key);
        }
      }
      return result;
    }
  
    function keysIn(object) {
      return isArrayLike(object) ? arrayLikeKeys(object, true) : baseKeysIn(object);
    }
  
    var assignIn = createAssigner(function(object, source) {
      copyObject(source, keysIn(source), object);
    });
  
    var assignInWith = createAssigner(function(object, source, srcIndex, customizer) {
      copyObject(source, keysIn(source), object, customizer);
    });
  
    var assignWith = createAssigner(function(object, source, srcIndex, customizer) {
      copyObject(source, keys(source), object, customizer);
    });
  
    var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/;
    var reIsPlainProp = /^\w*$/;
    function isKey(value, object) {
      if (isArray$1(value)) {
        return false;
      }
      var type = typeof value;
      if (type == "number" || type == "symbol" || type == "boolean" || value == null || isSymbol(value)) {
        return true;
      }
      return reIsPlainProp.test(value) || !reIsDeepProp.test(value) || object != null && value in Object(object);
    }
  
    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$2 = "__lodash_hash_undefined__";
    var objectProto$g = Object.prototype;
    var hasOwnProperty$f = objectProto$g.hasOwnProperty;
    function hashGet(key) {
      var data = this.__data__;
      if (nativeCreate) {
        var result = data[key];
        return result === HASH_UNDEFINED$2 ? void 0 : result;
      }
      return hasOwnProperty$f.call(data, key) ? data[key] : void 0;
    }
  
    var objectProto$f = Object.prototype;
    var hasOwnProperty$e = objectProto$f.hasOwnProperty;
    function hashHas(key) {
      var data = this.__data__;
      return nativeCreate ? data[key] !== void 0 : hasOwnProperty$e.call(data, key);
    }
  
    var HASH_UNDEFINED$1 = "__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$1 : 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 listCacheClear() {
      this.__data__ = [];
      this.size = 0;
    }
  
    function assocIndexOf(array, key) {
      var length = array.length;
      while (length--) {
        if (eq(array[length][0], key)) {
          return length;
        }
      }
      return -1;
    }
  
    var arrayProto$5 = Array.prototype;
    var splice$2 = arrayProto$5.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$2.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;
  
    var Map$1 = getNative(root, "Map");
  
    function mapCacheClear() {
      this.size = 0;
      this.__data__ = {
        "hash": new Hash(),
        "map": new (Map$1 || 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 FUNC_ERROR_TEXT$9 = "Expected a function";
    function memoize(func, resolver) {
      if (typeof func != "function" || resolver != null && typeof resolver != "function") {
        throw new TypeError(FUNC_ERROR_TEXT$9);
      }
      var memoized = function() {
        var args = arguments, key = resolver ? resolver.apply(this, args) : args[0], cache = memoized.cache;
        if (cache.has(key)) {
          return cache.get(key);
        }
        var result = func.apply(this, args);
        memoized.cache = cache.set(key, result) || cache;
        return result;
      };
      memoized.cache = new (memoize.Cache || MapCache)();
      return memoized;
    }
    memoize.Cache = MapCache;
  
    var MAX_MEMOIZE_SIZE = 500;
    function memoizeCapped(func) {
      var result = memoize(func, function(key) {
        if (cache.size === MAX_MEMOIZE_SIZE) {
          cache.clear();
        }
        return key;
      });
      var cache = result.cache;
      return result;
    }
  
    var rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g;
    var reEscapeChar = /\\(\\)?/g;
    var stringToPath = memoizeCapped(function(string) {
      var result = [];
      if (string.charCodeAt(0) === 46) {
        result.push("");
      }
      string.replace(rePropName, function(match, number, quote, subString) {
        result.push(quote ? subString.replace(reEscapeChar, "$1") : number || match);
      });
      return result;
    });
  
    function toString(value) {
      return value == null ? "" : baseToString(value);
    }
  
    function castPath(value, object) {
      if (isArray$1(value)) {
        return value;
      }
      return isKey(value, object) ? [value] : stringToPath(toString(value));
    }
  
    var INFINITY$3 = 1 / 0;
    function toKey(value) {
      if (typeof value == "string" || isSymbol(value)) {
        return value;
      }
      var result = value + "";
      return result == "0" && 1 / value == -INFINITY$3 ? "-0" : result;
    }
  
    function baseGet(object, path) {
      path = castPath(path, object);
      var index = 0, length = path.length;
      while (object != null && index < length) {
        object = object[toKey(path[index++])];
      }
      return index && index == length ? object : void 0;
    }
  
    function get(object, path, defaultValue) {
      var result = object == null ? void 0 : baseGet(object, path);
      return result === void 0 ? defaultValue : result;
    }
  
    function baseAt(object, paths) {
      var index = -1, length = paths.length, result = Array(length), skip = object == null;
      while (++index < length) {
        result[index] = skip ? void 0 : get(object, paths[index]);
      }
      return result;
    }
  
    function arrayPush(array, values) {
      var index = -1, length = values.length, offset = array.length;
      while (++index < length) {
        array[offset + index] = values[index];
      }
      return array;
    }
  
    var spreadableSymbol = Symbol$1 ? Symbol$1.isConcatSpreadable : void 0;
    function isFlattenable(value) {
      return isArray$1(value) || isArguments(value) || !!(spreadableSymbol && value && value[spreadableSymbol]);
    }
  
    function baseFlatten(array, depth, predicate, isStrict, result) {
      var index = -1, length = array.length;
      predicate || (predicate = isFlattenable);
      result || (result = []);
      while (++index < length) {
        var value = array[index];
        if (depth > 0 && predicate(value)) {
          if (depth > 1) {
            baseFlatten(value, depth - 1, predicate, isStrict, result);
          } else {
            arrayPush(result, value);
          }
        } else if (!isStrict) {
          result[result.length] = value;
        }
      }
      return result;
    }
  
    function flatten(array) {
      var length = array == null ? 0 : array.length;
      return length ? baseFlatten(array, 1) : [];
    }
  
    function flatRest(func) {
      return setToString(overRest(func, void 0, flatten), func + "");
    }
  
    var at$1 = flatRest(baseAt);
  
    var getPrototype = overArg(Object.getPrototypeOf, Object);
  
    var objectTag$3 = "[object Object]";
    var funcProto = Function.prototype;
    var objectProto$e = Object.prototype;
    var funcToString = funcProto.toString;
    var hasOwnProperty$d = objectProto$e.hasOwnProperty;
    var objectCtorString = funcToString.call(Object);
    function isPlainObject(value) {
      if (!isObjectLike(value) || baseGetTag(value) != objectTag$3) {
        return false;
      }
      var proto = getPrototype(value);
      if (proto === null) {
        return true;
      }
      var Ctor = hasOwnProperty$d.call(proto, "constructor") && proto.constructor;
      return typeof Ctor == "function" && Ctor instanceof Ctor && funcToString.call(Ctor) == objectCtorString;
    }
  
    var domExcTag = "[object DOMException]";
    var errorTag$2 = "[object Error]";
    function isError(value) {
      if (!isObjectLike(value)) {
        return false;
      }
      var tag = baseGetTag(value);
      return tag == errorTag$2 || tag == domExcTag || typeof value.message == "string" && typeof value.name == "string" && !isPlainObject(value);
    }
  
    var attempt = baseRest(function(func, args) {
      try {
        return apply(func, void 0, args);
      } catch (e) {
        return isError(e) ? e : new Error(e);
      }
    });
  
    var FUNC_ERROR_TEXT$8 = "Expected a function";
    function before(n, func) {
      var result;
      if (typeof func != "function") {
        throw new TypeError(FUNC_ERROR_TEXT$8);
      }
      n = toInteger(n);
      return function() {
        if (--n > 0) {
          result = func.apply(this, arguments);
        }
        if (n <= 1) {
          func = void 0;
        }
        return result;
      };
    }
  
    var WRAP_BIND_FLAG$1 = 1;
    var WRAP_PARTIAL_FLAG$3 = 32;
    var bind = baseRest(function(func, thisArg, partials) {
      var bitmask = WRAP_BIND_FLAG$1;
      if (partials.length) {
        var holders = replaceHolders(partials, getHolder(bind));
        bitmask |= WRAP_PARTIAL_FLAG$3;
      }
      return createWrap(func, bitmask, thisArg, partials, holders);
    });
    bind.placeholder = {};
  
    var bindAll = flatRest(function(object, methodNames) {
      arrayEach(methodNames, function(key) {
        key = toKey(key);
        baseAssignValue(object, key, bind(object[key], object));
      });
      return object;
    });
  
    var WRAP_BIND_FLAG = 1;
    var WRAP_BIND_KEY_FLAG$1 = 2;
    var WRAP_PARTIAL_FLAG$2 = 32;
    var bindKey = baseRest(function(object, key, partials) {
      var bitmask = WRAP_BIND_FLAG | WRAP_BIND_KEY_FLAG$1;
      if (partials.length) {
        var holders = replaceHolders(partials, getHolder(bindKey));
        bitmask |= WRAP_PARTIAL_FLAG$2;
      }
      return createWrap(key, bitmask, object, partials, holders);
    });
    bindKey.placeholder = {};
  
    function baseSlice(array, start, end) {
      var index = -1, length = array.length;
      if (start < 0) {
        start = -start > length ? 0 : length + start;
      }
      end = end > length ? length : end;
      if (end < 0) {
        end += length;
      }
      length = start > end ? 0 : end - start >>> 0;
      start >>>= 0;
      var result = Array(length);
      while (++index < length) {
        result[index] = array[index + start];
      }
      return result;
    }
  
    function castSlice(array, start, end) {
      var length = array.length;
      end = end === void 0 ? length : end;
      return !start && end >= length ? array : baseSlice(array, start, end);
    }
  
    var rsAstralRange$3 = "\\ud800-\\udfff";
    var rsComboMarksRange$4 = "\\u0300-\\u036f";
    var reComboHalfMarksRange$4 = "\\ufe20-\\ufe2f";
    var rsComboSymbolsRange$4 = "\\u20d0-\\u20ff";
    var rsComboRange$4 = rsComboMarksRange$4 + reComboHalfMarksRange$4 + rsComboSymbolsRange$4;
    var rsVarRange$3 = "\\ufe0e\\ufe0f";
    var rsZWJ$3 = "\\u200d";
    var reHasUnicode = RegExp("[" + rsZWJ$3 + rsAstralRange$3 + rsComboRange$4 + rsVarRange$3 + "]");
    function hasUnicode(string) {
      return reHasUnicode.test(string);
    }
  
    function asciiToArray(string) {
      return string.split("");
    }
  
    var rsAstralRange$2 = "\\ud800-\\udfff";
    var rsComboMarksRange$3 = "\\u0300-\\u036f";
    var reComboHalfMarksRange$3 = "\\ufe20-\\ufe2f";
    var rsComboSymbolsRange$3 = "\\u20d0-\\u20ff";
    var rsComboRange$3 = rsComboMarksRange$3 + reComboHalfMarksRange$3 + rsComboSymbolsRange$3;
    var rsVarRange$2 = "\\ufe0e\\ufe0f";
    var rsAstral$1 = "[" + rsAstralRange$2 + "]";
    var rsCombo$3 = "[" + rsComboRange$3 + "]";
    var rsFitz$2 = "\\ud83c[\\udffb-\\udfff]";
    var rsModifier$2 = "(?:" + rsCombo$3 + "|" + rsFitz$2 + ")";
    var rsNonAstral$2 = "[^" + rsAstralRange$2 + "]";
    var rsRegional$2 = "(?:\\ud83c[\\udde6-\\uddff]){2}";
    var rsSurrPair$2 = "[\\ud800-\\udbff][\\udc00-\\udfff]";
    var rsZWJ$2 = "\\u200d";
    var reOptMod$2 = rsModifier$2 + "?";
    var rsOptVar$2 = "[" + rsVarRange$2 + "]?";
    var rsOptJoin$2 = "(?:" + rsZWJ$2 + "(?:" + [rsNonAstral$2, rsRegional$2, rsSurrPair$2].join("|") + ")" + rsOptVar$2 + reOptMod$2 + ")*";
    var rsSeq$2 = rsOptVar$2 + reOptMod$2 + rsOptJoin$2;
    var rsSymbol$1 = "(?:" + [rsNonAstral$2 + rsCombo$3 + "?", rsCombo$3, rsRegional$2, rsSurrPair$2, rsAstral$1].join("|") + ")";
    var reUnicode$1 = RegExp(rsFitz$2 + "(?=" + rsFitz$2 + ")|" + rsSymbol$1 + rsSeq$2, "g");
    function unicodeToArray(string) {
      return string.match(reUnicode$1) || [];
    }
  
    function stringToArray(string) {
      return hasUnicode(string) ? unicodeToArray(string) : asciiToArray(string);
    }
  
    function createCaseFirst(methodName) {
      return function(string) {
        string = toString(string);
        var strSymbols = hasUnicode(string) ? stringToArray(string) : void 0;
        var chr = strSymbols ? strSymbols[0] : string.charAt(0);
        var trailing = strSymbols ? castSlice(strSymbols, 1).join("") : string.slice(1);
        return chr[methodName]() + trailing;
      };
    }
  
    var upperFirst = createCaseFirst("toUpperCase");
  
    function capitalize$2(string) {
      return upperFirst(toString(string).toLowerCase());
    }
  
    function arrayReduce(array, iteratee, accumulator, initAccum) {
      var index = -1, length = array == null ? 0 : array.length;
      if (initAccum && length) {
        accumulator = array[++index];
      }
      while (++index < length) {
        accumulator = iteratee(accumulator, array[index], index, array);
      }
      return accumulator;
    }
  
    function basePropertyOf(object) {
      return function(key) {
        return object == null ? void 0 : object[key];
      };
    }
  
    var deburredLetters = {
      "\xC0": "A",
      "\xC1": "A",
      "\xC2": "A",
      "\xC3": "A",
      "\xC4": "A",
      "\xC5": "A",
      "\xE0": "a",
      "\xE1": "a",
      "\xE2": "a",
      "\xE3": "a",
      "\xE4": "a",
      "\xE5": "a",
      "\xC7": "C",
      "\xE7": "c",
      "\xD0": "D",
      "\xF0": "d",
      "\xC8": "E",
      "\xC9": "E",
      "\xCA": "E",
      "\xCB": "E",
      "\xE8": "e",
      "\xE9": "e",
      "\xEA": "e",
      "\xEB": "e",
      "\xCC": "I",
      "\xCD": "I",
      "\xCE": "I",
      "\xCF": "I",
      "\xEC": "i",
      "\xED": "i",
      "\xEE": "i",
      "\xEF": "i",
      "\xD1": "N",
      "\xF1": "n",
      "\xD2": "O",
      "\xD3": "O",
      "\xD4": "O",
      "\xD5": "O",
      "\xD6": "O",
      "\xD8": "O",
      "\xF2": "o",
      "\xF3": "o",
      "\xF4": "o",
      "\xF5": "o",
      "\xF6": "o",
      "\xF8": "o",
      "\xD9": "U",
      "\xDA": "U",
      "\xDB": "U",
      "\xDC": "U",
      "\xF9": "u",
      "\xFA": "u",
      "\xFB": "u",
      "\xFC": "u",
      "\xDD": "Y",
      "\xFD": "y",
      "\xFF": "y",
      "\xC6": "Ae",
      "\xE6": "ae",
      "\xDE": "Th",
      "\xFE": "th",
      "\xDF": "ss",
      "\u0100": "A",
      "\u0102": "A",
      "\u0104": "A",
      "\u0101": "a",
      "\u0103": "a",
      "\u0105": "a",
      "\u0106": "C",
      "\u0108": "C",
      "\u010A": "C",
      "\u010C": "C",
      "\u0107": "c",
      "\u0109": "c",
      "\u010B": "c",
      "\u010D": "c",
      "\u010E": "D",
      "\u0110": "D",
      "\u010F": "d",
      "\u0111": "d",
      "\u0112": "E",
      "\u0114": "E",
      "\u0116": "E",
      "\u0118": "E",
      "\u011A": "E",
      "\u0113": "e",
      "\u0115": "e",
      "\u0117": "e",
      "\u0119": "e",
      "\u011B": "e",
      "\u011C": "G",
      "\u011E": "G",
      "\u0120": "G",
      "\u0122": "G",
      "\u011D": "g",
      "\u011F": "g",
      "\u0121": "g",
      "\u0123": "g",
      "\u0124": "H",
      "\u0126": "H",
      "\u0125": "h",
      "\u0127": "h",
      "\u0128": "I",
      "\u012A": "I",
      "\u012C": "I",
      "\u012E": "I",
      "\u0130": "I",
      "\u0129": "i",
      "\u012B": "i",
      "\u012D": "i",
      "\u012F": "i",
      "\u0131": "i",
      "\u0134": "J",
      "\u0135": "j",
      "\u0136": "K",
      "\u0137": "k",
      "\u0138": "k",
      "\u0139": "L",
      "\u013B": "L",
      "\u013D": "L",
      "\u013F": "L",
      "\u0141": "L",
      "\u013A": "l",
      "\u013C": "l",
      "\u013E": "l",
      "\u0140": "l",
      "\u0142": "l",
      "\u0143": "N",
      "\u0145": "N",
      "\u0147": "N",
      "\u014A": "N",
      "\u0144": "n",
      "\u0146": "n",
      "\u0148": "n",
      "\u014B": "n",
      "\u014C": "O",
      "\u014E": "O",
      "\u0150": "O",
      "\u014D": "o",
      "\u014F": "o",
      "\u0151": "o",
      "\u0154": "R",
      "\u0156": "R",
      "\u0158": "R",
      "\u0155": "r",
      "\u0157": "r",
      "\u0159": "r",
      "\u015A": "S",
      "\u015C": "S",
      "\u015E": "S",
      "\u0160": "S",
      "\u015B": "s",
      "\u015D": "s",
      "\u015F": "s",
      "\u0161": "s",
      "\u0162": "T",
      "\u0164": "T",
      "\u0166": "T",
      "\u0163": "t",
      "\u0165": "t",
      "\u0167": "t",
      "\u0168": "U",
      "\u016A": "U",
      "\u016C": "U",
      "\u016E": "U",
      "\u0170": "U",
      "\u0172": "U",
      "\u0169": "u",
      "\u016B": "u",
      "\u016D": "u",
      "\u016F": "u",
      "\u0171": "u",
      "\u0173": "u",
      "\u0174": "W",
      "\u0175": "w",
      "\u0176": "Y",
      "\u0177": "y",
      "\u0178": "Y",
      "\u0179": "Z",
      "\u017B": "Z",
      "\u017D": "Z",
      "\u017A": "z",
      "\u017C": "z",
      "\u017E": "z",
      "\u0132": "IJ",
      "\u0133": "ij",
      "\u0152": "Oe",
      "\u0153": "oe",
      "\u0149": "'n",
      "\u017F": "s"
    };
    var deburrLetter = basePropertyOf(deburredLetters);
  
    var reLatin = /[\xc0-\xd6\xd8-\xf6\xf8-\xff\u0100-\u017f]/g;
    var rsComboMarksRange$2 = "\\u0300-\\u036f";
    var reComboHalfMarksRange$2 = "\\ufe20-\\ufe2f";
    var rsComboSymbolsRange$2 = "\\u20d0-\\u20ff";
    var rsComboRange$2 = rsComboMarksRange$2 + reComboHalfMarksRange$2 + rsComboSymbolsRange$2;
    var rsCombo$2 = "[" + rsComboRange$2 + "]";
    var reComboMark = RegExp(rsCombo$2, "g");
    function deburr(string) {
      string = toString(string);
      return string && string.replace(reLatin, deburrLetter).replace(reComboMark, "");
    }
  
    var reAsciiWord = /[^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+/g;
    function asciiWords(string) {
      return string.match(reAsciiWord) || [];
    }
  
    var reHasUnicodeWord = /[a-z][A-Z]|[A-Z]{2}[a-z]|[0-9][a-zA-Z]|[a-zA-Z][0-9]|[^a-zA-Z0-9 ]/;
    function hasUnicodeWord(string) {
      return reHasUnicodeWord.test(string);
    }
  
    var rsAstralRange$1 = "\\ud800-\\udfff";
    var rsComboMarksRange$1 = "\\u0300-\\u036f";
    var reComboHalfMarksRange$1 = "\\ufe20-\\ufe2f";
    var rsComboSymbolsRange$1 = "\\u20d0-\\u20ff";
    var rsComboRange$1 = rsComboMarksRange$1 + reComboHalfMarksRange$1 + rsComboSymbolsRange$1;
    var rsDingbatRange = "\\u2700-\\u27bf";
    var rsLowerRange = "a-z\\xdf-\\xf6\\xf8-\\xff";
    var rsMathOpRange = "\\xac\\xb1\\xd7\\xf7";
    var rsNonCharRange = "\\x00-\\x2f\\x3a-\\x40\\x5b-\\x60\\x7b-\\xbf";
    var rsPunctuationRange = "\\u2000-\\u206f";
    var rsSpaceRange = " \\t\\x0b\\f\\xa0\\ufeff\\n\\r\\u2028\\u2029\\u1680\\u180e\\u2000\\u2001\\u2002\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200a\\u202f\\u205f\\u3000";
    var rsUpperRange = "A-Z\\xc0-\\xd6\\xd8-\\xde";
    var rsVarRange$1 = "\\ufe0e\\ufe0f";
    var rsBreakRange = rsMathOpRange + rsNonCharRange + rsPunctuationRange + rsSpaceRange;
    var rsApos$1 = "['\u2019]";
    var rsBreak = "[" + rsBreakRange + "]";
    var rsCombo$1 = "[" + rsComboRange$1 + "]";
    var rsDigits = "\\d+";
    var rsDingbat = "[" + rsDingbatRange + "]";
    var rsLower = "[" + rsLowerRange + "]";
    var rsMisc = "[^" + rsAstralRange$1 + rsBreakRange + rsDigits + rsDingbatRange + rsLowerRange + rsUpperRange + "]";
    var rsFitz$1 = "\\ud83c[\\udffb-\\udfff]";
    var rsModifier$1 = "(?:" + rsCombo$1 + "|" + rsFitz$1 + ")";
    var rsNonAstral$1 = "[^" + rsAstralRange$1 + "]";
    var rsRegional$1 = "(?:\\ud83c[\\udde6-\\uddff]){2}";
    var rsSurrPair$1 = "[\\ud800-\\udbff][\\udc00-\\udfff]";
    var rsUpper = "[" + rsUpperRange + "]";
    var rsZWJ$1 = "\\u200d";
    var rsMiscLower = "(?:" + rsLower + "|" + rsMisc + ")";
    var rsMiscUpper = "(?:" + rsUpper + "|" + rsMisc + ")";
    var rsOptContrLower = "(?:" + rsApos$1 + "(?:d|ll|m|re|s|t|ve))?";
    var rsOptContrUpper = "(?:" + rsApos$1 + "(?:D|LL|M|RE|S|T|VE))?";
    var reOptMod$1 = rsModifier$1 + "?";
    var rsOptVar$1 = "[" + rsVarRange$1 + "]?";
    var rsOptJoin$1 = "(?:" + rsZWJ$1 + "(?:" + [rsNonAstral$1, rsRegional$1, rsSurrPair$1].join("|") + ")" + rsOptVar$1 + reOptMod$1 + ")*";
    var rsOrdLower = "\\d*(?:1st|2nd|3rd|(?![123])\\dth)(?=\\b|[A-Z_])";
    var rsOrdUpper = "\\d*(?:1ST|2ND|3RD|(?![123])\\dTH)(?=\\b|[a-z_])";
    var rsSeq$1 = rsOptVar$1 + reOptMod$1 + rsOptJoin$1;
    var rsEmoji = "(?:" + [rsDingbat, rsRegional$1, rsSurrPair$1].join("|") + ")" + rsSeq$1;
    var reUnicodeWord = RegExp([
      rsUpper + "?" + rsLower + "+" + rsOptContrLower + "(?=" + [rsBreak, rsUpper, "$"].join("|") + ")",
      rsMiscUpper + "+" + rsOptContrUpper + "(?=" + [rsBreak, rsUpper + rsMiscLower, "$"].join("|") + ")",
      rsUpper + "?" + rsMiscLower + "+" + rsOptContrLower,
      rsUpper + "+" + rsOptContrUpper,
      rsOrdUpper,
      rsOrdLower,
      rsDigits,
      rsEmoji
    ].join("|"), "g");
    function unicodeWords(string) {
      return string.match(reUnicodeWord) || [];
    }
  
    function words(string, pattern, guard) {
      string = toString(string);
      pattern = guard ? void 0 : pattern;
      if (pattern === void 0) {
        return hasUnicodeWord(string) ? unicodeWords(string) : asciiWords(string);
      }
      return string.match(pattern) || [];
    }
  
    var rsApos = "['\u2019]";
    var reApos = RegExp(rsApos, "g");
    function createCompounder(callback) {
      return function(string) {
        return arrayReduce(words(deburr(string).replace(reApos, "")), callback, "");
      };
    }
  
    var camelCase = createCompounder(function(result, word, index) {
      word = word.toLowerCase();
      return result + (index ? capitalize$2(word) : word);
    });
  
    function castArray$1() {
      if (!arguments.length) {
        return [];
      }
      var value = arguments[0];
      return isArray$1(value) ? value : [value];
    }
  
    var nativeIsFinite$1 = root.isFinite;
    var nativeMin$c = Math.min;
    function createRound(methodName) {
      var func = Math[methodName];
      return function(number, precision) {
        number = toNumber(number);
        precision = precision == null ? 0 : nativeMin$c(toInteger(precision), 292);
        if (precision && nativeIsFinite$1(number)) {
          var pair = (toString(number) + "e").split("e"), value = func(pair[0] + "e" + (+pair[1] + precision));
          pair = (toString(value) + "e").split("e");
          return +(pair[0] + "e" + (+pair[1] - precision));
        }
        return func(number);
      };
    }
  
    var ceil = createRound("ceil");
  
    function chain(value) {
      var result = lodash(value);
      result.__chain__ = true;
      return result;
    }
  
    var nativeCeil$3 = Math.ceil;
    var nativeMax$c = Math.max;
    function chunk(array, size, guard) {
      if (guard ? isIterateeCall(array, size, guard) : size === void 0) {
        size = 1;
      } else {
        size = nativeMax$c(toInteger(size), 0);
      }
      var length = array == null ? 0 : array.length;
      if (!length || size < 1) {
        return [];
      }
      var index = 0, resIndex = 0, result = Array(nativeCeil$3(length / size));
      while (index < length) {
        result[resIndex++] = baseSlice(array, index, index += size);
      }
      return result;
    }
  
    function baseClamp(number, lower, upper) {
      if (number === number) {
        if (upper !== void 0) {
          number = number <= upper ? number : upper;
        }
        if (lower !== void 0) {
          number = number >= lower ? number : lower;
        }
      }
      return number;
    }
  
    function clamp(number, lower, upper) {
      if (upper === void 0) {
        upper = lower;
        lower = void 0;
      }
      if (upper !== void 0) {
        upper = toNumber(upper);
        upper = upper === upper ? upper : 0;
      }
      if (lower !== void 0) {
        lower = toNumber(lower);
        lower = lower === lower ? lower : 0;
      }
      return baseClamp(toNumber(number), lower, upper);
    }
  
    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 LARGE_ARRAY_SIZE$2 = 200;
    function stackSet(key, value) {
      var data = this.__data__;
      if (data instanceof ListCache) {
        var pairs = data.__data__;
        if (!Map$1 || pairs.length < LARGE_ARRAY_SIZE$2 - 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 baseAssign(object, source) {
      return object && copyObject(source, keys(source), object);
    }
  
    function baseAssignIn(object, source) {
      return object && copyObject(source, keysIn(source), 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 Buffer = moduleExports ? root.Buffer : void 0;
    var allocUnsafe = Buffer ? Buffer.allocUnsafe : void 0;
    function cloneBuffer(buffer, isDeep) {
      if (isDeep) {
        return buffer.slice();
      }
      var length = buffer.length, result = allocUnsafe ? allocUnsafe(length) : new buffer.constructor(length);
      buffer.copy(result);
      return result;
    }
  
    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$d = Object.prototype;
    var propertyIsEnumerable = objectProto$d.propertyIsEnumerable;
    var nativeGetSymbols$1 = Object.getOwnPropertySymbols;
    var getSymbols = !nativeGetSymbols$1 ? stubArray : function(object) {
      if (object == null) {
        return [];
      }
      object = Object(object);
      return arrayFilter(nativeGetSymbols$1(object), function(symbol) {
        return propertyIsEnumerable.call(object, symbol);
      });
    };
  
    function copySymbols(source, object) {
      return copyObject(source, getSymbols(source), object);
    }
  
    var nativeGetSymbols = Object.getOwnPropertySymbols;
    var getSymbolsIn = !nativeGetSymbols ? stubArray : function(object) {
      var result = [];
      while (object) {
        arrayPush(result, getSymbols(object));
        object = getPrototype(object);
      }
      return result;
    };
  
    function copySymbolsIn(source, object) {
      return copyObject(source, getSymbolsIn(source), object);
    }
  
    function baseGetAllKeys(object, keysFunc, symbolsFunc) {
      var result = keysFunc(object);
      return isArray$1(object) ? result : arrayPush(result, symbolsFunc(object));
    }
  
    function getAllKeys(object) {
      return baseGetAllKeys(object, keys, getSymbols);
    }
  
    function getAllKeysIn(object) {
      return baseGetAllKeys(object, keysIn, getSymbolsIn);
    }
  
    var DataView = getNative(root, "DataView");
  
    var Promise$1 = getNative(root, "Promise");
  
    var Set$1 = getNative(root, "Set");
  
    var mapTag$8 = "[object Map]";
    var objectTag$2 = "[object Object]";
    var promiseTag = "[object Promise]";
    var setTag$8 = "[object Set]";
    var weakMapTag$2 = "[object WeakMap]";
    var dataViewTag$3 = "[object DataView]";
    var dataViewCtorString = toSource(DataView);
    var mapCtorString = toSource(Map$1);
    var promiseCtorString = toSource(Promise$1);
    var setCtorString = toSource(Set$1);
    var weakMapCtorString = toSource(WeakMap);
    var getTag = baseGetTag;
    if (DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag$3 || Map$1 && getTag(new Map$1()) != mapTag$8 || Promise$1 && getTag(Promise$1.resolve()) != promiseTag || Set$1 && getTag(new Set$1()) != setTag$8 || WeakMap && getTag(new WeakMap()) != weakMapTag$2) {
      getTag = function(value) {
        var result = baseGetTag(value), Ctor = result == objectTag$2 ? value.constructor : void 0, ctorString = Ctor ? toSource(Ctor) : "";
        if (ctorString) {
          switch (ctorString) {
            case dataViewCtorString:
              return dataViewTag$3;
            case mapCtorString:
              return mapTag$8;
            case promiseCtorString:
              return promiseTag;
            case setCtorString:
              return setTag$8;
            case weakMapCtorString:
              return weakMapTag$2;
          }
        }
        return result;
      };
    }
    var getTag$1 = getTag;
  
    var objectProto$c = Object.prototype;
    var hasOwnProperty$c = objectProto$c.hasOwnProperty;
    function initCloneArray(array) {
      var length = array.length, result = new array.constructor(length);
      if (length && typeof array[0] == "string" && hasOwnProperty$c.call(array, "index")) {
        result.index = array.index;
        result.input = array.input;
      }
      return result;
    }
  
    var Uint8Array = root.Uint8Array;
  
    function cloneArrayBuffer(arrayBuffer) {
      var result = new arrayBuffer.constructor(arrayBuffer.byteLength);
      new Uint8Array(result).set(new Uint8Array(arrayBuffer));
      return result;
    }
  
    function cloneDataView(dataView, isDeep) {
      var buffer = isDeep ? cloneArrayBuffer(dataView.buffer) : dataView.buffer;
      return new dataView.constructor(buffer, dataView.byteOffset, dataView.byteLength);
    }
  
    var reFlags$1 = /\w*$/;
    function cloneRegExp(regexp) {
      var result = new regexp.constructor(regexp.source, reFlags$1.exec(regexp));
      result.lastIndex = regexp.lastIndex;
      return result;
    }
  
    var symbolProto$1 = Symbol$1 ? Symbol$1.prototype : void 0;
    var symbolValueOf$1 = symbolProto$1 ? symbolProto$1.valueOf : void 0;
    function cloneSymbol(symbol) {
      return symbolValueOf$1 ? Object(symbolValueOf$1.call(symbol)) : {};
    }
  
    function cloneTypedArray(typedArray, isDeep) {
      var buffer = isDeep ? cloneArrayBuffer(typedArray.buffer) : typedArray.buffer;
      return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length);
    }
  
    var boolTag$3 = "[object Boolean]";
    var dateTag$3 = "[object Date]";
    var mapTag$7 = "[object Map]";
    var numberTag$3 = "[object Number]";
    var regexpTag$3 = "[object RegExp]";
    var setTag$7 = "[object Set]";
    var stringTag$3 = "[object String]";
    var symbolTag$2 = "[object Symbol]";
    var arrayBufferTag$3 = "[object ArrayBuffer]";
    var dataViewTag$2 = "[object DataView]";
    var float32Tag$1 = "[object Float32Array]";
    var float64Tag$1 = "[object Float64Array]";
    var int8Tag$1 = "[object Int8Array]";
    var int16Tag$1 = "[object Int16Array]";
    var int32Tag$1 = "[object Int32Array]";
    var uint8Tag$1 = "[object Uint8Array]";
    var uint8ClampedTag$1 = "[object Uint8ClampedArray]";
    var uint16Tag$1 = "[object Uint16Array]";
    var uint32Tag$1 = "[object Uint32Array]";
    function initCloneByTag(object, tag, isDeep) {
      var Ctor = object.constructor;
      switch (tag) {
        case arrayBufferTag$3:
          return cloneArrayBuffer(object);
        case boolTag$3:
        case dateTag$3:
          return new Ctor(+object);
        case dataViewTag$2:
          return cloneDataView(object, isDeep);
        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, isDeep);
        case mapTag$7:
          return new Ctor();
        case numberTag$3:
        case stringTag$3:
          return new Ctor(object);
        case regexpTag$3:
          return cloneRegExp(object);
        case setTag$7:
          return new Ctor();
        case symbolTag$2:
          return cloneSymbol(object);
      }
    }
  
    function initCloneObject(object) {
      return typeof object.constructor == "function" && !isPrototype(object) ? baseCreate(getPrototype(object)) : {};
    }
  
    var mapTag$6 = "[object Map]";
    function baseIsMap(value) {
      return isObjectLike(value) && getTag$1(value) == mapTag$6;
    }
  
    var nodeIsMap = nodeUtil && nodeUtil.isMap;
    var isMap = nodeIsMap ? baseUnary(nodeIsMap) : baseIsMap;
  
    var setTag$6 = "[object Set]";
    function baseIsSet(value) {
      return isObjectLike(value) && getTag$1(value) == setTag$6;
    }
  
    var nodeIsSet = nodeUtil && nodeUtil.isSet;
    var isSet = nodeIsSet ? baseUnary(nodeIsSet) : baseIsSet;
  
    var CLONE_DEEP_FLAG$7 = 1;
    var CLONE_FLAT_FLAG$1 = 2;
    var CLONE_SYMBOLS_FLAG$5 = 4;
    var argsTag$1 = "[object Arguments]";
    var arrayTag$1 = "[object Array]";
    var boolTag$2 = "[object Boolean]";
    var dateTag$2 = "[object Date]";
    var errorTag$1 = "[object Error]";
    var funcTag = "[object Function]";
    var genTag = "[object GeneratorFunction]";
    var mapTag$5 = "[object Map]";
    var numberTag$2 = "[object Number]";
    var objectTag$1 = "[object Object]";
    var regexpTag$2 = "[object RegExp]";
    var setTag$5 = "[object Set]";
    var stringTag$2 = "[object String]";
    var symbolTag$1 = "[object Symbol]";
    var weakMapTag$1 = "[object WeakMap]";
    var arrayBufferTag$2 = "[object ArrayBuffer]";
    var dataViewTag$1 = "[object DataView]";
    var float32Tag = "[object Float32Array]";
    var float64Tag = "[object Float64Array]";
    var int8Tag = "[object Int8Array]";
    var int16Tag = "[object Int16Array]";
    var int32Tag = "[object Int32Array]";
    var uint8Tag = "[object Uint8Array]";
    var uint8ClampedTag = "[object Uint8ClampedArray]";
    var uint16Tag = "[object Uint16Array]";
    var uint32Tag = "[object Uint32Array]";
    var cloneableTags = {};
    cloneableTags[argsTag$1] = cloneableTags[arrayTag$1] = cloneableTags[arrayBufferTag$2] = cloneableTags[dataViewTag$1] = cloneableTags[boolTag$2] = cloneableTags[dateTag$2] = cloneableTags[float32Tag] = cloneableTags[float64Tag] = cloneableTags[int8Tag] = cloneableTags[int16Tag] = cloneableTags[int32Tag] = cloneableTags[mapTag$5] = cloneableTags[numberTag$2] = cloneableTags[objectTag$1] = cloneableTags[regexpTag$2] = cloneableTags[setTag$5] = cloneableTags[stringTag$2] = cloneableTags[symbolTag$1] = cloneableTags[uint8Tag] = cloneableTags[uint8ClampedTag] = cloneableTags[uint16Tag] = cloneableTags[uint32Tag] = true;
    cloneableTags[errorTag$1] = cloneableTags[funcTag] = cloneableTags[weakMapTag$1] = false;
    function baseClone(value, bitmask, customizer, key, object, stack) {
      var result, isDeep = bitmask & CLONE_DEEP_FLAG$7, isFlat = bitmask & CLONE_FLAT_FLAG$1, isFull = bitmask & CLONE_SYMBOLS_FLAG$5;
      if (customizer) {
        result = object ? customizer(value, key, object, stack) : customizer(value);
      }
      if (result !== void 0) {
        return result;
      }
      if (!isObject$2(value)) {
        return value;
      }
      var isArr = isArray$1(value);
      if (isArr) {
        result = initCloneArray(value);
        if (!isDeep) {
          return copyArray(value, result);
        }
      } else {
        var tag = getTag$1(value), isFunc = tag == funcTag || tag == genTag;
        if (isBuffer(value)) {
          return cloneBuffer(value, isDeep);
        }
        if (tag == objectTag$1 || tag == argsTag$1 || isFunc && !object) {
          result = isFlat || isFunc ? {} : initCloneObject(value);
          if (!isDeep) {
            return isFlat ? copySymbolsIn(value, baseAssignIn(result, value)) : copySymbols(value, baseAssign(result, value));
          }
        } else {
          if (!cloneableTags[tag]) {
            return object ? value : {};
          }
          result = initCloneByTag(value, tag, isDeep);
        }
      }
      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 = isFull ? isFlat ? getAllKeysIn : getAllKeys : isFlat ? keysIn : keys;
      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_SYMBOLS_FLAG$4 = 4;
    function clone(value) {
      return baseClone(value, CLONE_SYMBOLS_FLAG$4);
    }
  
    var CLONE_DEEP_FLAG$6 = 1;
    var CLONE_SYMBOLS_FLAG$3 = 4;
    function cloneDeep(value) {
      return baseClone(value, CLONE_DEEP_FLAG$6 | CLONE_SYMBOLS_FLAG$3);
    }
  
    var CLONE_DEEP_FLAG$5 = 1;
    var CLONE_SYMBOLS_FLAG$2 = 4;
    function cloneDeepWith(value, customizer) {
      customizer = typeof customizer == "function" ? customizer : void 0;
      return baseClone(value, CLONE_DEEP_FLAG$5 | CLONE_SYMBOLS_FLAG$2, customizer);
    }
  
    var CLONE_SYMBOLS_FLAG$1 = 4;
    function cloneWith(value, customizer) {
      customizer = typeof customizer == "function" ? customizer : void 0;
      return baseClone(value, CLONE_SYMBOLS_FLAG$1, customizer);
    }
  
    function wrapperCommit() {
      return new LodashWrapper(this.value(), this.__chain__);
    }
  
    function compact(array) {
      var index = -1, length = array == null ? 0 : array.length, resIndex = 0, result = [];
      while (++index < length) {
        var value = array[index];
        if (value) {
          result[resIndex++] = value;
        }
      }
      return result;
    }
  
    function concat() {
      var length = arguments.length;
      if (!length) {
        return [];
      }
      var args = Array(length - 1), array = arguments[0], index = length;
      while (index--) {
        args[index - 1] = arguments[index];
      }
      return arrayPush(isArray$1(array) ? copyArray(array) : [array], baseFlatten(args, 1));
    }
  
    var HASH_UNDEFINED = "__lodash_hash_undefined__";
    function setCacheAdd(value) {
      this.__data__.set(value, HASH_UNDEFINED);
      return this;
    }
  
    function setCacheHas(value) {
      return this.__data__.has(value);
    }
  
    function SetCache(values) {
      var index = -1, length = values == null ? 0 : values.length;
      this.__data__ = new MapCache();
      while (++index < length) {
        this.add(values[index]);
      }
    }
    SetCache.prototype.add = SetCache.prototype.push = setCacheAdd;
    SetCache.prototype.has = setCacheHas;
  
    function arraySome(array, predicate) {
      var index = -1, length = array == null ? 0 : array.length;
      while (++index < length) {
        if (predicate(array[index], index, array)) {
          return true;
        }
      }
      return false;
    }
  
    function cacheHas(cache, key) {
      return cache.has(key);
    }
  
    var COMPARE_PARTIAL_FLAG$5 = 1;
    var COMPARE_UNORDERED_FLAG$3 = 2;
    function equalArrays(array, other, bitmask, customizer, equalFunc, stack) {
      var isPartial = bitmask & COMPARE_PARTIAL_FLAG$5, arrLength = array.length, othLength = other.length;
      if (arrLength != othLength && !(isPartial && othLength > arrLength)) {
        return false;
      }
      var arrStacked = stack.get(array);
      var othStacked = stack.get(other);
      if (arrStacked && othStacked) {
        return arrStacked == other && othStacked == array;
      }
      var index = -1, result = true, seen = bitmask & COMPARE_UNORDERED_FLAG$3 ? new SetCache() : void 0;
      stack.set(array, other);
      stack.set(other, array);
      while (++index < arrLength) {
        var arrValue = array[index], othValue = other[index];
        if (customizer) {
          var compared = isPartial ? customizer(othValue, arrValue, index, other, array, stack) : customizer(arrValue, othValue, index, array, other, stack);
        }
        if (compared !== void 0) {
          if (compared) {
            continue;
          }
          result = false;
          break;
        }
        if (seen) {
          if (!arraySome(other, function(othValue2, othIndex) {
            if (!cacheHas(seen, othIndex) && (arrValue === othValue2 || equalFunc(arrValue, othValue2, bitmask, customizer, stack))) {
              return seen.push(othIndex);
            }
          })) {
            result = false;
            break;
          }
        } else if (!(arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) {
          result = false;
          break;
        }
      }
      stack["delete"](array);
      stack["delete"](other);
      return result;
    }
  
    function mapToArray(map) {
      var index = -1, result = Array(map.size);
      map.forEach(function(value, key) {
        result[++index] = [key, value];
      });
      return result;
    }
  
    function setToArray(set) {
      var index = -1, result = Array(set.size);
      set.forEach(function(value) {
        result[++index] = value;
      });
      return result;
    }
  
    var COMPARE_PARTIAL_FLAG$4 = 1;
    var COMPARE_UNORDERED_FLAG$2 = 2;
    var boolTag$1 = "[object Boolean]";
    var dateTag$1 = "[object Date]";
    var errorTag = "[object Error]";
    var mapTag$4 = "[object Map]";
    var numberTag$1 = "[object Number]";
    var regexpTag$1 = "[object RegExp]";
    var setTag$4 = "[object Set]";
    var stringTag$1 = "[object String]";
    var symbolTag = "[object Symbol]";
    var arrayBufferTag$1 = "[object ArrayBuffer]";
    var dataViewTag = "[object DataView]";
    var symbolProto = Symbol$1 ? Symbol$1.prototype : void 0;
    var symbolValueOf = symbolProto ? symbolProto.valueOf : void 0;
    function equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack) {
      switch (tag) {
        case dataViewTag:
          if (object.byteLength != other.byteLength || object.byteOffset != other.byteOffset) {
            return false;
          }
          object = object.buffer;
          other = other.buffer;
        case arrayBufferTag$1:
          if (object.byteLength != other.byteLength || !equalFunc(new Uint8Array(object), new Uint8Array(other))) {
            return false;
          }
          return true;
        case boolTag$1:
        case dateTag$1:
        case numberTag$1:
          return eq(+object, +other);
        case errorTag:
          return object.name == other.name && object.message == other.message;
        case regexpTag$1:
        case stringTag$1:
          return object == other + "";
        case mapTag$4:
          var convert = mapToArray;
        case setTag$4:
          var isPartial = bitmask & COMPARE_PARTIAL_FLAG$4;
          convert || (convert = setToArray);
          if (object.size != other.size && !isPartial) {
            return false;
          }
          var stacked = stack.get(object);
          if (stacked) {
            return stacked == other;
          }
          bitmask |= COMPARE_UNORDERED_FLAG$2;
          stack.set(object, other);
          var result = equalArrays(convert(object), convert(other), bitmask, customizer, equalFunc, stack);
          stack["delete"](object);
          return result;
        case symbolTag:
          if (symbolValueOf) {
            return symbolValueOf.call(object) == symbolValueOf.call(other);
          }
      }
      return false;
    }
  
    var COMPARE_PARTIAL_FLAG$3 = 1;
    var objectProto$b = Object.prototype;
    var hasOwnProperty$b = objectProto$b.hasOwnProperty;
    function equalObjects(object, other, bitmask, customizer, equalFunc, stack) {
      var isPartial = bitmask & COMPARE_PARTIAL_FLAG$3, objProps = getAllKeys(object), objLength = objProps.length, othProps = getAllKeys(other), othLength = othProps.length;
      if (objLength != othLength && !isPartial) {
        return false;
      }
      var index = objLength;
      while (index--) {
        var key = objProps[index];
        if (!(isPartial ? key in other : hasOwnProperty$b.call(other, key))) {
          return false;
        }
      }
      var objStacked = stack.get(object);
      var othStacked = stack.get(other);
      if (objStacked && othStacked) {
        return objStacked == other && othStacked == object;
      }
      var result = true;
      stack.set(object, other);
      stack.set(other, object);
      var skipCtor = isPartial;
      while (++index < objLength) {
        key = objProps[index];
        var objValue = object[key], othValue = other[key];
        if (customizer) {
          var compared = isPartial ? customizer(othValue, objValue, key, other, object, stack) : customizer(objValue, othValue, key, object, other, stack);
        }
        if (!(compared === void 0 ? objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack) : compared)) {
          result = false;
          break;
        }
        skipCtor || (skipCtor = key == "constructor");
      }
      if (result && !skipCtor) {
        var objCtor = object.constructor, othCtor = other.constructor;
        if (objCtor != othCtor && ("constructor" in object && "constructor" in other) && !(typeof objCtor == "function" && objCtor instanceof objCtor && typeof othCtor == "function" && othCtor instanceof othCtor)) {
          result = false;
        }
      }
      stack["delete"](object);
      stack["delete"](other);
      return result;
    }
  
    var COMPARE_PARTIAL_FLAG$2 = 1;
    var argsTag = "[object Arguments]";
    var arrayTag = "[object Array]";
    var objectTag = "[object Object]";
    var objectProto$a = Object.prototype;
    var hasOwnProperty$a = objectProto$a.hasOwnProperty;
    function baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) {
      var objIsArr = isArray$1(object), othIsArr = isArray$1(other), objTag = objIsArr ? arrayTag : getTag$1(object), othTag = othIsArr ? arrayTag : getTag$1(other);
      objTag = objTag == argsTag ? objectTag : objTag;
      othTag = othTag == argsTag ? objectTag : othTag;
      var objIsObj = objTag == objectTag, othIsObj = othTag == objectTag, isSameTag = objTag == othTag;
      if (isSameTag && isBuffer(object)) {
        if (!isBuffer(other)) {
          return false;
        }
        objIsArr = true;
        objIsObj = false;
      }
      if (isSameTag && !objIsObj) {
        stack || (stack = new Stack());
        return objIsArr || isTypedArray(object) ? equalArrays(object, other, bitmask, customizer, equalFunc, stack) : equalByTag(object, other, objTag, bitmask, customizer, equalFunc, stack);
      }
      if (!(bitmask & COMPARE_PARTIAL_FLAG$2)) {
        var objIsWrapped = objIsObj && hasOwnProperty$a.call(object, "__wrapped__"), othIsWrapped = othIsObj && hasOwnProperty$a.call(other, "__wrapped__");
        if (objIsWrapped || othIsWrapped) {
          var objUnwrapped = objIsWrapped ? object.value() : object, othUnwrapped = othIsWrapped ? other.value() : other;
          stack || (stack = new Stack());
          return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack);
        }
      }
      if (!isSameTag) {
        return false;
      }
      stack || (stack = new Stack());
      return equalObjects(object, other, bitmask, customizer, equalFunc, stack);
    }
  
    function baseIsEqual(value, other, bitmask, customizer, stack) {
      if (value === other) {
        return true;
      }
      if (value == null || other == null || !isObjectLike(value) && !isObjectLike(other)) {
        return value !== value && other !== other;
      }
      return baseIsEqualDeep(value, other, bitmask, customizer, baseIsEqual, stack);
    }
  
    var COMPARE_PARTIAL_FLAG$1 = 1;
    var COMPARE_UNORDERED_FLAG$1 = 2;
    function baseIsMatch(object, source, matchData, customizer) {
      var index = matchData.length, length = index, noCustomizer = !customizer;
      if (object == null) {
        return !length;
      }
      object = Object(object);
      while (index--) {
        var data = matchData[index];
        if (noCustomizer && data[2] ? data[1] !== object[data[0]] : !(data[0] in object)) {
          return false;
        }
      }
      while (++index < length) {
        data = matchData[index];
        var key = data[0], objValue = object[key], srcValue = data[1];
        if (noCustomizer && data[2]) {
          if (objValue === void 0 && !(key in object)) {
            return false;
          }
        } else {
          var stack = new Stack();
          if (customizer) {
            var result = customizer(objValue, srcValue, key, object, source, stack);
          }
          if (!(result === void 0 ? baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG$1 | COMPARE_UNORDERED_FLAG$1, customizer, stack) : result)) {
            return false;
          }
        }
      }
      return true;
    }
  
    function isStrictComparable(value) {
      return value === value && !isObject$2(value);
    }
  
    function getMatchData(object) {
      var result = keys(object), length = result.length;
      while (length--) {
        var key = result[length], value = object[key];
        result[length] = [key, value, isStrictComparable(value)];
      }
      return result;
    }
  
    function matchesStrictComparable(key, srcValue) {
      return function(object) {
        if (object == null) {
          return false;
        }
        return object[key] === srcValue && (srcValue !== void 0 || key in Object(object));
      };
    }
  
    function baseMatches(source) {
      var matchData = getMatchData(source);
      if (matchData.length == 1 && matchData[0][2]) {
        return matchesStrictComparable(matchData[0][0], matchData[0][1]);
      }
      return function(object) {
        return object === source || baseIsMatch(object, source, matchData);
      };
    }
  
    function baseHasIn(object, key) {
      return object != null && key in Object(object);
    }
  
    function hasPath(object, path, hasFunc) {
      path = castPath(path, object);
      var index = -1, length = path.length, result = false;
      while (++index < length) {
        var key = toKey(path[index]);
        if (!(result = object != null && hasFunc(object, key))) {
          break;
        }
        object = object[key];
      }
      if (result || ++index != length) {
        return result;
      }
      length = object == null ? 0 : object.length;
      return !!length && isLength(length) && isIndex(key, length) && (isArray$1(object) || isArguments(object));
    }
  
    function hasIn(object, path) {
      return object != null && hasPath(object, path, baseHasIn);
    }
  
    var COMPARE_PARTIAL_FLAG = 1;
    var COMPARE_UNORDERED_FLAG = 2;
    function baseMatchesProperty(path, srcValue) {
      if (isKey(path) && isStrictComparable(srcValue)) {
        return matchesStrictComparable(toKey(path), srcValue);
      }
      return function(object) {
        var objValue = get(object, path);
        return objValue === void 0 && objValue === srcValue ? hasIn(object, path) : baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG);
      };
    }
  
    function baseProperty(key) {
      return function(object) {
        return object == null ? void 0 : object[key];
      };
    }
  
    function basePropertyDeep(path) {
      return function(object) {
        return baseGet(object, path);
      };
    }
  
    function property(path) {
      return isKey(path) ? baseProperty(toKey(path)) : basePropertyDeep(path);
    }
  
    function baseIteratee(value) {
      if (typeof value == "function") {
        return value;
      }
      if (value == null) {
        return identity$1;
      }
      if (typeof value == "object") {
        return isArray$1(value) ? baseMatchesProperty(value[0], value[1]) : baseMatches(value);
      }
      return property(value);
    }
  
    var FUNC_ERROR_TEXT$7 = "Expected a function";
    function cond(pairs) {
      var length = pairs == null ? 0 : pairs.length, toIteratee = baseIteratee;
      pairs = !length ? [] : arrayMap(pairs, function(pair) {
        if (typeof pair[1] != "function") {
          throw new TypeError(FUNC_ERROR_TEXT$7);
        }
        return [toIteratee(pair[0]), pair[1]];
      });
      return baseRest(function(args) {
        var index = -1;
        while (++index < length) {
          var pair = pairs[index];
          if (apply(pair[0], this, args)) {
            return apply(pair[1], this, args);
          }
        }
      });
    }
  
    function baseConformsTo(object, source, props) {
      var length = props.length;
      if (object == null) {
        return !length;
      }
      object = Object(object);
      while (length--) {
        var key = props[length], predicate = source[key], value = object[key];
        if (value === void 0 && !(key in object) || !predicate(value)) {
          return false;
        }
      }
      return true;
    }
  
    function baseConforms(source) {
      var props = keys(source);
      return function(object) {
        return baseConformsTo(object, source, props);
      };
    }
  
    var CLONE_DEEP_FLAG$4 = 1;
    function conforms(source) {
      return baseConforms(baseClone(source, CLONE_DEEP_FLAG$4));
    }
  
    function conformsTo(object, source) {
      return source == null || baseConformsTo(object, source, keys(source));
    }
  
    function arrayAggregator(array, setter, iteratee, accumulator) {
      var index = -1, length = array == null ? 0 : array.length;
      while (++index < length) {
        var value = array[index];
        setter(accumulator, value, iteratee(value), array);
      }
      return accumulator;
    }
  
    function createBaseFor(fromRight) {
      return function(object, iteratee, keysFunc) {
        var index = -1, iterable = Object(object), props = keysFunc(object), length = props.length;
        while (length--) {
          var key = props[fromRight ? length : ++index];
          if (iteratee(iterable[key], key, iterable) === false) {
            break;
          }
        }
        return object;
      };
    }
  
    var baseFor = createBaseFor();
  
    function baseForOwn(object, iteratee) {
      return object && baseFor(object, iteratee, keys);
    }
  
    function createBaseEach(eachFunc, fromRight) {
      return function(collection, iteratee) {
        if (collection == null) {
          return collection;
        }
        if (!isArrayLike(collection)) {
          return eachFunc(collection, iteratee);
        }
        var length = collection.length, index = fromRight ? length : -1, iterable = Object(collection);
        while (fromRight ? index-- : ++index < length) {
          if (iteratee(iterable[index], index, iterable) === false) {
            break;
          }
        }
        return collection;
      };
    }
  
    var baseEach = createBaseEach(baseForOwn);
  
    function baseAggregator(collection, setter, iteratee, accumulator) {
      baseEach(collection, function(value, key, collection2) {
        setter(accumulator, value, iteratee(value), collection2);
      });
      return accumulator;
    }
  
    function createAggregator(setter, initializer) {
      return function(collection, iteratee) {
        var func = isArray$1(collection) ? arrayAggregator : baseAggregator, accumulator = initializer ? initializer() : {};
        return func(collection, setter, baseIteratee(iteratee), accumulator);
      };
    }
  
    var objectProto$9 = Object.prototype;
    var hasOwnProperty$9 = objectProto$9.hasOwnProperty;
    var countBy = createAggregator(function(result, value, key) {
      if (hasOwnProperty$9.call(result, key)) {
        ++result[key];
      } else {
        baseAssignValue(result, key, 1);
      }
    });
  
    function create(prototype, properties) {
      var result = baseCreate(prototype);
      return properties == null ? result : baseAssign(result, properties);
    }
  
    var WRAP_CURRY_FLAG$1 = 8;
    function curry(func, arity, guard) {
      arity = guard ? void 0 : arity;
      var result = createWrap(func, WRAP_CURRY_FLAG$1, void 0, void 0, void 0, void 0, void 0, arity);
      result.placeholder = curry.placeholder;
      return result;
    }
    curry.placeholder = {};
  
    var WRAP_CURRY_RIGHT_FLAG = 16;
    function curryRight(func, arity, guard) {
      arity = guard ? void 0 : arity;
      var result = createWrap(func, WRAP_CURRY_RIGHT_FLAG, void 0, void 0, void 0, void 0, void 0, arity);
      result.placeholder = curryRight.placeholder;
      return result;
    }
    curryRight.placeholder = {};
  
    var now = function() {
      return root.Date.now();
    };
  
    var FUNC_ERROR_TEXT$6 = "Expected a function";
    var nativeMax$b = Math.max;
    var nativeMin$b = Math.min;
    function debounce(func, wait, options) {
      var lastArgs, lastThis, maxWait, result, timerId, lastCallTime, lastInvokeTime = 0, leading = false, maxing = false, trailing = true;
      if (typeof func != "function") {
        throw new TypeError(FUNC_ERROR_TEXT$6);
      }
      wait = toNumber(wait) || 0;
      if (isObject$2(options)) {
        leading = !!options.leading;
        maxing = "maxWait" in options;
        maxWait = maxing ? nativeMax$b(toNumber(options.maxWait) || 0, wait) : maxWait;
        trailing = "trailing" in options ? !!options.trailing : trailing;
      }
      function invokeFunc(time) {
        var args = lastArgs, thisArg = lastThis;
        lastArgs = lastThis = void 0;
        lastInvokeTime = time;
        result = func.apply(thisArg, args);
        return result;
      }
      function leadingEdge(time) {
        lastInvokeTime = time;
        timerId = setTimeout(timerExpired, wait);
        return leading ? invokeFunc(time) : result;
      }
      function remainingWait(time) {
        var timeSinceLastCall = time - lastCallTime, timeSinceLastInvoke = time - lastInvokeTime, timeWaiting = wait - timeSinceLastCall;
        return maxing ? nativeMin$b(timeWaiting, maxWait - timeSinceLastInvoke) : timeWaiting;
      }
      function shouldInvoke(time) {
        var timeSinceLastCall = time - lastCallTime, timeSinceLastInvoke = time - lastInvokeTime;
        return lastCallTime === void 0 || timeSinceLastCall >= wait || timeSinceLastCall < 0 || maxing && timeSinceLastInvoke >= maxWait;
      }
      function timerExpired() {
        var time = now();
        if (shouldInvoke(time)) {
          return trailingEdge(time);
        }
        timerId = setTimeout(timerExpired, remainingWait(time));
      }
      function trailingEdge(time) {
        timerId = void 0;
        if (trailing && lastArgs) {
          return invokeFunc(time);
        }
        lastArgs = lastThis = void 0;
        return result;
      }
      function cancel() {
        if (timerId !== void 0) {
          clearTimeout(timerId);
        }
        lastInvokeTime = 0;
        lastArgs = lastCallTime = lastThis = timerId = void 0;
      }
      function flush() {
        return timerId === void 0 ? result : trailingEdge(now());
      }
      function debounced() {
        var time = now(), isInvoking = shouldInvoke(time);
        lastArgs = arguments;
        lastThis = this;
        lastCallTime = time;
        if (isInvoking) {
          if (timerId === void 0) {
            return leadingEdge(lastCallTime);
          }
          if (maxing) {
            clearTimeout(timerId);
            timerId = setTimeout(timerExpired, wait);
            return invokeFunc(lastCallTime);
          }
        }
        if (timerId === void 0) {
          timerId = setTimeout(timerExpired, wait);
        }
        return result;
      }
      debounced.cancel = cancel;
      debounced.flush = flush;
      return debounced;
    }
  
    function defaultTo(value, defaultValue) {
      return value == null || value !== value ? defaultValue : value;
    }
  
    var objectProto$8 = Object.prototype;
    var hasOwnProperty$8 = objectProto$8.hasOwnProperty;
    var defaults = baseRest(function(object, sources) {
      object = Object(object);
      var index = -1;
      var length = sources.length;
      var guard = length > 2 ? sources[2] : void 0;
      if (guard && isIterateeCall(sources[0], sources[1], guard)) {
        length = 1;
      }
      while (++index < length) {
        var source = sources[index];
        var props = keysIn(source);
        var propsIndex = -1;
        var propsLength = props.length;
        while (++propsIndex < propsLength) {
          var key = props[propsIndex];
          var value = object[key];
          if (value === void 0 || eq(value, objectProto$8[key]) && !hasOwnProperty$8.call(object, key)) {
            object[key] = source[key];
          }
        }
      }
      return object;
    });
  
    function assignMergeValue(object, key, value) {
      if (value !== void 0 && !eq(object[key], value) || value === void 0 && !(key in object)) {
        baseAssignValue(object, key, value);
      }
    }
  
    function isArrayLikeObject(value) {
      return isObjectLike(value) && isArrayLike(value);
    }
  
    function safeGet(object, key) {
      if (key === "constructor" && typeof object[key] === "function") {
        return;
      }
      if (key == "__proto__") {
        return;
      }
      return object[key];
    }
  
    function toPlainObject(value) {
      return copyObject(value, keysIn(value));
    }
  
    function baseMergeDeep(object, source, key, srcIndex, mergeFunc, customizer, stack) {
      var objValue = safeGet(object, key), srcValue = safeGet(source, key), stacked = stack.get(srcValue);
      if (stacked) {
        assignMergeValue(object, key, stacked);
        return;
      }
      var newValue = customizer ? customizer(objValue, srcValue, key + "", object, source, stack) : void 0;
      var isCommon = newValue === void 0;
      if (isCommon) {
        var isArr = isArray$1(srcValue), isBuff = !isArr && isBuffer(srcValue), isTyped = !isArr && !isBuff && isTypedArray(srcValue);
        newValue = srcValue;
        if (isArr || isBuff || isTyped) {
          if (isArray$1(objValue)) {
            newValue = objValue;
          } else if (isArrayLikeObject(objValue)) {
            newValue = copyArray(objValue);
          } else if (isBuff) {
            isCommon = false;
            newValue = cloneBuffer(srcValue, true);
          } else if (isTyped) {
            isCommon = false;
            newValue = cloneTypedArray(srcValue, true);
          } else {
            newValue = [];
          }
        } else if (isPlainObject(srcValue) || isArguments(srcValue)) {
          newValue = objValue;
          if (isArguments(objValue)) {
            newValue = toPlainObject(objValue);
          } else if (!isObject$2(objValue) || isFunction$1(objValue)) {
            newValue = initCloneObject(srcValue);
          }
        } else {
          isCommon = false;
        }
      }
      if (isCommon) {
        stack.set(srcValue, newValue);
        mergeFunc(newValue, srcValue, srcIndex, customizer, stack);
        stack["delete"](srcValue);
      }
      assignMergeValue(object, key, newValue);
    }
  
    function baseMerge(object, source, srcIndex, customizer, stack) {
      if (object === source) {
        return;
      }
      baseFor(source, function(srcValue, key) {
        stack || (stack = new Stack());
        if (isObject$2(srcValue)) {
          baseMergeDeep(object, source, key, srcIndex, baseMerge, customizer, stack);
        } else {
          var newValue = customizer ? customizer(safeGet(object, key), srcValue, key + "", object, source, stack) : void 0;
          if (newValue === void 0) {
            newValue = srcValue;
          }
          assignMergeValue(object, key, newValue);
        }
      }, keysIn);
    }
  
    function customDefaultsMerge(objValue, srcValue, key, object, source, stack) {
      if (isObject$2(objValue) && isObject$2(srcValue)) {
        stack.set(srcValue, objValue);
        baseMerge(objValue, srcValue, void 0, customDefaultsMerge, stack);
        stack["delete"](srcValue);
      }
      return objValue;
    }
  
    var mergeWith = createAssigner(function(object, source, srcIndex, customizer) {
      baseMerge(object, source, srcIndex, customizer);
    });
  
    var defaultsDeep = baseRest(function(args) {
      args.push(void 0, customDefaultsMerge);
      return apply(mergeWith, void 0, args);
    });
  
    var FUNC_ERROR_TEXT$5 = "Expected a function";
    function baseDelay(func, wait, args) {
      if (typeof func != "function") {
        throw new TypeError(FUNC_ERROR_TEXT$5);
      }
      return setTimeout(function() {
        func.apply(void 0, args);
      }, wait);
    }
  
    var defer = baseRest(function(func, args) {
      return baseDelay(func, 1, args);
    });
  
    var delay = baseRest(function(func, wait, args) {
      return baseDelay(func, toNumber(wait) || 0, args);
    });
  
    function arrayIncludesWith(array, value, comparator) {
      var index = -1, length = array == null ? 0 : array.length;
      while (++index < length) {
        if (comparator(value, array[index])) {
          return true;
        }
      }
      return false;
    }
  
    var LARGE_ARRAY_SIZE$1 = 200;
    function baseDifference(array, values, iteratee, comparator) {
      var index = -1, includes = arrayIncludes, isCommon = true, length = array.length, result = [], valuesLength = values.length;
      if (!length) {
        return result;
      }
      if (iteratee) {
        values = arrayMap(values, baseUnary(iteratee));
      }
      if (comparator) {
        includes = arrayIncludesWith;
        isCommon = false;
      } else if (values.length >= LARGE_ARRAY_SIZE$1) {
        includes = cacheHas;
        isCommon = false;
        values = new SetCache(values);
      }
      outer:
        while (++index < length) {
          var value = array[index], computed = iteratee == null ? value : iteratee(value);
          value = comparator || value !== 0 ? value : 0;
          if (isCommon && computed === computed) {
            var valuesIndex = valuesLength;
            while (valuesIndex--) {
              if (values[valuesIndex] === computed) {
                continue outer;
              }
            }
            result.push(value);
          } else if (!includes(values, computed, comparator)) {
            result.push(value);
          }
        }
      return result;
    }
  
    var difference = baseRest(function(array, values) {
      return isArrayLikeObject(array) ? baseDifference(array, baseFlatten(values, 1, isArrayLikeObject, true)) : [];
    });
  
    function last(array) {
      var length = array == null ? 0 : array.length;
      return length ? array[length - 1] : void 0;
    }
  
    var differenceBy = baseRest(function(array, values) {
      var iteratee = last(values);
      if (isArrayLikeObject(iteratee)) {
        iteratee = void 0;
      }
      return isArrayLikeObject(array) ? baseDifference(array, baseFlatten(values, 1, isArrayLikeObject, true), baseIteratee(iteratee)) : [];
    });
  
    var differenceWith = baseRest(function(array, values) {
      var comparator = last(values);
      if (isArrayLikeObject(comparator)) {
        comparator = void 0;
      }
      return isArrayLikeObject(array) ? baseDifference(array, baseFlatten(values, 1, isArrayLikeObject, true), void 0, comparator) : [];
    });
  
    var divide = createMathOperation(function(dividend, divisor) {
      return dividend / divisor;
    }, 1);
  
    function drop(array, n, guard) {
      var length = array == null ? 0 : array.length;
      if (!length) {
        return [];
      }
      n = guard || n === void 0 ? 1 : toInteger(n);
      return baseSlice(array, n < 0 ? 0 : n, length);
    }
  
    function dropRight(array, n, guard) {
      var length = array == null ? 0 : array.length;
      if (!length) {
        return [];
      }
      n = guard || n === void 0 ? 1 : toInteger(n);
      n = length - n;
      return baseSlice(array, 0, n < 0 ? 0 : n);
    }
  
    function baseWhile(array, predicate, isDrop, fromRight) {
      var length = array.length, index = fromRight ? length : -1;
      while ((fromRight ? index-- : ++index < length) && predicate(array[index], index, array)) {
      }
      return isDrop ? baseSlice(array, fromRight ? 0 : index, fromRight ? index + 1 : length) : baseSlice(array, fromRight ? index + 1 : 0, fromRight ? length : index);
    }
  
    function dropRightWhile(array, predicate) {
      return array && array.length ? baseWhile(array, baseIteratee(predicate), true, true) : [];
    }
  
    function dropWhile(array, predicate) {
      return array && array.length ? baseWhile(array, baseIteratee(predicate), true) : [];
    }
  
    function castFunction(value) {
      return typeof value == "function" ? value : identity$1;
    }
  
    function forEach(collection, iteratee) {
      var func = isArray$1(collection) ? arrayEach : baseEach;
      return func(collection, castFunction(iteratee));
    }
  
    function arrayEachRight(array, iteratee) {
      var length = array == null ? 0 : array.length;
      while (length--) {
        if (iteratee(array[length], length, array) === false) {
          break;
        }
      }
      return array;
    }
  
    var baseForRight = createBaseFor(true);
  
    function baseForOwnRight(object, iteratee) {
      return object && baseForRight(object, iteratee, keys);
    }
  
    var baseEachRight = createBaseEach(baseForOwnRight, true);
  
    function forEachRight(collection, iteratee) {
      var func = isArray$1(collection) ? arrayEachRight : baseEachRight;
      return func(collection, castFunction(iteratee));
    }
  
    function endsWith(string, target, position) {
      string = toString(string);
      target = baseToString(target);
      var length = string.length;
      position = position === void 0 ? length : baseClamp(toInteger(position), 0, length);
      var end = position;
      position -= target.length;
      return position >= 0 && string.slice(position, end) == target;
    }
  
    function baseToPairs(object, props) {
      return arrayMap(props, function(key) {
        return [key, object[key]];
      });
    }
  
    function setToPairs(set) {
      var index = -1, result = Array(set.size);
      set.forEach(function(value) {
        result[++index] = [value, value];
      });
      return result;
    }
  
    var mapTag$3 = "[object Map]";
    var setTag$3 = "[object Set]";
    function createToPairs(keysFunc) {
      return function(object) {
        var tag = getTag$1(object);
        if (tag == mapTag$3) {
          return mapToArray(object);
        }
        if (tag == setTag$3) {
          return setToPairs(object);
        }
        return baseToPairs(object, keysFunc(object));
      };
    }
  
    var toPairs = createToPairs(keys);
  
    var toPairsIn = createToPairs(keysIn);
  
    var htmlEscapes = {
      "&": "&amp;",
      "<": "&lt;",
      ">": "&gt;",
      '"': "&quot;",
      "'": "&#39;"
    };
    var escapeHtmlChar = basePropertyOf(htmlEscapes);
  
    var reUnescapedHtml = /[&<>"']/g;
    var reHasUnescapedHtml = RegExp(reUnescapedHtml.source);
    function escape(string) {
      string = toString(string);
      return string && reHasUnescapedHtml.test(string) ? string.replace(reUnescapedHtml, escapeHtmlChar) : string;
    }
  
    var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
    var reHasRegExpChar = RegExp(reRegExpChar.source);
    function escapeRegExp(string) {
      string = toString(string);
      return string && reHasRegExpChar.test(string) ? string.replace(reRegExpChar, "\\$&") : string;
    }
  
    function arrayEvery(array, predicate) {
      var index = -1, length = array == null ? 0 : array.length;
      while (++index < length) {
        if (!predicate(array[index], index, array)) {
          return false;
        }
      }
      return true;
    }
  
    function baseEvery(collection, predicate) {
      var result = true;
      baseEach(collection, function(value, index, collection2) {
        result = !!predicate(value, index, collection2);
        return result;
      });
      return result;
    }
  
    function every(collection, predicate, guard) {
      var func = isArray$1(collection) ? arrayEvery : baseEvery;
      if (guard && isIterateeCall(collection, predicate, guard)) {
        predicate = void 0;
      }
      return func(collection, baseIteratee(predicate));
    }
  
    var MAX_ARRAY_LENGTH$5 = 4294967295;
    function toLength(value) {
      return value ? baseClamp(toInteger(value), 0, MAX_ARRAY_LENGTH$5) : 0;
    }
  
    function baseFill(array, value, start, end) {
      var length = array.length;
      start = toInteger(start);
      if (start < 0) {
        start = -start > length ? 0 : length + start;
      }
      end = end === void 0 || end > length ? length : toInteger(end);
      if (end < 0) {
        end += length;
      }
      end = start > end ? 0 : toLength(end);
      while (start < end) {
        array[start++] = value;
      }
      return array;
    }
  
    function fill(array, value, start, end) {
      var length = array == null ? 0 : array.length;
      if (!length) {
        return [];
      }
      if (start && typeof start != "number" && isIterateeCall(array, value, start)) {
        start = 0;
        end = length;
      }
      return baseFill(array, value, start, end);
    }
  
    function baseFilter(collection, predicate) {
      var result = [];
      baseEach(collection, function(value, index, collection2) {
        if (predicate(value, index, collection2)) {
          result.push(value);
        }
      });
      return result;
    }
  
    function filter(collection, predicate) {
      var func = isArray$1(collection) ? arrayFilter : baseFilter;
      return func(collection, baseIteratee(predicate));
    }
  
    function createFind(findIndexFunc) {
      return function(collection, predicate, fromIndex) {
        var iterable = Object(collection);
        if (!isArrayLike(collection)) {
          var iteratee = baseIteratee(predicate);
          collection = keys(collection);
          predicate = function(key) {
            return iteratee(iterable[key], key, iterable);
          };
        }
        var index = findIndexFunc(collection, predicate, fromIndex);
        return index > -1 ? iterable[iteratee ? collection[index] : index] : void 0;
      };
    }
  
    var nativeMax$a = Math.max;
    function findIndex(array, predicate, fromIndex) {
      var length = array == null ? 0 : array.length;
      if (!length) {
        return -1;
      }
      var index = fromIndex == null ? 0 : toInteger(fromIndex);
      if (index < 0) {
        index = nativeMax$a(length + index, 0);
      }
      return baseFindIndex(array, baseIteratee(predicate), index);
    }
  
    var find = createFind(findIndex);
  
    function baseFindKey(collection, predicate, eachFunc) {
      var result;
      eachFunc(collection, function(value, key, collection2) {
        if (predicate(value, key, collection2)) {
          result = key;
          return false;
        }
      });
      return result;
    }
  
    function findKey(object, predicate) {
      return baseFindKey(object, baseIteratee(predicate), baseForOwn);
    }
  
    var nativeMax$9 = Math.max;
    var nativeMin$a = Math.min;
    function findLastIndex(array, predicate, fromIndex) {
      var length = array == null ? 0 : array.length;
      if (!length) {
        return -1;
      }
      var index = length - 1;
      if (fromIndex !== void 0) {
        index = toInteger(fromIndex);
        index = fromIndex < 0 ? nativeMax$9(length + index, 0) : nativeMin$a(index, length - 1);
      }
      return baseFindIndex(array, baseIteratee(predicate), index, true);
    }
  
    var findLast = createFind(findLastIndex);
  
    function findLastKey(object, predicate) {
      return baseFindKey(object, baseIteratee(predicate), baseForOwnRight);
    }
  
    function head(array) {
      return array && array.length ? array[0] : void 0;
    }
  
    function baseMap(collection, iteratee) {
      var index = -1, result = isArrayLike(collection) ? Array(collection.length) : [];
      baseEach(collection, function(value, key, collection2) {
        result[++index] = iteratee(value, key, collection2);
      });
      return result;
    }
  
    function map(collection, iteratee) {
      var func = isArray$1(collection) ? arrayMap : baseMap;
      return func(collection, baseIteratee(iteratee));
    }
  
    function flatMap(collection, iteratee) {
      return baseFlatten(map(collection, iteratee), 1);
    }
  
    var INFINITY$2 = 1 / 0;
    function flatMapDeep(collection, iteratee) {
      return baseFlatten(map(collection, iteratee), INFINITY$2);
    }
  
    function flatMapDepth(collection, iteratee, depth) {
      depth = depth === void 0 ? 1 : toInteger(depth);
      return baseFlatten(map(collection, iteratee), depth);
    }
  
    var INFINITY$1 = 1 / 0;
    function flattenDeep(array) {
      var length = array == null ? 0 : array.length;
      return length ? baseFlatten(array, INFINITY$1) : [];
    }
  
    function flattenDepth(array, depth) {
      var length = array == null ? 0 : array.length;
      if (!length) {
        return [];
      }
      depth = depth === void 0 ? 1 : toInteger(depth);
      return baseFlatten(array, depth);
    }
  
    var WRAP_FLIP_FLAG = 512;
    function flip(func) {
      return createWrap(func, WRAP_FLIP_FLAG);
    }
  
    var floor$1 = createRound("floor");
  
    var FUNC_ERROR_TEXT$4 = "Expected a function";
    var WRAP_CURRY_FLAG = 8;
    var WRAP_PARTIAL_FLAG$1 = 32;
    var WRAP_ARY_FLAG = 128;
    var WRAP_REARG_FLAG$1 = 256;
    function createFlow(fromRight) {
      return flatRest(function(funcs) {
        var length = funcs.length, index = length, prereq = LodashWrapper.prototype.thru;
        if (fromRight) {
          funcs.reverse();
        }
        while (index--) {
          var func = funcs[index];
          if (typeof func != "function") {
            throw new TypeError(FUNC_ERROR_TEXT$4);
          }
          if (prereq && !wrapper && getFuncName(func) == "wrapper") {
            var wrapper = new LodashWrapper([], true);
          }
        }
        index = wrapper ? index : length;
        while (++index < length) {
          func = funcs[index];
          var funcName = getFuncName(func), data = funcName == "wrapper" ? getData(func) : void 0;
          if (data && isLaziable(data[0]) && data[1] == (WRAP_ARY_FLAG | WRAP_CURRY_FLAG | WRAP_PARTIAL_FLAG$1 | WRAP_REARG_FLAG$1) && !data[4].length && data[9] == 1) {
            wrapper = wrapper[getFuncName(data[0])].apply(wrapper, data[3]);
          } else {
            wrapper = func.length == 1 && isLaziable(func) ? wrapper[funcName]() : wrapper.thru(func);
          }
        }
        return function() {
          var args = arguments, value = args[0];
          if (wrapper && args.length == 1 && isArray$1(value)) {
            return wrapper.plant(value).value();
          }
          var index2 = 0, result = length ? funcs[index2].apply(this, args) : value;
          while (++index2 < length) {
            result = funcs[index2].call(this, result);
          }
          return result;
        };
      });
    }
  
    var flow = createFlow();
  
    var flowRight = createFlow(true);
  
    function forIn(object, iteratee) {
      return object == null ? object : baseFor(object, castFunction(iteratee), keysIn);
    }
  
    function forInRight(object, iteratee) {
      return object == null ? object : baseForRight(object, castFunction(iteratee), keysIn);
    }
  
    function forOwn(object, iteratee) {
      return object && baseForOwn(object, castFunction(iteratee));
    }
  
    function forOwnRight(object, iteratee) {
      return object && baseForOwnRight(object, castFunction(iteratee));
    }
  
    function fromPairs(pairs) {
      var index = -1, length = pairs == null ? 0 : pairs.length, result = {};
      while (++index < length) {
        var pair = pairs[index];
        result[pair[0]] = pair[1];
      }
      return result;
    }
  
    function baseFunctions(object, props) {
      return arrayFilter(props, function(key) {
        return isFunction$1(object[key]);
      });
    }
  
    function functions(object) {
      return object == null ? [] : baseFunctions(object, keys(object));
    }
  
    function functionsIn(object) {
      return object == null ? [] : baseFunctions(object, keysIn(object));
    }
  
    var objectProto$7 = Object.prototype;
    var hasOwnProperty$7 = objectProto$7.hasOwnProperty;
    var groupBy = createAggregator(function(result, value, key) {
      if (hasOwnProperty$7.call(result, key)) {
        result[key].push(value);
      } else {
        baseAssignValue(result, key, [value]);
      }
    });
  
    function baseGt(value, other) {
      return value > other;
    }
  
    function createRelationalOperation(operator) {
      return function(value, other) {
        if (!(typeof value == "string" && typeof other == "string")) {
          value = toNumber(value);
          other = toNumber(other);
        }
        return operator(value, other);
      };
    }
  
    var gt$1 = createRelationalOperation(baseGt);
  
    var gte = createRelationalOperation(function(value, other) {
      return value >= other;
    });
  
    var objectProto$6 = Object.prototype;
    var hasOwnProperty$6 = objectProto$6.hasOwnProperty;
    function baseHas(object, key) {
      return object != null && hasOwnProperty$6.call(object, key);
    }
  
    function has(object, path) {
      return object != null && hasPath(object, path, baseHas);
    }
  
    var nativeMax$8 = Math.max;
    var nativeMin$9 = Math.min;
    function baseInRange(number, start, end) {
      return number >= nativeMin$9(start, end) && number < nativeMax$8(start, end);
    }
  
    function inRange(number, start, end) {
      start = toFinite(start);
      if (end === void 0) {
        end = start;
        start = 0;
      } else {
        end = toFinite(end);
      }
      number = toNumber(number);
      return baseInRange(number, start, end);
    }
  
    var stringTag = "[object String]";
    function isString$2(value) {
      return typeof value == "string" || !isArray$1(value) && isObjectLike(value) && baseGetTag(value) == stringTag;
    }
  
    function baseValues(object, props) {
      return arrayMap(props, function(key) {
        return object[key];
      });
    }
  
    function values(object) {
      return object == null ? [] : baseValues(object, keys(object));
    }
  
    var nativeMax$7 = Math.max;
    function includes(collection, value, fromIndex, guard) {
      collection = isArrayLike(collection) ? collection : values(collection);
      fromIndex = fromIndex && !guard ? toInteger(fromIndex) : 0;
      var length = collection.length;
      if (fromIndex < 0) {
        fromIndex = nativeMax$7(length + fromIndex, 0);
      }
      return isString$2(collection) ? fromIndex <= length && collection.indexOf(value, fromIndex) > -1 : !!length && baseIndexOf(collection, value, fromIndex) > -1;
    }
  
    var nativeMax$6 = Math.max;
    function indexOf(array, value, fromIndex) {
      var length = array == null ? 0 : array.length;
      if (!length) {
        return -1;
      }
      var index = fromIndex == null ? 0 : toInteger(fromIndex);
      if (index < 0) {
        index = nativeMax$6(length + index, 0);
      }
      return baseIndexOf(array, value, index);
    }
  
    function initial(array) {
      var length = array == null ? 0 : array.length;
      return length ? baseSlice(array, 0, -1) : [];
    }
  
    var nativeMin$8 = Math.min;
    function baseIntersection(arrays, iteratee, comparator) {
      var includes = comparator ? arrayIncludesWith : arrayIncludes, length = arrays[0].length, othLength = arrays.length, othIndex = othLength, caches = Array(othLength), maxLength = Infinity, result = [];
      while (othIndex--) {
        var array = arrays[othIndex];
        if (othIndex && iteratee) {
          array = arrayMap(array, baseUnary(iteratee));
        }
        maxLength = nativeMin$8(array.length, maxLength);
        caches[othIndex] = !comparator && (iteratee || length >= 120 && array.length >= 120) ? new SetCache(othIndex && array) : void 0;
      }
      array = arrays[0];
      var index = -1, seen = caches[0];
      outer:
        while (++index < length && result.length < maxLength) {
          var value = array[index], computed = iteratee ? iteratee(value) : value;
          value = comparator || value !== 0 ? value : 0;
          if (!(seen ? cacheHas(seen, computed) : includes(result, computed, comparator))) {
            othIndex = othLength;
            while (--othIndex) {
              var cache = caches[othIndex];
              if (!(cache ? cacheHas(cache, computed) : includes(arrays[othIndex], computed, comparator))) {
                continue outer;
              }
            }
            if (seen) {
              seen.push(computed);
            }
            result.push(value);
          }
        }
      return result;
    }
  
    function castArrayLikeObject(value) {
      return isArrayLikeObject(value) ? value : [];
    }
  
    var intersection = baseRest(function(arrays) {
      var mapped = arrayMap(arrays, castArrayLikeObject);
      return mapped.length && mapped[0] === arrays[0] ? baseIntersection(mapped) : [];
    });
  
    var intersectionBy = baseRest(function(arrays) {
      var iteratee = last(arrays), mapped = arrayMap(arrays, castArrayLikeObject);
      if (iteratee === last(mapped)) {
        iteratee = void 0;
      } else {
        mapped.pop();
      }
      return mapped.length && mapped[0] === arrays[0] ? baseIntersection(mapped, baseIteratee(iteratee)) : [];
    });
  
    var intersectionWith = baseRest(function(arrays) {
      var comparator = last(arrays), mapped = arrayMap(arrays, castArrayLikeObject);
      comparator = typeof comparator == "function" ? comparator : void 0;
      if (comparator) {
        mapped.pop();
      }
      return mapped.length && mapped[0] === arrays[0] ? baseIntersection(mapped, void 0, comparator) : [];
    });
  
    function baseInverter(object, setter, iteratee, accumulator) {
      baseForOwn(object, function(value, key, object2) {
        setter(accumulator, iteratee(value), key, object2);
      });
      return accumulator;
    }
  
    function createInverter(setter, toIteratee) {
      return function(object, iteratee) {
        return baseInverter(object, setter, toIteratee(iteratee), {});
      };
    }
  
    var objectProto$5 = Object.prototype;
    var nativeObjectToString$1 = objectProto$5.toString;
    var invert = createInverter(function(result, value, key) {
      if (value != null && typeof value.toString != "function") {
        value = nativeObjectToString$1.call(value);
      }
      result[value] = key;
    }, constant(identity$1));
  
    var objectProto$4 = Object.prototype;
    var hasOwnProperty$5 = objectProto$4.hasOwnProperty;
    var nativeObjectToString = objectProto$4.toString;
    var invertBy = createInverter(function(result, value, key) {
      if (value != null && typeof value.toString != "function") {
        value = nativeObjectToString.call(value);
      }
      if (hasOwnProperty$5.call(result, value)) {
        result[value].push(key);
      } else {
        result[value] = [key];
      }
    }, baseIteratee);
  
    function parent(object, path) {
      return path.length < 2 ? object : baseGet(object, baseSlice(path, 0, -1));
    }
  
    function baseInvoke(object, path, args) {
      path = castPath(path, object);
      object = parent(object, path);
      var func = object == null ? object : object[toKey(last(path))];
      return func == null ? void 0 : apply(func, object, args);
    }
  
    var invoke = baseRest(baseInvoke);
  
    var invokeMap = baseRest(function(collection, path, args) {
      var index = -1, isFunc = typeof path == "function", result = isArrayLike(collection) ? Array(collection.length) : [];
      baseEach(collection, function(value) {
        result[++index] = isFunc ? apply(path, value, args) : baseInvoke(value, path, args);
      });
      return result;
    });
  
    var arrayBufferTag = "[object ArrayBuffer]";
    function baseIsArrayBuffer(value) {
      return isObjectLike(value) && baseGetTag(value) == arrayBufferTag;
    }
  
    var nodeIsArrayBuffer = nodeUtil && nodeUtil.isArrayBuffer;
    var isArrayBuffer = nodeIsArrayBuffer ? baseUnary(nodeIsArrayBuffer) : baseIsArrayBuffer;
  
    var boolTag = "[object Boolean]";
    function isBoolean$1(value) {
      return value === true || value === false || isObjectLike(value) && baseGetTag(value) == boolTag;
    }
  
    var dateTag = "[object Date]";
    function baseIsDate(value) {
      return isObjectLike(value) && baseGetTag(value) == dateTag;
    }
  
    var nodeIsDate = nodeUtil && nodeUtil.isDate;
    var isDate$1 = nodeIsDate ? baseUnary(nodeIsDate) : baseIsDate;
  
    function isElement$2(value) {
      return isObjectLike(value) && value.nodeType === 1 && !isPlainObject(value);
    }
  
    var mapTag$2 = "[object Map]";
    var setTag$2 = "[object Set]";
    var objectProto$3 = Object.prototype;
    var hasOwnProperty$4 = objectProto$3.hasOwnProperty;
    function isEmpty$1(value) {
      if (value == null) {
        return true;
      }
      if (isArrayLike(value) && (isArray$1(value) || typeof value == "string" || typeof value.splice == "function" || isBuffer(value) || isTypedArray(value) || isArguments(value))) {
        return !value.length;
      }
      var tag = getTag$1(value);
      if (tag == mapTag$2 || tag == setTag$2) {
        return !value.size;
      }
      if (isPrototype(value)) {
        return !baseKeys(value).length;
      }
      for (var key in value) {
        if (hasOwnProperty$4.call(value, key)) {
          return false;
        }
      }
      return true;
    }
  
    function isEqual$1(value, other) {
      return baseIsEqual(value, other);
    }
  
    function isEqualWith(value, other, customizer) {
      customizer = typeof customizer == "function" ? customizer : void 0;
      var result = customizer ? customizer(value, other) : void 0;
      return result === void 0 ? baseIsEqual(value, other, void 0, customizer) : !!result;
    }
  
    var nativeIsFinite = root.isFinite;
    function isFinite(value) {
      return typeof value == "number" && nativeIsFinite(value);
    }
  
    function isInteger(value) {
      return typeof value == "number" && value == toInteger(value);
    }
  
    function isMatch(object, source) {
      return object === source || baseIsMatch(object, source, getMatchData(source));
    }
  
    function isMatchWith(object, source, customizer) {
      customizer = typeof customizer == "function" ? customizer : void 0;
      return baseIsMatch(object, source, getMatchData(source), customizer);
    }
  
    var numberTag = "[object Number]";
    function isNumber$1(value) {
      return typeof value == "number" || isObjectLike(value) && baseGetTag(value) == numberTag;
    }
  
    function isNaN$1(value) {
      return isNumber$1(value) && value != +value;
    }
  
    var isMaskable = coreJsData ? isFunction$1 : stubFalse;
  
    var CORE_ERROR_TEXT = "Unsupported core-js use. Try https://npms.io/search?q=ponyfill.";
    function isNative(value) {
      if (isMaskable(value)) {
        throw new Error(CORE_ERROR_TEXT);
      }
      return baseIsNative(value);
    }
  
    function isNil(value) {
      return value == null;
    }
  
    function isNull(value) {
      return value === null;
    }
  
    var regexpTag = "[object RegExp]";
    function baseIsRegExp(value) {
      return isObjectLike(value) && baseGetTag(value) == regexpTag;
    }
  
    var nodeIsRegExp = nodeUtil && nodeUtil.isRegExp;
    var isRegExp = nodeIsRegExp ? baseUnary(nodeIsRegExp) : baseIsRegExp;
  
    var MAX_SAFE_INTEGER$3 = 9007199254740991;
    function isSafeInteger(value) {
      return isInteger(value) && value >= -MAX_SAFE_INTEGER$3 && value <= MAX_SAFE_INTEGER$3;
    }
  
    function isUndefined$1(value) {
      return value === void 0;
    }
  
    var weakMapTag = "[object WeakMap]";
    function isWeakMap(value) {
      return isObjectLike(value) && getTag$1(value) == weakMapTag;
    }
  
    var weakSetTag = "[object WeakSet]";
    function isWeakSet(value) {
      return isObjectLike(value) && baseGetTag(value) == weakSetTag;
    }
  
    var CLONE_DEEP_FLAG$3 = 1;
    function iteratee(func) {
      return baseIteratee(typeof func == "function" ? func : baseClone(func, CLONE_DEEP_FLAG$3));
    }
  
    var arrayProto$4 = Array.prototype;
    var nativeJoin = arrayProto$4.join;
    function join(array, separator) {
      return array == null ? "" : nativeJoin.call(array, separator);
    }
  
    var kebabCase = createCompounder(function(result, word, index) {
      return result + (index ? "-" : "") + word.toLowerCase();
    });
  
    var keyBy = createAggregator(function(result, value, key) {
      baseAssignValue(result, key, value);
    });
  
    function strictLastIndexOf(array, value, fromIndex) {
      var index = fromIndex + 1;
      while (index--) {
        if (array[index] === value) {
          return index;
        }
      }
      return index;
    }
  
    var nativeMax$5 = Math.max;
    var nativeMin$7 = Math.min;
    function lastIndexOf(array, value, fromIndex) {
      var length = array == null ? 0 : array.length;
      if (!length) {
        return -1;
      }
      var index = length;
      if (fromIndex !== void 0) {
        index = toInteger(fromIndex);
        index = index < 0 ? nativeMax$5(length + index, 0) : nativeMin$7(index, length - 1);
      }
      return value === value ? strictLastIndexOf(array, value, index) : baseFindIndex(array, baseIsNaN, index, true);
    }
  
    var lowerCase = createCompounder(function(result, word, index) {
      return result + (index ? " " : "") + word.toLowerCase();
    });
  
    var lowerFirst = createCaseFirst("toLowerCase");
  
    function baseLt(value, other) {
      return value < other;
    }
  
    var lt$1 = createRelationalOperation(baseLt);
  
    var lte = createRelationalOperation(function(value, other) {
      return value <= other;
    });
  
    function mapKeys(object, iteratee) {
      var result = {};
      iteratee = baseIteratee(iteratee);
      baseForOwn(object, function(value, key, object2) {
        baseAssignValue(result, iteratee(value, key, object2), value);
      });
      return result;
    }
  
    function mapValues(object, iteratee) {
      var result = {};
      iteratee = baseIteratee(iteratee);
      baseForOwn(object, function(value, key, object2) {
        baseAssignValue(result, key, iteratee(value, key, object2));
      });
      return result;
    }
  
    var CLONE_DEEP_FLAG$2 = 1;
    function matches(source) {
      return baseMatches(baseClone(source, CLONE_DEEP_FLAG$2));
    }
  
    var CLONE_DEEP_FLAG$1 = 1;
    function matchesProperty(path, srcValue) {
      return baseMatchesProperty(path, baseClone(srcValue, CLONE_DEEP_FLAG$1));
    }
  
    function baseExtremum(array, iteratee, comparator) {
      var index = -1, length = array.length;
      while (++index < length) {
        var value = array[index], current = iteratee(value);
        if (current != null && (computed === void 0 ? current === current && !isSymbol(current) : comparator(current, computed))) {
          var computed = current, result = value;
        }
      }
      return result;
    }
  
    function max$3(array) {
      return array && array.length ? baseExtremum(array, identity$1, baseGt) : void 0;
    }
  
    function maxBy(array, iteratee) {
      return array && array.length ? baseExtremum(array, baseIteratee(iteratee), baseGt) : void 0;
    }
  
    function baseSum(array, iteratee) {
      var result, index = -1, length = array.length;
      while (++index < length) {
        var current = iteratee(array[index]);
        if (current !== void 0) {
          result = result === void 0 ? current : result + current;
        }
      }
      return result;
    }
  
    var NAN = 0 / 0;
    function baseMean(array, iteratee) {
      var length = array == null ? 0 : array.length;
      return length ? baseSum(array, iteratee) / length : NAN;
    }
  
    function mean(array) {
      return baseMean(array, identity$1);
    }
  
    function meanBy(array, iteratee) {
      return baseMean(array, baseIteratee(iteratee));
    }
  
    var merge = createAssigner(function(object, source, srcIndex) {
      baseMerge(object, source, srcIndex);
    });
  
    var method = baseRest(function(path, args) {
      return function(object) {
        return baseInvoke(object, path, args);
      };
    });
  
    var methodOf = baseRest(function(object, args) {
      return function(path) {
        return baseInvoke(object, path, args);
      };
    });
  
    function min$3(array) {
      return array && array.length ? baseExtremum(array, identity$1, baseLt) : void 0;
    }
  
    function minBy(array, iteratee) {
      return array && array.length ? baseExtremum(array, baseIteratee(iteratee), baseLt) : void 0;
    }
  
    function mixin$1(object, source, options) {
      var props = keys(source), methodNames = baseFunctions(source, props);
      var chain = !(isObject$2(options) && "chain" in options) || !!options.chain, isFunc = isFunction$1(object);
      arrayEach(methodNames, function(methodName) {
        var func = source[methodName];
        object[methodName] = func;
        if (isFunc) {
          object.prototype[methodName] = function() {
            var chainAll = this.__chain__;
            if (chain || chainAll) {
              var result = object(this.__wrapped__), actions = result.__actions__ = copyArray(this.__actions__);
              actions.push({ "func": func, "args": arguments, "thisArg": object });
              result.__chain__ = chainAll;
              return result;
            }
            return func.apply(object, arrayPush([this.value()], arguments));
          };
        }
      });
      return object;
    }
  
    var multiply = createMathOperation(function(multiplier, multiplicand) {
      return multiplier * multiplicand;
    }, 1);
  
    var FUNC_ERROR_TEXT$3 = "Expected a function";
    function negate(predicate) {
      if (typeof predicate != "function") {
        throw new TypeError(FUNC_ERROR_TEXT$3);
      }
      return function() {
        var args = arguments;
        switch (args.length) {
          case 0:
            return !predicate.call(this);
          case 1:
            return !predicate.call(this, args[0]);
          case 2:
            return !predicate.call(this, args[0], args[1]);
          case 3:
            return !predicate.call(this, args[0], args[1], args[2]);
        }
        return !predicate.apply(this, args);
      };
    }
  
    function iteratorToArray(iterator) {
      var data, result = [];
      while (!(data = iterator.next()).done) {
        result.push(data.value);
      }
      return result;
    }
  
    var mapTag$1 = "[object Map]";
    var setTag$1 = "[object Set]";
    var symIterator$1 = Symbol$1 ? Symbol$1.iterator : void 0;
    function toArray(value) {
      if (!value) {
        return [];
      }
      if (isArrayLike(value)) {
        return isString$2(value) ? stringToArray(value) : copyArray(value);
      }
      if (symIterator$1 && value[symIterator$1]) {
        return iteratorToArray(value[symIterator$1]());
      }
      var tag = getTag$1(value), func = tag == mapTag$1 ? mapToArray : tag == setTag$1 ? setToArray : values;
      return func(value);
    }
  
    function wrapperNext() {
      if (this.__values__ === void 0) {
        this.__values__ = toArray(this.value());
      }
      var done = this.__index__ >= this.__values__.length, value = done ? void 0 : this.__values__[this.__index__++];
      return { "done": done, "value": value };
    }
  
    function baseNth(array, n) {
      var length = array.length;
      if (!length) {
        return;
      }
      n += n < 0 ? length : 0;
      return isIndex(n, length) ? array[n] : void 0;
    }
  
    function nth(array, n) {
      return array && array.length ? baseNth(array, toInteger(n)) : void 0;
    }
  
    function nthArg(n) {
      n = toInteger(n);
      return baseRest(function(args) {
        return baseNth(args, n);
      });
    }
  
    function baseUnset(object, path) {
      path = castPath(path, object);
      object = parent(object, path);
      return object == null || delete object[toKey(last(path))];
    }
  
    function customOmitClone(value) {
      return isPlainObject(value) ? void 0 : value;
    }
  
    var CLONE_DEEP_FLAG = 1;
    var CLONE_FLAT_FLAG = 2;
    var CLONE_SYMBOLS_FLAG = 4;
    var omit = flatRest(function(object, paths) {
      var result = {};
      if (object == null) {
        return result;
      }
      var isDeep = false;
      paths = arrayMap(paths, function(path) {
        path = castPath(path, object);
        isDeep || (isDeep = path.length > 1);
        return path;
      });
      copyObject(object, getAllKeysIn(object), result);
      if (isDeep) {
        result = baseClone(result, CLONE_DEEP_FLAG | CLONE_FLAT_FLAG | CLONE_SYMBOLS_FLAG, customOmitClone);
      }
      var length = paths.length;
      while (length--) {
        baseUnset(result, paths[length]);
      }
      return result;
    });
  
    function baseSet(object, path, value, customizer) {
      if (!isObject$2(object)) {
        return object;
      }
      path = castPath(path, object);
      var index = -1, length = path.length, lastIndex = length - 1, nested = object;
      while (nested != null && ++index < length) {
        var key = toKey(path[index]), newValue = value;
        if (key === "__proto__" || key === "constructor" || key === "prototype") {
          return object;
        }
        if (index != lastIndex) {
          var objValue = nested[key];
          newValue = customizer ? customizer(objValue, key, nested) : void 0;
          if (newValue === void 0) {
            newValue = isObject$2(objValue) ? objValue : isIndex(path[index + 1]) ? [] : {};
          }
        }
        assignValue(nested, key, newValue);
        nested = nested[key];
      }
      return object;
    }
  
    function basePickBy(object, paths, predicate) {
      var index = -1, length = paths.length, result = {};
      while (++index < length) {
        var path = paths[index], value = baseGet(object, path);
        if (predicate(value, path)) {
          baseSet(result, castPath(path, object), value);
        }
      }
      return result;
    }
  
    function pickBy(object, predicate) {
      if (object == null) {
        return {};
      }
      var props = arrayMap(getAllKeysIn(object), function(prop) {
        return [prop];
      });
      predicate = baseIteratee(predicate);
      return basePickBy(object, props, function(value, path) {
        return predicate(value, path[0]);
      });
    }
  
    function omitBy(object, predicate) {
      return pickBy(object, negate(baseIteratee(predicate)));
    }
  
    function once(func) {
      return before(2, func);
    }
  
    function baseSortBy(array, comparer) {
      var length = array.length;
      array.sort(comparer);
      while (length--) {
        array[length] = array[length].value;
      }
      return array;
    }
  
    function compareAscending(value, other) {
      if (value !== other) {
        var valIsDefined = value !== void 0, valIsNull = value === null, valIsReflexive = value === value, valIsSymbol = isSymbol(value);
        var othIsDefined = other !== void 0, othIsNull = other === null, othIsReflexive = other === other, othIsSymbol = isSymbol(other);
        if (!othIsNull && !othIsSymbol && !valIsSymbol && value > other || valIsSymbol && othIsDefined && othIsReflexive && !othIsNull && !othIsSymbol || valIsNull && othIsDefined && othIsReflexive || !valIsDefined && othIsReflexive || !valIsReflexive) {
          return 1;
        }
        if (!valIsNull && !valIsSymbol && !othIsSymbol && value < other || othIsSymbol && valIsDefined && valIsReflexive && !valIsNull && !valIsSymbol || othIsNull && valIsDefined && valIsReflexive || !othIsDefined && valIsReflexive || !othIsReflexive) {
          return -1;
        }
      }
      return 0;
    }
  
    function compareMultiple(object, other, orders) {
      var index = -1, objCriteria = object.criteria, othCriteria = other.criteria, length = objCriteria.length, ordersLength = orders.length;
      while (++index < length) {
        var result = compareAscending(objCriteria[index], othCriteria[index]);
        if (result) {
          if (index >= ordersLength) {
            return result;
          }
          var order = orders[index];
          return result * (order == "desc" ? -1 : 1);
        }
      }
      return object.index - other.index;
    }
  
    function baseOrderBy(collection, iteratees, orders) {
      if (iteratees.length) {
        iteratees = arrayMap(iteratees, function(iteratee) {
          if (isArray$1(iteratee)) {
            return function(value) {
              return baseGet(value, iteratee.length === 1 ? iteratee[0] : iteratee);
            };
          }
          return iteratee;
        });
      } else {
        iteratees = [identity$1];
      }
      var index = -1;
      iteratees = arrayMap(iteratees, baseUnary(baseIteratee));
      var result = baseMap(collection, function(value, key, collection2) {
        var criteria = arrayMap(iteratees, function(iteratee) {
          return iteratee(value);
        });
        return { "criteria": criteria, "index": ++index, "value": value };
      });
      return baseSortBy(result, function(object, other) {
        return compareMultiple(object, other, orders);
      });
    }
  
    function orderBy$1(collection, iteratees, orders, guard) {
      if (collection == null) {
        return [];
      }
      if (!isArray$1(iteratees)) {
        iteratees = iteratees == null ? [] : [iteratees];
      }
      orders = guard ? void 0 : orders;
      if (!isArray$1(orders)) {
        orders = orders == null ? [] : [orders];
      }
      return baseOrderBy(collection, iteratees, orders);
    }
  
    function createOver(arrayFunc) {
      return flatRest(function(iteratees) {
        iteratees = arrayMap(iteratees, baseUnary(baseIteratee));
        return baseRest(function(args) {
          var thisArg = this;
          return arrayFunc(iteratees, function(iteratee) {
            return apply(iteratee, thisArg, args);
          });
        });
      });
    }
  
    var over = createOver(arrayMap);
  
    var castRest = baseRest;
  
    var nativeMin$6 = Math.min;
    var overArgs = castRest(function(func, transforms) {
      transforms = transforms.length == 1 && isArray$1(transforms[0]) ? arrayMap(transforms[0], baseUnary(baseIteratee)) : arrayMap(baseFlatten(transforms, 1), baseUnary(baseIteratee));
      var funcsLength = transforms.length;
      return baseRest(function(args) {
        var index = -1, length = nativeMin$6(args.length, funcsLength);
        while (++index < length) {
          args[index] = transforms[index].call(this, args[index]);
        }
        return apply(func, this, args);
      });
    });
  
    var overEvery = createOver(arrayEvery);
  
    var overSome = createOver(arraySome);
  
    var MAX_SAFE_INTEGER$2 = 9007199254740991;
    var nativeFloor$3 = Math.floor;
    function baseRepeat(string, n) {
      var result = "";
      if (!string || n < 1 || n > MAX_SAFE_INTEGER$2) {
        return result;
      }
      do {
        if (n % 2) {
          result += string;
        }
        n = nativeFloor$3(n / 2);
        if (n) {
          string += string;
        }
      } while (n);
      return result;
    }
  
    var asciiSize = baseProperty("length");
  
    var rsAstralRange = "\\ud800-\\udfff";
    var rsComboMarksRange = "\\u0300-\\u036f";
    var reComboHalfMarksRange = "\\ufe20-\\ufe2f";
    var rsComboSymbolsRange = "\\u20d0-\\u20ff";
    var rsComboRange = rsComboMarksRange + reComboHalfMarksRange + rsComboSymbolsRange;
    var rsVarRange = "\\ufe0e\\ufe0f";
    var rsAstral = "[" + rsAstralRange + "]";
    var rsCombo = "[" + rsComboRange + "]";
    var rsFitz = "\\ud83c[\\udffb-\\udfff]";
    var rsModifier = "(?:" + rsCombo + "|" + rsFitz + ")";
    var rsNonAstral = "[^" + rsAstralRange + "]";
    var rsRegional = "(?:\\ud83c[\\udde6-\\uddff]){2}";
    var rsSurrPair = "[\\ud800-\\udbff][\\udc00-\\udfff]";
    var rsZWJ = "\\u200d";
    var reOptMod = rsModifier + "?";
    var rsOptVar = "[" + rsVarRange + "]?";
    var rsOptJoin = "(?:" + rsZWJ + "(?:" + [rsNonAstral, rsRegional, rsSurrPair].join("|") + ")" + rsOptVar + reOptMod + ")*";
    var rsSeq = rsOptVar + reOptMod + rsOptJoin;
    var rsSymbol = "(?:" + [rsNonAstral + rsCombo + "?", rsCombo, rsRegional, rsSurrPair, rsAstral].join("|") + ")";
    var reUnicode = RegExp(rsFitz + "(?=" + rsFitz + ")|" + rsSymbol + rsSeq, "g");
    function unicodeSize(string) {
      var result = reUnicode.lastIndex = 0;
      while (reUnicode.test(string)) {
        ++result;
      }
      return result;
    }
  
    function stringSize(string) {
      return hasUnicode(string) ? unicodeSize(string) : asciiSize(string);
    }
  
    var nativeCeil$2 = Math.ceil;
    function createPadding(length, chars) {
      chars = chars === void 0 ? " " : baseToString(chars);
      var charsLength = chars.length;
      if (charsLength < 2) {
        return charsLength ? baseRepeat(chars, length) : chars;
      }
      var result = baseRepeat(chars, nativeCeil$2(length / stringSize(chars)));
      return hasUnicode(chars) ? castSlice(stringToArray(result), 0, length).join("") : result.slice(0, length);
    }
  
    var nativeCeil$1 = Math.ceil;
    var nativeFloor$2 = Math.floor;
    function pad(string, length, chars) {
      string = toString(string);
      length = toInteger(length);
      var strLength = length ? stringSize(string) : 0;
      if (!length || strLength >= length) {
        return string;
      }
      var mid = (length - strLength) / 2;
      return createPadding(nativeFloor$2(mid), chars) + string + createPadding(nativeCeil$1(mid), chars);
    }
  
    function padEnd(string, length, chars) {
      string = toString(string);
      length = toInteger(length);
      var strLength = length ? stringSize(string) : 0;
      return length && strLength < length ? string + createPadding(length - strLength, chars) : string;
    }
  
    function padStart(string, length, chars) {
      string = toString(string);
      length = toInteger(length);
      var strLength = length ? stringSize(string) : 0;
      return length && strLength < length ? createPadding(length - strLength, chars) + string : string;
    }
  
    var reTrimStart$1 = /^\s+/;
    var nativeParseInt = root.parseInt;
    function parseInt$1(string, radix, guard) {
      if (guard || radix == null) {
        radix = 0;
      } else if (radix) {
        radix = +radix;
      }
      return nativeParseInt(toString(string).replace(reTrimStart$1, ""), radix || 0);
    }
  
    var WRAP_PARTIAL_FLAG = 32;
    var partial = baseRest(function(func, partials) {
      var holders = replaceHolders(partials, getHolder(partial));
      return createWrap(func, WRAP_PARTIAL_FLAG, void 0, partials, holders);
    });
    partial.placeholder = {};
  
    var WRAP_PARTIAL_RIGHT_FLAG = 64;
    var partialRight = baseRest(function(func, partials) {
      var holders = replaceHolders(partials, getHolder(partialRight));
      return createWrap(func, WRAP_PARTIAL_RIGHT_FLAG, void 0, partials, holders);
    });
    partialRight.placeholder = {};
  
    var partition = createAggregator(function(result, value, key) {
      result[key ? 0 : 1].push(value);
    }, function() {
      return [[], []];
    });
  
    function basePick(object, paths) {
      return basePickBy(object, paths, function(value, path) {
        return hasIn(object, path);
      });
    }
  
    var pick = flatRest(function(object, paths) {
      return object == null ? {} : basePick(object, paths);
    });
  
    function wrapperPlant(value) {
      var result, parent = this;
      while (parent instanceof baseLodash) {
        var clone = wrapperClone(parent);
        clone.__index__ = 0;
        clone.__values__ = void 0;
        if (result) {
          previous.__wrapped__ = clone;
        } else {
          result = clone;
        }
        var previous = clone;
        parent = parent.__wrapped__;
      }
      previous.__wrapped__ = value;
      return result;
    }
  
    function propertyOf(object) {
      return function(path) {
        return object == null ? void 0 : baseGet(object, path);
      };
    }
  
    function baseIndexOfWith(array, value, fromIndex, comparator) {
      var index = fromIndex - 1, length = array.length;
      while (++index < length) {
        if (comparator(array[index], value)) {
          return index;
        }
      }
      return -1;
    }
  
    var arrayProto$3 = Array.prototype;
    var splice$1 = arrayProto$3.splice;
    function basePullAll(array, values, iteratee, comparator) {
      var indexOf = comparator ? baseIndexOfWith : baseIndexOf, index = -1, length = values.length, seen = array;
      if (array === values) {
        values = copyArray(values);
      }
      if (iteratee) {
        seen = arrayMap(array, baseUnary(iteratee));
      }
      while (++index < length) {
        var fromIndex = 0, value = values[index], computed = iteratee ? iteratee(value) : value;
        while ((fromIndex = indexOf(seen, computed, fromIndex, comparator)) > -1) {
          if (seen !== array) {
            splice$1.call(seen, fromIndex, 1);
          }
          splice$1.call(array, fromIndex, 1);
        }
      }
      return array;
    }
  
    function pullAll(array, values) {
      return array && array.length && values && values.length ? basePullAll(array, values) : array;
    }
  
    var pull = baseRest(pullAll);
  
    function pullAllBy(array, values, iteratee) {
      return array && array.length && values && values.length ? basePullAll(array, values, baseIteratee(iteratee)) : array;
    }
  
    function pullAllWith(array, values, comparator) {
      return array && array.length && values && values.length ? basePullAll(array, values, void 0, comparator) : array;
    }
  
    var arrayProto$2 = Array.prototype;
    var splice = arrayProto$2.splice;
    function basePullAt(array, indexes) {
      var length = array ? indexes.length : 0, lastIndex = length - 1;
      while (length--) {
        var index = indexes[length];
        if (length == lastIndex || index !== previous) {
          var previous = index;
          if (isIndex(index)) {
            splice.call(array, index, 1);
          } else {
            baseUnset(array, index);
          }
        }
      }
      return array;
    }
  
    var pullAt = flatRest(function(array, indexes) {
      var length = array == null ? 0 : array.length, result = baseAt(array, indexes);
      basePullAt(array, arrayMap(indexes, function(index) {
        return isIndex(index, length) ? +index : index;
      }).sort(compareAscending));
      return result;
    });
  
    var nativeFloor$1 = Math.floor;
    var nativeRandom$1 = Math.random;
    function baseRandom(lower, upper) {
      return lower + nativeFloor$1(nativeRandom$1() * (upper - lower + 1));
    }
  
    var freeParseFloat = parseFloat;
    var nativeMin$5 = Math.min;
    var nativeRandom = Math.random;
    function random(lower, upper, floating) {
      if (floating && typeof floating != "boolean" && isIterateeCall(lower, upper, floating)) {
        upper = floating = void 0;
      }
      if (floating === void 0) {
        if (typeof upper == "boolean") {
          floating = upper;
          upper = void 0;
        } else if (typeof lower == "boolean") {
          floating = lower;
          lower = void 0;
        }
      }
      if (lower === void 0 && upper === void 0) {
        lower = 0;
        upper = 1;
      } else {
        lower = toFinite(lower);
        if (upper === void 0) {
          upper = lower;
          lower = 0;
        } else {
          upper = toFinite(upper);
        }
      }
      if (lower > upper) {
        var temp = lower;
        lower = upper;
        upper = temp;
      }
      if (floating || lower % 1 || upper % 1) {
        var rand = nativeRandom();
        return nativeMin$5(lower + rand * (upper - lower + freeParseFloat("1e-" + ((rand + "").length - 1))), upper);
      }
      return baseRandom(lower, upper);
    }
  
    var nativeCeil = Math.ceil;
    var nativeMax$4 = Math.max;
    function baseRange(start, end, step, fromRight) {
      var index = -1, length = nativeMax$4(nativeCeil((end - start) / (step || 1)), 0), result = Array(length);
      while (length--) {
        result[fromRight ? length : ++index] = start;
        start += step;
      }
      return result;
    }
  
    function createRange(fromRight) {
      return function(start, end, step) {
        if (step && typeof step != "number" && isIterateeCall(start, end, step)) {
          end = step = void 0;
        }
        start = toFinite(start);
        if (end === void 0) {
          end = start;
          start = 0;
        } else {
          end = toFinite(end);
        }
        step = step === void 0 ? start < end ? 1 : -1 : toFinite(step);
        return baseRange(start, end, step, fromRight);
      };
    }
  
    var range$1 = createRange();
  
    var rangeRight = createRange(true);
  
    var WRAP_REARG_FLAG = 256;
    var rearg = flatRest(function(func, indexes) {
      return createWrap(func, WRAP_REARG_FLAG, void 0, void 0, void 0, indexes);
    });
  
    function baseReduce(collection, iteratee, accumulator, initAccum, eachFunc) {
      eachFunc(collection, function(value, index, collection2) {
        accumulator = initAccum ? (initAccum = false, value) : iteratee(accumulator, value, index, collection2);
      });
      return accumulator;
    }
  
    function reduce(collection, iteratee, accumulator) {
      var func = isArray$1(collection) ? arrayReduce : baseReduce, initAccum = arguments.length < 3;
      return func(collection, baseIteratee(iteratee), accumulator, initAccum, baseEach);
    }
  
    function arrayReduceRight(array, iteratee, accumulator, initAccum) {
      var length = array == null ? 0 : array.length;
      if (initAccum && length) {
        accumulator = array[--length];
      }
      while (length--) {
        accumulator = iteratee(accumulator, array[length], length, array);
      }
      return accumulator;
    }
  
    function reduceRight(collection, iteratee, accumulator) {
      var func = isArray$1(collection) ? arrayReduceRight : baseReduce, initAccum = arguments.length < 3;
      return func(collection, baseIteratee(iteratee), accumulator, initAccum, baseEachRight);
    }
  
    function reject(collection, predicate) {
      var func = isArray$1(collection) ? arrayFilter : baseFilter;
      return func(collection, negate(baseIteratee(predicate)));
    }
  
    function remove(array, predicate) {
      var result = [];
      if (!(array && array.length)) {
        return result;
      }
      var index = -1, indexes = [], length = array.length;
      predicate = baseIteratee(predicate);
      while (++index < length) {
        var value = array[index];
        if (predicate(value, index, array)) {
          result.push(value);
          indexes.push(index);
        }
      }
      basePullAt(array, indexes);
      return result;
    }
  
    function repeat(string, n, guard) {
      if (guard ? isIterateeCall(string, n, guard) : n === void 0) {
        n = 1;
      } else {
        n = toInteger(n);
      }
      return baseRepeat(toString(string), n);
    }
  
    function replace() {
      var args = arguments, string = toString(args[0]);
      return args.length < 3 ? string : string.replace(args[1], args[2]);
    }
  
    var FUNC_ERROR_TEXT$2 = "Expected a function";
    function rest(func, start) {
      if (typeof func != "function") {
        throw new TypeError(FUNC_ERROR_TEXT$2);
      }
      start = start === void 0 ? start : toInteger(start);
      return baseRest(func, start);
    }
  
    function result(object, path, defaultValue) {
      path = castPath(path, object);
      var index = -1, length = path.length;
      if (!length) {
        length = 1;
        object = void 0;
      }
      while (++index < length) {
        var value = object == null ? void 0 : object[toKey(path[index])];
        if (value === void 0) {
          index = length;
          value = defaultValue;
        }
        object = isFunction$1(value) ? value.call(object) : value;
      }
      return object;
    }
  
    var arrayProto$1 = Array.prototype;
    var nativeReverse = arrayProto$1.reverse;
    function reverse(array) {
      return array == null ? array : nativeReverse.call(array);
    }
  
    var round$1 = createRound("round");
  
    function arraySample(array) {
      var length = array.length;
      return length ? array[baseRandom(0, length - 1)] : void 0;
    }
  
    function baseSample(collection) {
      return arraySample(values(collection));
    }
  
    function sample(collection) {
      var func = isArray$1(collection) ? arraySample : baseSample;
      return func(collection);
    }
  
    function shuffleSelf(array, size) {
      var index = -1, length = array.length, lastIndex = length - 1;
      size = size === void 0 ? length : size;
      while (++index < size) {
        var rand = baseRandom(index, lastIndex), value = array[rand];
        array[rand] = array[index];
        array[index] = value;
      }
      array.length = size;
      return array;
    }
  
    function arraySampleSize(array, n) {
      return shuffleSelf(copyArray(array), baseClamp(n, 0, array.length));
    }
  
    function baseSampleSize(collection, n) {
      var array = values(collection);
      return shuffleSelf(array, baseClamp(n, 0, array.length));
    }
  
    function sampleSize(collection, n, guard) {
      if (guard ? isIterateeCall(collection, n, guard) : n === void 0) {
        n = 1;
      } else {
        n = toInteger(n);
      }
      var func = isArray$1(collection) ? arraySampleSize : baseSampleSize;
      return func(collection, n);
    }
  
    function set(object, path, value) {
      return object == null ? object : baseSet(object, path, value);
    }
  
    function setWith(object, path, value, customizer) {
      customizer = typeof customizer == "function" ? customizer : void 0;
      return object == null ? object : baseSet(object, path, value, customizer);
    }
  
    function arrayShuffle(array) {
      return shuffleSelf(copyArray(array));
    }
  
    function baseShuffle(collection) {
      return shuffleSelf(values(collection));
    }
  
    function shuffle(collection) {
      var func = isArray$1(collection) ? arrayShuffle : baseShuffle;
      return func(collection);
    }
  
    var mapTag = "[object Map]";
    var setTag = "[object Set]";
    function size(collection) {
      if (collection == null) {
        return 0;
      }
      if (isArrayLike(collection)) {
        return isString$2(collection) ? stringSize(collection) : collection.length;
      }
      var tag = getTag$1(collection);
      if (tag == mapTag || tag == setTag) {
        return collection.size;
      }
      return baseKeys(collection).length;
    }
  
    function slice(array, start, end) {
      var length = array == null ? 0 : array.length;
      if (!length) {
        return [];
      }
      if (end && typeof end != "number" && isIterateeCall(array, start, end)) {
        start = 0;
        end = length;
      } else {
        start = start == null ? 0 : toInteger(start);
        end = end === void 0 ? length : toInteger(end);
      }
      return baseSlice(array, start, end);
    }
  
    var snakeCase = createCompounder(function(result, word, index) {
      return result + (index ? "_" : "") + word.toLowerCase();
    });
  
    function baseSome(collection, predicate) {
      var result;
      baseEach(collection, function(value, index, collection2) {
        result = predicate(value, index, collection2);
        return !result;
      });
      return !!result;
    }
  
    function some(collection, predicate, guard) {
      var func = isArray$1(collection) ? arraySome : baseSome;
      if (guard && isIterateeCall(collection, predicate, guard)) {
        predicate = void 0;
      }
      return func(collection, baseIteratee(predicate));
    }
  
    var sortBy = baseRest(function(collection, iteratees) {
      if (collection == null) {
        return [];
      }
      var length = iteratees.length;
      if (length > 1 && isIterateeCall(collection, iteratees[0], iteratees[1])) {
        iteratees = [];
      } else if (length > 2 && isIterateeCall(iteratees[0], iteratees[1], iteratees[2])) {
        iteratees = [iteratees[0]];
      }
      return baseOrderBy(collection, baseFlatten(iteratees, 1), []);
    });
  
    var MAX_ARRAY_LENGTH$4 = 4294967295;
    var MAX_ARRAY_INDEX = MAX_ARRAY_LENGTH$4 - 1;
    var nativeFloor = Math.floor;
    var nativeMin$4 = Math.min;
    function baseSortedIndexBy(array, value, iteratee, retHighest) {
      var low = 0, high = array == null ? 0 : array.length;
      if (high === 0) {
        return 0;
      }
      value = iteratee(value);
      var valIsNaN = value !== value, valIsNull = value === null, valIsSymbol = isSymbol(value), valIsUndefined = value === void 0;
      while (low < high) {
        var mid = nativeFloor((low + high) / 2), computed = iteratee(array[mid]), othIsDefined = computed !== void 0, othIsNull = computed === null, othIsReflexive = computed === computed, othIsSymbol = isSymbol(computed);
        if (valIsNaN) {
          var setLow = retHighest || othIsReflexive;
        } else if (valIsUndefined) {
          setLow = othIsReflexive && (retHighest || othIsDefined);
        } else if (valIsNull) {
          setLow = othIsReflexive && othIsDefined && (retHighest || !othIsNull);
        } else if (valIsSymbol) {
          setLow = othIsReflexive && othIsDefined && !othIsNull && (retHighest || !othIsSymbol);
        } else if (othIsNull || othIsSymbol) {
          setLow = false;
        } else {
          setLow = retHighest ? computed <= value : computed < value;
        }
        if (setLow) {
          low = mid + 1;
        } else {
          high = mid;
        }
      }
      return nativeMin$4(high, MAX_ARRAY_INDEX);
    }
  
    var MAX_ARRAY_LENGTH$3 = 4294967295;
    var HALF_MAX_ARRAY_LENGTH = MAX_ARRAY_LENGTH$3 >>> 1;
    function baseSortedIndex(array, value, retHighest) {
      var low = 0, high = array == null ? low : array.length;
      if (typeof value == "number" && value === value && high <= HALF_MAX_ARRAY_LENGTH) {
        while (low < high) {
          var mid = low + high >>> 1, computed = array[mid];
          if (computed !== null && !isSymbol(computed) && (retHighest ? computed <= value : computed < value)) {
            low = mid + 1;
          } else {
            high = mid;
          }
        }
        return high;
      }
      return baseSortedIndexBy(array, value, identity$1, retHighest);
    }
  
    function sortedIndex(array, value) {
      return baseSortedIndex(array, value);
    }
  
    function sortedIndexBy(array, value, iteratee) {
      return baseSortedIndexBy(array, value, baseIteratee(iteratee));
    }
  
    function sortedIndexOf(array, value) {
      var length = array == null ? 0 : array.length;
      if (length) {
        var index = baseSortedIndex(array, value);
        if (index < length && eq(array[index], value)) {
          return index;
        }
      }
      return -1;
    }
  
    function sortedLastIndex(array, value) {
      return baseSortedIndex(array, value, true);
    }
  
    function sortedLastIndexBy(array, value, iteratee) {
      return baseSortedIndexBy(array, value, baseIteratee(iteratee), true);
    }
  
    function sortedLastIndexOf(array, value) {
      var length = array == null ? 0 : array.length;
      if (length) {
        var index = baseSortedIndex(array, value, true) - 1;
        if (eq(array[index], value)) {
          return index;
        }
      }
      return -1;
    }
  
    function baseSortedUniq(array, iteratee) {
      var index = -1, length = array.length, resIndex = 0, result = [];
      while (++index < length) {
        var value = array[index], computed = iteratee ? iteratee(value) : value;
        if (!index || !eq(computed, seen)) {
          var seen = computed;
          result[resIndex++] = value === 0 ? 0 : value;
        }
      }
      return result;
    }
  
    function sortedUniq(array) {
      return array && array.length ? baseSortedUniq(array) : [];
    }
  
    function sortedUniqBy(array, iteratee) {
      return array && array.length ? baseSortedUniq(array, baseIteratee(iteratee)) : [];
    }
  
    var MAX_ARRAY_LENGTH$2 = 4294967295;
    function split(string, separator, limit) {
      if (limit && typeof limit != "number" && isIterateeCall(string, separator, limit)) {
        separator = limit = void 0;
      }
      limit = limit === void 0 ? MAX_ARRAY_LENGTH$2 : limit >>> 0;
      if (!limit) {
        return [];
      }
      string = toString(string);
      if (string && (typeof separator == "string" || separator != null && !isRegExp(separator))) {
        separator = baseToString(separator);
        if (!separator && hasUnicode(string)) {
          return castSlice(stringToArray(string), 0, limit);
        }
      }
      return string.split(separator, limit);
    }
  
    var FUNC_ERROR_TEXT$1 = "Expected a function";
    var nativeMax$3 = Math.max;
    function spread(func, start) {
      if (typeof func != "function") {
        throw new TypeError(FUNC_ERROR_TEXT$1);
      }
      start = start == null ? 0 : nativeMax$3(toInteger(start), 0);
      return baseRest(function(args) {
        var array = args[start], otherArgs = castSlice(args, 0, start);
        if (array) {
          arrayPush(otherArgs, array);
        }
        return apply(func, this, otherArgs);
      });
    }
  
    var startCase = createCompounder(function(result, word, index) {
      return result + (index ? " " : "") + upperFirst(word);
    });
  
    function startsWith(string, target, position) {
      string = toString(string);
      position = position == null ? 0 : baseClamp(toInteger(position), 0, string.length);
      target = baseToString(target);
      return string.slice(position, position + target.length) == target;
    }
  
    function stubObject() {
      return {};
    }
  
    function stubString() {
      return "";
    }
  
    function stubTrue() {
      return true;
    }
  
    var subtract = createMathOperation(function(minuend, subtrahend) {
      return minuend - subtrahend;
    }, 0);
  
    function sum$1(array) {
      return array && array.length ? baseSum(array, identity$1) : 0;
    }
  
    function sumBy(array, iteratee) {
      return array && array.length ? baseSum(array, baseIteratee(iteratee)) : 0;
    }
  
    function tail(array) {
      var length = array == null ? 0 : array.length;
      return length ? baseSlice(array, 1, length) : [];
    }
  
    function take(array, n, guard) {
      if (!(array && array.length)) {
        return [];
      }
      n = guard || n === void 0 ? 1 : toInteger(n);
      return baseSlice(array, 0, n < 0 ? 0 : n);
    }
  
    function takeRight(array, n, guard) {
      var length = array == null ? 0 : array.length;
      if (!length) {
        return [];
      }
      n = guard || n === void 0 ? 1 : toInteger(n);
      n = length - n;
      return baseSlice(array, n < 0 ? 0 : n, length);
    }
  
    function takeRightWhile(array, predicate) {
      return array && array.length ? baseWhile(array, baseIteratee(predicate), false, true) : [];
    }
  
    function takeWhile(array, predicate) {
      return array && array.length ? baseWhile(array, baseIteratee(predicate)) : [];
    }
  
    function tap(value, interceptor) {
      interceptor(value);
      return value;
    }
  
    var objectProto$2 = Object.prototype;
    var hasOwnProperty$3 = objectProto$2.hasOwnProperty;
    function customDefaultsAssignIn(objValue, srcValue, key, object) {
      if (objValue === void 0 || eq(objValue, objectProto$2[key]) && !hasOwnProperty$3.call(object, key)) {
        return srcValue;
      }
      return objValue;
    }
  
    var stringEscapes = {
      "\\": "\\",
      "'": "'",
      "\n": "n",
      "\r": "r",
      "\u2028": "u2028",
      "\u2029": "u2029"
    };
    function escapeStringChar(chr) {
      return "\\" + stringEscapes[chr];
    }
  
    var reInterpolate = /<%=([\s\S]+?)%>/g;
  
    var reEscape = /<%-([\s\S]+?)%>/g;
  
    var reEvaluate = /<%([\s\S]+?)%>/g;
  
    var templateSettings = {
      "escape": reEscape,
      "evaluate": reEvaluate,
      "interpolate": reInterpolate,
      "variable": "",
      "imports": {
        "_": { "escape": escape }
      }
    };
  
    var INVALID_TEMPL_VAR_ERROR_TEXT = "Invalid `variable` option passed into `_.template`";
    var reEmptyStringLeading = /\b__p \+= '';/g;
    var reEmptyStringMiddle = /\b(__p \+=) '' \+/g;
    var reEmptyStringTrailing = /(__e\(.*?\)|\b__t\)) \+\n'';/g;
    var reForbiddenIdentifierChars = /[()=,{}\[\]\/\s]/;
    var reEsTemplate = /\$\{([^\\}]*(?:\\.[^\\}]*)*)\}/g;
    var reNoMatch = /($^)/;
    var reUnescapedString = /['\n\r\u2028\u2029\\]/g;
    var objectProto$1 = Object.prototype;
    var hasOwnProperty$2 = objectProto$1.hasOwnProperty;
    function template(string, options, guard) {
      var settings = templateSettings.imports._.templateSettings || templateSettings;
      if (guard && isIterateeCall(string, options, guard)) {
        options = void 0;
      }
      string = toString(string);
      options = assignInWith({}, options, settings, customDefaultsAssignIn);
      var imports = assignInWith({}, options.imports, settings.imports, customDefaultsAssignIn), importsKeys = keys(imports), importsValues = baseValues(imports, importsKeys);
      var isEscaping, isEvaluating, index = 0, interpolate = options.interpolate || reNoMatch, source = "__p += '";
      var reDelimiters = RegExp((options.escape || reNoMatch).source + "|" + interpolate.source + "|" + (interpolate === reInterpolate ? reEsTemplate : reNoMatch).source + "|" + (options.evaluate || reNoMatch).source + "|$", "g");
      var sourceURL = hasOwnProperty$2.call(options, "sourceURL") ? "//# sourceURL=" + (options.sourceURL + "").replace(/\s/g, " ") + "\n" : "";
      string.replace(reDelimiters, function(match, escapeValue, interpolateValue, esTemplateValue, evaluateValue, offset) {
        interpolateValue || (interpolateValue = esTemplateValue);
        source += string.slice(index, offset).replace(reUnescapedString, escapeStringChar);
        if (escapeValue) {
          isEscaping = true;
          source += "' +\n__e(" + escapeValue + ") +\n'";
        }
        if (evaluateValue) {
          isEvaluating = true;
          source += "';\n" + evaluateValue + ";\n__p += '";
        }
        if (interpolateValue) {
          source += "' +\n((__t = (" + interpolateValue + ")) == null ? '' : __t) +\n'";
        }
        index = offset + match.length;
        return match;
      });
      source += "';\n";
      var variable = hasOwnProperty$2.call(options, "variable") && options.variable;
      if (!variable) {
        source = "with (obj) {\n" + source + "\n}\n";
      } else if (reForbiddenIdentifierChars.test(variable)) {
        throw new Error(INVALID_TEMPL_VAR_ERROR_TEXT);
      }
      source = (isEvaluating ? source.replace(reEmptyStringLeading, "") : source).replace(reEmptyStringMiddle, "$1").replace(reEmptyStringTrailing, "$1;");
      source = "function(" + (variable || "obj") + ") {\n" + (variable ? "" : "obj || (obj = {});\n") + "var __t, __p = ''" + (isEscaping ? ", __e = _.escape" : "") + (isEvaluating ? ", __j = Array.prototype.join;\nfunction print() { __p += __j.call(arguments, '') }\n" : ";\n") + source + "return __p\n}";
      var result = attempt(function() {
        return Function(importsKeys, sourceURL + "return " + source).apply(void 0, importsValues);
      });
      result.source = source;
      if (isError(result)) {
        throw result;
      }
      return result;
    }
  
    var FUNC_ERROR_TEXT = "Expected a function";
    function throttle(func, wait, options) {
      var leading = true, trailing = true;
      if (typeof func != "function") {
        throw new TypeError(FUNC_ERROR_TEXT);
      }
      if (isObject$2(options)) {
        leading = "leading" in options ? !!options.leading : leading;
        trailing = "trailing" in options ? !!options.trailing : trailing;
      }
      return debounce(func, wait, {
        "leading": leading,
        "maxWait": wait,
        "trailing": trailing
      });
    }
  
    function thru(value, interceptor) {
      return interceptor(value);
    }
  
    var MAX_SAFE_INTEGER$1 = 9007199254740991;
    var MAX_ARRAY_LENGTH$1 = 4294967295;
    var nativeMin$3 = Math.min;
    function times(n, iteratee) {
      n = toInteger(n);
      if (n < 1 || n > MAX_SAFE_INTEGER$1) {
        return [];
      }
      var index = MAX_ARRAY_LENGTH$1, length = nativeMin$3(n, MAX_ARRAY_LENGTH$1);
      iteratee = castFunction(iteratee);
      n -= MAX_ARRAY_LENGTH$1;
      var result = baseTimes(length, iteratee);
      while (++index < n) {
        iteratee(index);
      }
      return result;
    }
  
    function wrapperToIterator() {
      return this;
    }
  
    function baseWrapperValue(value, actions) {
      var result = value;
      if (result instanceof LazyWrapper) {
        result = result.value();
      }
      return arrayReduce(actions, function(result2, action) {
        return action.func.apply(action.thisArg, arrayPush([result2], action.args));
      }, result);
    }
  
    function wrapperValue() {
      return baseWrapperValue(this.__wrapped__, this.__actions__);
    }
  
    function toLower(value) {
      return toString(value).toLowerCase();
    }
  
    function toPath(value) {
      if (isArray$1(value)) {
        return arrayMap(value, toKey);
      }
      return isSymbol(value) ? [value] : copyArray(stringToPath(toString(value)));
    }
  
    var MAX_SAFE_INTEGER = 9007199254740991;
    function toSafeInteger(value) {
      return value ? baseClamp(toInteger(value), -MAX_SAFE_INTEGER, MAX_SAFE_INTEGER) : value === 0 ? value : 0;
    }
  
    function toUpper(value) {
      return toString(value).toUpperCase();
    }
  
    function transform(object, iteratee, accumulator) {
      var isArr = isArray$1(object), isArrLike = isArr || isBuffer(object) || isTypedArray(object);
      iteratee = baseIteratee(iteratee);
      if (accumulator == null) {
        var Ctor = object && object.constructor;
        if (isArrLike) {
          accumulator = isArr ? new Ctor() : [];
        } else if (isObject$2(object)) {
          accumulator = isFunction$1(Ctor) ? baseCreate(getPrototype(object)) : {};
        } else {
          accumulator = {};
        }
      }
      (isArrLike ? arrayEach : baseForOwn)(object, function(value, index, object2) {
        return iteratee(accumulator, value, index, object2);
      });
      return accumulator;
    }
  
    function charsEndIndex(strSymbols, chrSymbols) {
      var index = strSymbols.length;
      while (index-- && baseIndexOf(chrSymbols, strSymbols[index], 0) > -1) {
      }
      return index;
    }
  
    function charsStartIndex(strSymbols, chrSymbols) {
      var index = -1, length = strSymbols.length;
      while (++index < length && baseIndexOf(chrSymbols, strSymbols[index], 0) > -1) {
      }
      return index;
    }
  
    function trim(string, chars, guard) {
      string = toString(string);
      if (string && (guard || chars === void 0)) {
        return baseTrim(string);
      }
      if (!string || !(chars = baseToString(chars))) {
        return string;
      }
      var strSymbols = stringToArray(string), chrSymbols = stringToArray(chars), start = charsStartIndex(strSymbols, chrSymbols), end = charsEndIndex(strSymbols, chrSymbols) + 1;
      return castSlice(strSymbols, start, end).join("");
    }
  
    function trimEnd(string, chars, guard) {
      string = toString(string);
      if (string && (guard || chars === void 0)) {
        return string.slice(0, trimmedEndIndex(string) + 1);
      }
      if (!string || !(chars = baseToString(chars))) {
        return string;
      }
      var strSymbols = stringToArray(string), end = charsEndIndex(strSymbols, stringToArray(chars)) + 1;
      return castSlice(strSymbols, 0, end).join("");
    }
  
    var reTrimStart = /^\s+/;
    function trimStart(string, chars, guard) {
      string = toString(string);
      if (string && (guard || chars === void 0)) {
        return string.replace(reTrimStart, "");
      }
      if (!string || !(chars = baseToString(chars))) {
        return string;
      }
      var strSymbols = stringToArray(string), start = charsStartIndex(strSymbols, stringToArray(chars));
      return castSlice(strSymbols, start).join("");
    }
  
    var DEFAULT_TRUNC_LENGTH = 30;
    var DEFAULT_TRUNC_OMISSION = "...";
    var reFlags = /\w*$/;
    function truncate(string, options) {
      var length = DEFAULT_TRUNC_LENGTH, omission = DEFAULT_TRUNC_OMISSION;
      if (isObject$2(options)) {
        var separator = "separator" in options ? options.separator : separator;
        length = "length" in options ? toInteger(options.length) : length;
        omission = "omission" in options ? baseToString(options.omission) : omission;
      }
      string = toString(string);
      var strLength = string.length;
      if (hasUnicode(string)) {
        var strSymbols = stringToArray(string);
        strLength = strSymbols.length;
      }
      if (length >= strLength) {
        return string;
      }
      var end = length - stringSize(omission);
      if (end < 1) {
        return omission;
      }
      var result = strSymbols ? castSlice(strSymbols, 0, end).join("") : string.slice(0, end);
      if (separator === void 0) {
        return result + omission;
      }
      if (strSymbols) {
        end += result.length - end;
      }
      if (isRegExp(separator)) {
        if (string.slice(end).search(separator)) {
          var match, substring = result;
          if (!separator.global) {
            separator = RegExp(separator.source, toString(reFlags.exec(separator)) + "g");
          }
          separator.lastIndex = 0;
          while (match = separator.exec(substring)) {
            var newEnd = match.index;
          }
          result = result.slice(0, newEnd === void 0 ? end : newEnd);
        }
      } else if (string.indexOf(baseToString(separator), end) != end) {
        var index = result.lastIndexOf(separator);
        if (index > -1) {
          result = result.slice(0, index);
        }
      }
      return result + omission;
    }
  
    function unary(func) {
      return ary(func, 1);
    }
  
    var htmlUnescapes = {
      "&amp;": "&",
      "&lt;": "<",
      "&gt;": ">",
      "&quot;": '"',
      "&#39;": "'"
    };
    var unescapeHtmlChar = basePropertyOf(htmlUnescapes);
  
    var reEscapedHtml = /&(?:amp|lt|gt|quot|#39);/g;
    var reHasEscapedHtml = RegExp(reEscapedHtml.source);
    function unescape(string) {
      string = toString(string);
      return string && reHasEscapedHtml.test(string) ? string.replace(reEscapedHtml, unescapeHtmlChar) : string;
    }
  
    var INFINITY = 1 / 0;
    var createSet = !(Set$1 && 1 / setToArray(new Set$1([, -0]))[1] == INFINITY) ? noop$1 : function(values) {
      return new Set$1(values);
    };
  
    var LARGE_ARRAY_SIZE = 200;
    function baseUniq(array, iteratee, comparator) {
      var index = -1, includes = arrayIncludes, length = array.length, isCommon = true, result = [], seen = result;
      if (comparator) {
        isCommon = false;
        includes = arrayIncludesWith;
      } else if (length >= LARGE_ARRAY_SIZE) {
        var set = iteratee ? null : createSet(array);
        if (set) {
          return setToArray(set);
        }
        isCommon = false;
        includes = cacheHas;
        seen = new SetCache();
      } else {
        seen = iteratee ? [] : result;
      }
      outer:
        while (++index < length) {
          var value = array[index], computed = iteratee ? iteratee(value) : value;
          value = comparator || value !== 0 ? value : 0;
          if (isCommon && computed === computed) {
            var seenIndex = seen.length;
            while (seenIndex--) {
              if (seen[seenIndex] === computed) {
                continue outer;
              }
            }
            if (iteratee) {
              seen.push(computed);
            }
            result.push(value);
          } else if (!includes(seen, computed, comparator)) {
            if (seen !== result) {
              seen.push(computed);
            }
            result.push(value);
          }
        }
      return result;
    }
  
    var union = baseRest(function(arrays) {
      return baseUniq(baseFlatten(arrays, 1, isArrayLikeObject, true));
    });
  
    var unionBy = baseRest(function(arrays) {
      var iteratee = last(arrays);
      if (isArrayLikeObject(iteratee)) {
        iteratee = void 0;
      }
      return baseUniq(baseFlatten(arrays, 1, isArrayLikeObject, true), baseIteratee(iteratee));
    });
  
    var unionWith = baseRest(function(arrays) {
      var comparator = last(arrays);
      comparator = typeof comparator == "function" ? comparator : void 0;
      return baseUniq(baseFlatten(arrays, 1, isArrayLikeObject, true), void 0, comparator);
    });
  
    function uniq(array) {
      return array && array.length ? baseUniq(array) : [];
    }
  
    function uniqBy(array, iteratee) {
      return array && array.length ? baseUniq(array, baseIteratee(iteratee)) : [];
    }
  
    function uniqWith(array, comparator) {
      comparator = typeof comparator == "function" ? comparator : void 0;
      return array && array.length ? baseUniq(array, void 0, comparator) : [];
    }
  
    var idCounter = 0;
    function uniqueId(prefix) {
      var id = ++idCounter;
      return toString(prefix) + id;
    }
  
    function unset(object, path) {
      return object == null ? true : baseUnset(object, path);
    }
  
    var nativeMax$2 = Math.max;
    function unzip(array) {
      if (!(array && array.length)) {
        return [];
      }
      var length = 0;
      array = arrayFilter(array, function(group) {
        if (isArrayLikeObject(group)) {
          length = nativeMax$2(group.length, length);
          return true;
        }
      });
      return baseTimes(length, function(index) {
        return arrayMap(array, baseProperty(index));
      });
    }
  
    function unzipWith(array, iteratee) {
      if (!(array && array.length)) {
        return [];
      }
      var result = unzip(array);
      if (iteratee == null) {
        return result;
      }
      return arrayMap(result, function(group) {
        return apply(iteratee, void 0, group);
      });
    }
  
    function baseUpdate(object, path, updater, customizer) {
      return baseSet(object, path, updater(baseGet(object, path)), customizer);
    }
  
    function update(object, path, updater) {
      return object == null ? object : baseUpdate(object, path, castFunction(updater));
    }
  
    function updateWith(object, path, updater, customizer) {
      customizer = typeof customizer == "function" ? customizer : void 0;
      return object == null ? object : baseUpdate(object, path, castFunction(updater), customizer);
    }
  
    var upperCase = createCompounder(function(result, word, index) {
      return result + (index ? " " : "") + word.toUpperCase();
    });
  
    function valuesIn(object) {
      return object == null ? [] : baseValues(object, keysIn(object));
    }
  
    var without = baseRest(function(array, values) {
      return isArrayLikeObject(array) ? baseDifference(array, values) : [];
    });
  
    function wrap(value, wrapper) {
      return partial(castFunction(wrapper), value);
    }
  
    var wrapperAt = flatRest(function(paths) {
      var length = paths.length, start = length ? paths[0] : 0, value = this.__wrapped__, interceptor = function(object) {
        return baseAt(object, paths);
      };
      if (length > 1 || this.__actions__.length || !(value instanceof LazyWrapper) || !isIndex(start)) {
        return this.thru(interceptor);
      }
      value = value.slice(start, +start + (length ? 1 : 0));
      value.__actions__.push({
        "func": thru,
        "args": [interceptor],
        "thisArg": void 0
      });
      return new LodashWrapper(value, this.__chain__).thru(function(array) {
        if (length && !array.length) {
          array.push(void 0);
        }
        return array;
      });
    });
  
    function wrapperChain() {
      return chain(this);
    }
  
    function wrapperReverse() {
      var value = this.__wrapped__;
      if (value instanceof LazyWrapper) {
        var wrapped = value;
        if (this.__actions__.length) {
          wrapped = new LazyWrapper(this);
        }
        wrapped = wrapped.reverse();
        wrapped.__actions__.push({
          "func": thru,
          "args": [reverse],
          "thisArg": void 0
        });
        return new LodashWrapper(wrapped, this.__chain__);
      }
      return this.thru(reverse);
    }
  
    function baseXor(arrays, iteratee, comparator) {
      var length = arrays.length;
      if (length < 2) {
        return length ? baseUniq(arrays[0]) : [];
      }
      var index = -1, result = Array(length);
      while (++index < length) {
        var array = arrays[index], othIndex = -1;
        while (++othIndex < length) {
          if (othIndex != index) {
            result[index] = baseDifference(result[index] || array, arrays[othIndex], iteratee, comparator);
          }
        }
      }
      return baseUniq(baseFlatten(result, 1), iteratee, comparator);
    }
  
    var xor = baseRest(function(arrays) {
      return baseXor(arrayFilter(arrays, isArrayLikeObject));
    });
  
    var xorBy = baseRest(function(arrays) {
      var iteratee = last(arrays);
      if (isArrayLikeObject(iteratee)) {
        iteratee = void 0;
      }
      return baseXor(arrayFilter(arrays, isArrayLikeObject), baseIteratee(iteratee));
    });
  
    var xorWith = baseRest(function(arrays) {
      var comparator = last(arrays);
      comparator = typeof comparator == "function" ? comparator : void 0;
      return baseXor(arrayFilter(arrays, isArrayLikeObject), void 0, comparator);
    });
  
    var zip = baseRest(unzip);
  
    function baseZipObject(props, values, assignFunc) {
      var index = -1, length = props.length, valsLength = values.length, result = {};
      while (++index < length) {
        var value = index < valsLength ? values[index] : void 0;
        assignFunc(result, props[index], value);
      }
      return result;
    }
  
    function zipObject(props, values) {
      return baseZipObject(props || [], values || [], assignValue);
    }
  
    function zipObjectDeep(props, values) {
      return baseZipObject(props || [], values || [], baseSet);
    }
  
    var zipWith = baseRest(function(arrays) {
      var length = arrays.length, iteratee = length > 1 ? arrays[length - 1] : void 0;
      iteratee = typeof iteratee == "function" ? (arrays.pop(), iteratee) : void 0;
      return unzipWith(arrays, iteratee);
    });
  
    var array = {
      chunk,
      compact,
      concat,
      difference,
      differenceBy,
      differenceWith,
      drop,
      dropRight,
      dropRightWhile,
      dropWhile,
      fill,
      findIndex,
      findLastIndex,
      first: head,
      flatten,
      flattenDeep,
      flattenDepth,
      fromPairs,
      head,
      indexOf,
      initial,
      intersection,
      intersectionBy,
      intersectionWith,
      join,
      last,
      lastIndexOf,
      nth,
      pull,
      pullAll,
      pullAllBy,
      pullAllWith,
      pullAt,
      remove,
      reverse,
      slice,
      sortedIndex,
      sortedIndexBy,
      sortedIndexOf,
      sortedLastIndex,
      sortedLastIndexBy,
      sortedLastIndexOf,
      sortedUniq,
      sortedUniqBy,
      tail,
      take,
      takeRight,
      takeRightWhile,
      takeWhile,
      union,
      unionBy,
      unionWith,
      uniq,
      uniqBy,
      uniqWith,
      unzip,
      unzipWith,
      without,
      xor,
      xorBy,
      xorWith,
      zip,
      zipObject,
      zipObjectDeep,
      zipWith
    };
  
    var collection = {
      countBy,
      each: forEach,
      eachRight: forEachRight,
      every,
      filter,
      find,
      findLast,
      flatMap,
      flatMapDeep,
      flatMapDepth,
      forEach,
      forEachRight,
      groupBy,
      includes,
      invokeMap,
      keyBy,
      map,
      orderBy: orderBy$1,
      partition,
      reduce,
      reduceRight,
      reject,
      sample,
      sampleSize,
      shuffle,
      size,
      some,
      sortBy
    };
  
    var date$1 = {
      now
    };
  
    var func = {
      after,
      ary,
      before,
      bind,
      bindKey,
      curry,
      curryRight,
      debounce,
      defer,
      delay,
      flip,
      memoize,
      negate,
      once,
      overArgs,
      partial,
      partialRight,
      rearg,
      rest,
      spread,
      throttle,
      unary,
      wrap
    };
  
    var lang = {
      castArray: castArray$1,
      clone,
      cloneDeep,
      cloneDeepWith,
      cloneWith,
      conformsTo,
      eq,
      gt: gt$1,
      gte,
      isArguments,
      isArray: isArray$1,
      isArrayBuffer,
      isArrayLike,
      isArrayLikeObject,
      isBoolean: isBoolean$1,
      isBuffer,
      isDate: isDate$1,
      isElement: isElement$2,
      isEmpty: isEmpty$1,
      isEqual: isEqual$1,
      isEqualWith,
      isError,
      isFinite,
      isFunction: isFunction$1,
      isInteger,
      isLength,
      isMap,
      isMatch,
      isMatchWith,
      isNaN: isNaN$1,
      isNative,
      isNil,
      isNull,
      isNumber: isNumber$1,
      isObject: isObject$2,
      isObjectLike,
      isPlainObject,
      isRegExp,
      isSafeInteger,
      isSet,
      isString: isString$2,
      isSymbol,
      isTypedArray,
      isUndefined: isUndefined$1,
      isWeakMap,
      isWeakSet,
      lt: lt$1,
      lte,
      toArray,
      toFinite,
      toInteger,
      toLength,
      toNumber,
      toPlainObject,
      toSafeInteger,
      toString
    };
  
    var math = {
      add,
      ceil,
      divide,
      floor: floor$1,
      max: max$3,
      maxBy,
      mean,
      meanBy,
      min: min$3,
      minBy,
      multiply,
      round: round$1,
      subtract,
      sum: sum$1,
      sumBy
    };
  
    var number = {
      clamp,
      inRange,
      random
    };
  
    var object = {
      assign,
      assignIn,
      assignInWith,
      assignWith,
      at: at$1,
      create,
      defaults,
      defaultsDeep,
      entries: toPairs,
      entriesIn: toPairsIn,
      extend: assignIn,
      extendWith: assignInWith,
      findKey,
      findLastKey,
      forIn,
      forInRight,
      forOwn,
      forOwnRight,
      functions,
      functionsIn,
      get,
      has,
      hasIn,
      invert,
      invertBy,
      invoke,
      keys,
      keysIn,
      mapKeys,
      mapValues,
      merge,
      mergeWith,
      omit,
      omitBy,
      pick,
      pickBy,
      result,
      set,
      setWith,
      toPairs,
      toPairsIn,
      transform,
      unset,
      update,
      updateWith,
      values,
      valuesIn
    };
  
    var seq = {
      at: wrapperAt,
      chain,
      commit: wrapperCommit,
      lodash,
      next: wrapperNext,
      plant: wrapperPlant,
      reverse: wrapperReverse,
      tap,
      thru,
      toIterator: wrapperToIterator,
      toJSON: wrapperValue,
      value: wrapperValue,
      valueOf: wrapperValue,
      wrapperChain
    };
  
    var string$1 = {
      camelCase,
      capitalize: capitalize$2,
      deburr,
      endsWith,
      escape,
      escapeRegExp,
      kebabCase,
      lowerCase,
      lowerFirst,
      pad,
      padEnd,
      padStart,
      parseInt: parseInt$1,
      repeat,
      replace,
      snakeCase,
      split,
      startCase,
      startsWith,
      template,
      templateSettings,
      toLower,
      toUpper,
      trim,
      trimEnd,
      trimStart,
      truncate,
      unescape,
      upperCase,
      upperFirst,
      words
    };
  
    var util = {
      attempt,
      bindAll,
      cond,
      conforms,
      constant,
      defaultTo,
      flow,
      flowRight,
      identity: identity$1,
      iteratee,
      matches,
      matchesProperty,
      method,
      methodOf,
      mixin: mixin$1,
      noop: noop$1,
      nthArg,
      over,
      overEvery,
      overSome,
      property,
      propertyOf,
      range: range$1,
      rangeRight,
      stubArray,
      stubFalse,
      stubObject,
      stubString,
      stubTrue,
      times,
      toPath,
      uniqueId
    };
  
    function lazyClone() {
      var result = new LazyWrapper(this.__wrapped__);
      result.__actions__ = copyArray(this.__actions__);
      result.__dir__ = this.__dir__;
      result.__filtered__ = this.__filtered__;
      result.__iteratees__ = copyArray(this.__iteratees__);
      result.__takeCount__ = this.__takeCount__;
      result.__views__ = copyArray(this.__views__);
      return result;
    }
  
    function lazyReverse() {
      if (this.__filtered__) {
        var result = new LazyWrapper(this);
        result.__dir__ = -1;
        result.__filtered__ = true;
      } else {
        result = this.clone();
        result.__dir__ *= -1;
      }
      return result;
    }
  
    var nativeMax$1 = Math.max;
    var nativeMin$2 = Math.min;
    function getView(start, end, transforms) {
      var index = -1, length = transforms.length;
      while (++index < length) {
        var data = transforms[index], size = data.size;
        switch (data.type) {
          case "drop":
            start += size;
            break;
          case "dropRight":
            end -= size;
            break;
          case "take":
            end = nativeMin$2(end, start + size);
            break;
          case "takeRight":
            start = nativeMax$1(start, end - size);
            break;
        }
      }
      return { "start": start, "end": end };
    }
  
    var LAZY_FILTER_FLAG$1 = 1;
    var LAZY_MAP_FLAG = 2;
    var nativeMin$1 = Math.min;
    function lazyValue() {
      var array = this.__wrapped__.value(), dir = this.__dir__, isArr = isArray$1(array), isRight = dir < 0, arrLength = isArr ? array.length : 0, view = getView(0, arrLength, this.__views__), start = view.start, end = view.end, length = end - start, index = isRight ? end : start - 1, iteratees = this.__iteratees__, iterLength = iteratees.length, resIndex = 0, takeCount = nativeMin$1(length, this.__takeCount__);
      if (!isArr || !isRight && arrLength == length && takeCount == length) {
        return baseWrapperValue(array, this.__actions__);
      }
      var result = [];
      outer:
        while (length-- && resIndex < takeCount) {
          index += dir;
          var iterIndex = -1, value = array[index];
          while (++iterIndex < iterLength) {
            var data = iteratees[iterIndex], iteratee = data.iteratee, type = data.type, computed = iteratee(value);
            if (type == LAZY_MAP_FLAG) {
              value = computed;
            } else if (!computed) {
              if (type == LAZY_FILTER_FLAG$1) {
                continue outer;
              } else {
                break outer;
              }
            }
          }
          result[resIndex++] = value;
        }
      return result;
    }
  
    var VERSION = "4.17.21";
    var WRAP_BIND_KEY_FLAG = 2;
    var LAZY_FILTER_FLAG = 1;
    var LAZY_WHILE_FLAG = 3;
    var MAX_ARRAY_LENGTH = 4294967295;
    var arrayProto = Array.prototype;
    var objectProto = Object.prototype;
    var hasOwnProperty$1 = objectProto.hasOwnProperty;
    var symIterator = Symbol$1 ? Symbol$1.iterator : void 0;
    var nativeMax = Math.max;
    var nativeMin = Math.min;
    var mixin = function(func2) {
      return function(object2, source, options) {
        if (options == null) {
          var isObj = isObject$2(source), props = isObj && keys(source), methodNames = props && props.length && baseFunctions(source, props);
          if (!(methodNames ? methodNames.length : isObj)) {
            options = source;
            source = object2;
            object2 = this;
          }
        }
        return func2(object2, source, options);
      };
    }(mixin$1);
    lodash.after = func.after;
    lodash.ary = func.ary;
    lodash.assign = object.assign;
    lodash.assignIn = object.assignIn;
    lodash.assignInWith = object.assignInWith;
    lodash.assignWith = object.assignWith;
    lodash.at = object.at;
    lodash.before = func.before;
    lodash.bind = func.bind;
    lodash.bindAll = util.bindAll;
    lodash.bindKey = func.bindKey;
    lodash.castArray = lang.castArray;
    lodash.chain = seq.chain;
    lodash.chunk = array.chunk;
    lodash.compact = array.compact;
    lodash.concat = array.concat;
    lodash.cond = util.cond;
    lodash.conforms = util.conforms;
    lodash.constant = util.constant;
    lodash.countBy = collection.countBy;
    lodash.create = object.create;
    lodash.curry = func.curry;
    lodash.curryRight = func.curryRight;
    lodash.debounce = func.debounce;
    lodash.defaults = object.defaults;
    lodash.defaultsDeep = object.defaultsDeep;
    lodash.defer = func.defer;
    lodash.delay = func.delay;
    lodash.difference = array.difference;
    lodash.differenceBy = array.differenceBy;
    lodash.differenceWith = array.differenceWith;
    lodash.drop = array.drop;
    lodash.dropRight = array.dropRight;
    lodash.dropRightWhile = array.dropRightWhile;
    lodash.dropWhile = array.dropWhile;
    lodash.fill = array.fill;
    lodash.filter = collection.filter;
    lodash.flatMap = collection.flatMap;
    lodash.flatMapDeep = collection.flatMapDeep;
    lodash.flatMapDepth = collection.flatMapDepth;
    lodash.flatten = array.flatten;
    lodash.flattenDeep = array.flattenDeep;
    lodash.flattenDepth = array.flattenDepth;
    lodash.flip = func.flip;
    lodash.flow = util.flow;
    lodash.flowRight = util.flowRight;
    lodash.fromPairs = array.fromPairs;
    lodash.functions = object.functions;
    lodash.functionsIn = object.functionsIn;
    lodash.groupBy = collection.groupBy;
    lodash.initial = array.initial;
    lodash.intersection = array.intersection;
    lodash.intersectionBy = array.intersectionBy;
    lodash.intersectionWith = array.intersectionWith;
    lodash.invert = object.invert;
    lodash.invertBy = object.invertBy;
    lodash.invokeMap = collection.invokeMap;
    lodash.iteratee = util.iteratee;
    lodash.keyBy = collection.keyBy;
    lodash.keys = keys;
    lodash.keysIn = object.keysIn;
    lodash.map = collection.map;
    lodash.mapKeys = object.mapKeys;
    lodash.mapValues = object.mapValues;
    lodash.matches = util.matches;
    lodash.matchesProperty = util.matchesProperty;
    lodash.memoize = func.memoize;
    lodash.merge = object.merge;
    lodash.mergeWith = object.mergeWith;
    lodash.method = util.method;
    lodash.methodOf = util.methodOf;
    lodash.mixin = mixin;
    lodash.negate = negate;
    lodash.nthArg = util.nthArg;
    lodash.omit = object.omit;
    lodash.omitBy = object.omitBy;
    lodash.once = func.once;
    lodash.orderBy = collection.orderBy;
    lodash.over = util.over;
    lodash.overArgs = func.overArgs;
    lodash.overEvery = util.overEvery;
    lodash.overSome = util.overSome;
    lodash.partial = func.partial;
    lodash.partialRight = func.partialRight;
    lodash.partition = collection.partition;
    lodash.pick = object.pick;
    lodash.pickBy = object.pickBy;
    lodash.property = util.property;
    lodash.propertyOf = util.propertyOf;
    lodash.pull = array.pull;
    lodash.pullAll = array.pullAll;
    lodash.pullAllBy = array.pullAllBy;
    lodash.pullAllWith = array.pullAllWith;
    lodash.pullAt = array.pullAt;
    lodash.range = util.range;
    lodash.rangeRight = util.rangeRight;
    lodash.rearg = func.rearg;
    lodash.reject = collection.reject;
    lodash.remove = array.remove;
    lodash.rest = func.rest;
    lodash.reverse = array.reverse;
    lodash.sampleSize = collection.sampleSize;
    lodash.set = object.set;
    lodash.setWith = object.setWith;
    lodash.shuffle = collection.shuffle;
    lodash.slice = array.slice;
    lodash.sortBy = collection.sortBy;
    lodash.sortedUniq = array.sortedUniq;
    lodash.sortedUniqBy = array.sortedUniqBy;
    lodash.split = string$1.split;
    lodash.spread = func.spread;
    lodash.tail = array.tail;
    lodash.take = array.take;
    lodash.takeRight = array.takeRight;
    lodash.takeRightWhile = array.takeRightWhile;
    lodash.takeWhile = array.takeWhile;
    lodash.tap = seq.tap;
    lodash.throttle = func.throttle;
    lodash.thru = thru;
    lodash.toArray = lang.toArray;
    lodash.toPairs = object.toPairs;
    lodash.toPairsIn = object.toPairsIn;
    lodash.toPath = util.toPath;
    lodash.toPlainObject = lang.toPlainObject;
    lodash.transform = object.transform;
    lodash.unary = func.unary;
    lodash.union = array.union;
    lodash.unionBy = array.unionBy;
    lodash.unionWith = array.unionWith;
    lodash.uniq = array.uniq;
    lodash.uniqBy = array.uniqBy;
    lodash.uniqWith = array.uniqWith;
    lodash.unset = object.unset;
    lodash.unzip = array.unzip;
    lodash.unzipWith = array.unzipWith;
    lodash.update = object.update;
    lodash.updateWith = object.updateWith;
    lodash.values = object.values;
    lodash.valuesIn = object.valuesIn;
    lodash.without = array.without;
    lodash.words = string$1.words;
    lodash.wrap = func.wrap;
    lodash.xor = array.xor;
    lodash.xorBy = array.xorBy;
    lodash.xorWith = array.xorWith;
    lodash.zip = array.zip;
    lodash.zipObject = array.zipObject;
    lodash.zipObjectDeep = array.zipObjectDeep;
    lodash.zipWith = array.zipWith;
    lodash.entries = object.toPairs;
    lodash.entriesIn = object.toPairsIn;
    lodash.extend = object.assignIn;
    lodash.extendWith = object.assignInWith;
    mixin(lodash, lodash);
    lodash.add = math.add;
    lodash.attempt = util.attempt;
    lodash.camelCase = string$1.camelCase;
    lodash.capitalize = string$1.capitalize;
    lodash.ceil = math.ceil;
    lodash.clamp = number.clamp;
    lodash.clone = lang.clone;
    lodash.cloneDeep = lang.cloneDeep;
    lodash.cloneDeepWith = lang.cloneDeepWith;
    lodash.cloneWith = lang.cloneWith;
    lodash.conformsTo = lang.conformsTo;
    lodash.deburr = string$1.deburr;
    lodash.defaultTo = util.defaultTo;
    lodash.divide = math.divide;
    lodash.endsWith = string$1.endsWith;
    lodash.eq = lang.eq;
    lodash.escape = string$1.escape;
    lodash.escapeRegExp = string$1.escapeRegExp;
    lodash.every = collection.every;
    lodash.find = collection.find;
    lodash.findIndex = array.findIndex;
    lodash.findKey = object.findKey;
    lodash.findLast = collection.findLast;
    lodash.findLastIndex = array.findLastIndex;
    lodash.findLastKey = object.findLastKey;
    lodash.floor = math.floor;
    lodash.forEach = collection.forEach;
    lodash.forEachRight = collection.forEachRight;
    lodash.forIn = object.forIn;
    lodash.forInRight = object.forInRight;
    lodash.forOwn = object.forOwn;
    lodash.forOwnRight = object.forOwnRight;
    lodash.get = object.get;
    lodash.gt = lang.gt;
    lodash.gte = lang.gte;
    lodash.has = object.has;
    lodash.hasIn = object.hasIn;
    lodash.head = array.head;
    lodash.identity = identity$1;
    lodash.includes = collection.includes;
    lodash.indexOf = array.indexOf;
    lodash.inRange = number.inRange;
    lodash.invoke = object.invoke;
    lodash.isArguments = lang.isArguments;
    lodash.isArray = isArray$1;
    lodash.isArrayBuffer = lang.isArrayBuffer;
    lodash.isArrayLike = lang.isArrayLike;
    lodash.isArrayLikeObject = lang.isArrayLikeObject;
    lodash.isBoolean = lang.isBoolean;
    lodash.isBuffer = lang.isBuffer;
    lodash.isDate = lang.isDate;
    lodash.isElement = lang.isElement;
    lodash.isEmpty = lang.isEmpty;
    lodash.isEqual = lang.isEqual;
    lodash.isEqualWith = lang.isEqualWith;
    lodash.isError = lang.isError;
    lodash.isFinite = lang.isFinite;
    lodash.isFunction = lang.isFunction;
    lodash.isInteger = lang.isInteger;
    lodash.isLength = lang.isLength;
    lodash.isMap = lang.isMap;
    lodash.isMatch = lang.isMatch;
    lodash.isMatchWith = lang.isMatchWith;
    lodash.isNaN = lang.isNaN;
    lodash.isNative = lang.isNative;
    lodash.isNil = lang.isNil;
    lodash.isNull = lang.isNull;
    lodash.isNumber = lang.isNumber;
    lodash.isObject = isObject$2;
    lodash.isObjectLike = lang.isObjectLike;
    lodash.isPlainObject = lang.isPlainObject;
    lodash.isRegExp = lang.isRegExp;
    lodash.isSafeInteger = lang.isSafeInteger;
    lodash.isSet = lang.isSet;
    lodash.isString = lang.isString;
    lodash.isSymbol = lang.isSymbol;
    lodash.isTypedArray = lang.isTypedArray;
    lodash.isUndefined = lang.isUndefined;
    lodash.isWeakMap = lang.isWeakMap;
    lodash.isWeakSet = lang.isWeakSet;
    lodash.join = array.join;
    lodash.kebabCase = string$1.kebabCase;
    lodash.last = last;
    lodash.lastIndexOf = array.lastIndexOf;
    lodash.lowerCase = string$1.lowerCase;
    lodash.lowerFirst = string$1.lowerFirst;
    lodash.lt = lang.lt;
    lodash.lte = lang.lte;
    lodash.max = math.max;
    lodash.maxBy = math.maxBy;
    lodash.mean = math.mean;
    lodash.meanBy = math.meanBy;
    lodash.min = math.min;
    lodash.minBy = math.minBy;
    lodash.stubArray = util.stubArray;
    lodash.stubFalse = util.stubFalse;
    lodash.stubObject = util.stubObject;
    lodash.stubString = util.stubString;
    lodash.stubTrue = util.stubTrue;
    lodash.multiply = math.multiply;
    lodash.nth = array.nth;
    lodash.noop = util.noop;
    lodash.now = date$1.now;
    lodash.pad = string$1.pad;
    lodash.padEnd = string$1.padEnd;
    lodash.padStart = string$1.padStart;
    lodash.parseInt = string$1.parseInt;
    lodash.random = number.random;
    lodash.reduce = collection.reduce;
    lodash.reduceRight = collection.reduceRight;
    lodash.repeat = string$1.repeat;
    lodash.replace = string$1.replace;
    lodash.result = object.result;
    lodash.round = math.round;
    lodash.sample = collection.sample;
    lodash.size = collection.size;
    lodash.snakeCase = string$1.snakeCase;
    lodash.some = collection.some;
    lodash.sortedIndex = array.sortedIndex;
    lodash.sortedIndexBy = array.sortedIndexBy;
    lodash.sortedIndexOf = array.sortedIndexOf;
    lodash.sortedLastIndex = array.sortedLastIndex;
    lodash.sortedLastIndexBy = array.sortedLastIndexBy;
    lodash.sortedLastIndexOf = array.sortedLastIndexOf;
    lodash.startCase = string$1.startCase;
    lodash.startsWith = string$1.startsWith;
    lodash.subtract = math.subtract;
    lodash.sum = math.sum;
    lodash.sumBy = math.sumBy;
    lodash.template = string$1.template;
    lodash.times = util.times;
    lodash.toFinite = lang.toFinite;
    lodash.toInteger = toInteger;
    lodash.toLength = lang.toLength;
    lodash.toLower = string$1.toLower;
    lodash.toNumber = lang.toNumber;
    lodash.toSafeInteger = lang.toSafeInteger;
    lodash.toString = lang.toString;
    lodash.toUpper = string$1.toUpper;
    lodash.trim = string$1.trim;
    lodash.trimEnd = string$1.trimEnd;
    lodash.trimStart = string$1.trimStart;
    lodash.truncate = string$1.truncate;
    lodash.unescape = string$1.unescape;
    lodash.uniqueId = util.uniqueId;
    lodash.upperCase = string$1.upperCase;
    lodash.upperFirst = string$1.upperFirst;
    lodash.each = collection.forEach;
    lodash.eachRight = collection.forEachRight;
    lodash.first = array.head;
    mixin(lodash, function() {
      var source = {};
      baseForOwn(lodash, function(func2, methodName) {
        if (!hasOwnProperty$1.call(lodash.prototype, methodName)) {
          source[methodName] = func2;
        }
      });
      return source;
    }(), { "chain": false });
    lodash.VERSION = VERSION;
    (lodash.templateSettings = string$1.templateSettings).imports._ = lodash;
    arrayEach(["bind", "bindKey", "curry", "curryRight", "partial", "partialRight"], function(methodName) {
      lodash[methodName].placeholder = lodash;
    });
    arrayEach(["drop", "take"], function(methodName, index) {
      LazyWrapper.prototype[methodName] = function(n) {
        n = n === void 0 ? 1 : nativeMax(toInteger(n), 0);
        var result = this.__filtered__ && !index ? new LazyWrapper(this) : this.clone();
        if (result.__filtered__) {
          result.__takeCount__ = nativeMin(n, result.__takeCount__);
        } else {
          result.__views__.push({
            "size": nativeMin(n, MAX_ARRAY_LENGTH),
            "type": methodName + (result.__dir__ < 0 ? "Right" : "")
          });
        }
        return result;
      };
      LazyWrapper.prototype[methodName + "Right"] = function(n) {
        return this.reverse()[methodName](n).reverse();
      };
    });
    arrayEach(["filter", "map", "takeWhile"], function(methodName, index) {
      var type = index + 1, isFilter = type == LAZY_FILTER_FLAG || type == LAZY_WHILE_FLAG;
      LazyWrapper.prototype[methodName] = function(iteratee) {
        var result = this.clone();
        result.__iteratees__.push({
          "iteratee": baseIteratee(iteratee),
          "type": type
        });
        result.__filtered__ = result.__filtered__ || isFilter;
        return result;
      };
    });
    arrayEach(["head", "last"], function(methodName, index) {
      var takeName = "take" + (index ? "Right" : "");
      LazyWrapper.prototype[methodName] = function() {
        return this[takeName](1).value()[0];
      };
    });
    arrayEach(["initial", "tail"], function(methodName, index) {
      var dropName = "drop" + (index ? "" : "Right");
      LazyWrapper.prototype[methodName] = function() {
        return this.__filtered__ ? new LazyWrapper(this) : this[dropName](1);
      };
    });
    LazyWrapper.prototype.compact = function() {
      return this.filter(identity$1);
    };
    LazyWrapper.prototype.find = function(predicate) {
      return this.filter(predicate).head();
    };
    LazyWrapper.prototype.findLast = function(predicate) {
      return this.reverse().find(predicate);
    };
    LazyWrapper.prototype.invokeMap = baseRest(function(path, args) {
      if (typeof path == "function") {
        return new LazyWrapper(this);
      }
      return this.map(function(value) {
        return baseInvoke(value, path, args);
      });
    });
    LazyWrapper.prototype.reject = function(predicate) {
      return this.filter(negate(baseIteratee(predicate)));
    };
    LazyWrapper.prototype.slice = function(start, end) {
      start = toInteger(start);
      var result = this;
      if (result.__filtered__ && (start > 0 || end < 0)) {
        return new LazyWrapper(result);
      }
      if (start < 0) {
        result = result.takeRight(-start);
      } else if (start) {
        result = result.drop(start);
      }
      if (end !== void 0) {
        end = toInteger(end);
        result = end < 0 ? result.dropRight(-end) : result.take(end - start);
      }
      return result;
    };
    LazyWrapper.prototype.takeRightWhile = function(predicate) {
      return this.reverse().takeWhile(predicate).reverse();
    };
    LazyWrapper.prototype.toArray = function() {
      return this.take(MAX_ARRAY_LENGTH);
    };
    baseForOwn(LazyWrapper.prototype, function(func2, methodName) {
      var checkIteratee = /^(?:filter|find|map|reject)|While$/.test(methodName), isTaker = /^(?:head|last)$/.test(methodName), lodashFunc = lodash[isTaker ? "take" + (methodName == "last" ? "Right" : "") : methodName], retUnwrapped = isTaker || /^find/.test(methodName);
      if (!lodashFunc) {
        return;
      }
      lodash.prototype[methodName] = function() {
        var value = this.__wrapped__, args = isTaker ? [1] : arguments, isLazy = value instanceof LazyWrapper, iteratee = args[0], useLazy = isLazy || isArray$1(value);
        var interceptor = function(value2) {
          var result2 = lodashFunc.apply(lodash, arrayPush([value2], args));
          return isTaker && chainAll ? result2[0] : result2;
        };
        if (useLazy && checkIteratee && typeof iteratee == "function" && iteratee.length != 1) {
          isLazy = useLazy = false;
        }
        var chainAll = this.__chain__, isHybrid = !!this.__actions__.length, isUnwrapped = retUnwrapped && !chainAll, onlyLazy = isLazy && !isHybrid;
        if (!retUnwrapped && useLazy) {
          value = onlyLazy ? value : new LazyWrapper(this);
          var result = func2.apply(value, args);
          result.__actions__.push({ "func": thru, "args": [interceptor], "thisArg": void 0 });
          return new LodashWrapper(result, chainAll);
        }
        if (isUnwrapped && onlyLazy) {
          return func2.apply(this, args);
        }
        result = this.thru(interceptor);
        return isUnwrapped ? isTaker ? result.value()[0] : result.value() : result;
      };
    });
    arrayEach(["pop", "push", "shift", "sort", "splice", "unshift"], function(methodName) {
      var func2 = arrayProto[methodName], chainName = /^(?:push|sort|unshift)$/.test(methodName) ? "tap" : "thru", retUnwrapped = /^(?:pop|shift)$/.test(methodName);
      lodash.prototype[methodName] = function() {
        var args = arguments;
        if (retUnwrapped && !this.__chain__) {
          var value = this.value();
          return func2.apply(isArray$1(value) ? value : [], args);
        }
        return this[chainName](function(value2) {
          return func2.apply(isArray$1(value2) ? value2 : [], args);
        });
      };
    });
    baseForOwn(LazyWrapper.prototype, function(func2, methodName) {
      var lodashFunc = lodash[methodName];
      if (lodashFunc) {
        var key = lodashFunc.name + "";
        if (!hasOwnProperty$1.call(realNames, key)) {
          realNames[key] = [];
        }
        realNames[key].push({ "name": methodName, "func": lodashFunc });
      }
    });
    realNames[createHybrid(void 0, WRAP_BIND_KEY_FLAG).name] = [{
      "name": "wrapper",
      "func": void 0
    }];
    LazyWrapper.prototype.clone = lazyClone;
    LazyWrapper.prototype.reverse = lazyReverse;
    LazyWrapper.prototype.value = lazyValue;
    lodash.prototype.at = seq.at;
    lodash.prototype.chain = seq.wrapperChain;
    lodash.prototype.commit = seq.commit;
    lodash.prototype.next = seq.next;
    lodash.prototype.plant = seq.plant;
    lodash.prototype.reverse = seq.reverse;
    lodash.prototype.toJSON = lodash.prototype.valueOf = lodash.prototype.value = seq.value;
    lodash.prototype.first = lodash.prototype.head;
    if (symIterator) {
      lodash.prototype[symIterator] = seq.toIterator;
    }
    /**
     * @license
     * Lodash (Custom Build) <https://lodash.com/>
     * Build: `lodash modularize exports="es" -o ./`
     * Copyright OpenJS Foundation and other contributors <https://openjsf.org/>
     * Released under MIT license <https://lodash.com/license>
     * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
     * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
     */
  
    const FOCUSABLE_ELEMENT_SELECTORS = `a[href],button:not([disabled]),button:not([hidden]),:not([tabindex="-1"]),input:not([disabled]),input:not([type="hidden"]),select:not([disabled]),textarea:not([disabled])`;
    const isVisible = (element) => {
      const computed = getComputedStyle(element);
      return computed.position === "fixed" ? false : element.offsetParent !== null;
    };
    const obtainAllFocusableElements$1 = (element) => {
      return Array.from(element.querySelectorAll(FOCUSABLE_ELEMENT_SELECTORS)).filter((item) => isFocusable(item) && isVisible(item));
    };
    const isFocusable = (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;
        }
      }
    };
    const triggerEvent = function(elm, name, ...opts) {
      let eventName;
      if (name.includes("mouse") || name.includes("click")) {
        eventName = "MouseEvents";
      } else if (name.includes("key")) {
        eventName = "KeyboardEvent";
      } else {
        eventName = "HTMLEvents";
      }
      const evt = document.createEvent(eventName);
      evt.initEvent(name, ...opts);
      elm.dispatchEvent(evt);
      return elm;
    };
    const isLeaf = (el) => !el.getAttribute("aria-owns");
    const getSibling = (el, distance, elClass) => {
      const { parentNode } = el;
      if (!parentNode)
        return null;
      const siblings = parentNode.querySelectorAll(elClass);
      const index = Array.prototype.indexOf.call(siblings, el);
      return siblings[index + distance] || null;
    };
    const focusNode = (el) => {
      if (!el)
        return;
      el.focus();
      !isLeaf(el) && el.click();
    };
  
    const composeEventHandlers = (theirsHandler, oursHandler, { checkForDefaultPrevented = true } = {}) => {
      const handleEvent = (event) => {
        const shouldPrevent = theirsHandler == null ? void 0 : theirsHandler(event);
        if (checkForDefaultPrevented === false || !shouldPrevent) {
          return oursHandler == null ? void 0 : oursHandler(event);
        }
      };
      return handleEvent;
    };
    const whenMouse = (handler) => {
      return (e) => e.pointerType === "mouse" ? handler(e) : void 0;
    };
  
    var __defProp$9 = Object.defineProperty;
    var __defProps$6 = Object.defineProperties;
    var __getOwnPropDescs$6 = Object.getOwnPropertyDescriptors;
    var __getOwnPropSymbols$b = Object.getOwnPropertySymbols;
    var __hasOwnProp$b = Object.prototype.hasOwnProperty;
    var __propIsEnum$b = Object.prototype.propertyIsEnumerable;
    var __defNormalProp$9 = (obj, key, value) => key in obj ? __defProp$9(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
    var __spreadValues$9 = (a, b) => {
      for (var prop in b || (b = {}))
        if (__hasOwnProp$b.call(b, prop))
          __defNormalProp$9(a, prop, b[prop]);
      if (__getOwnPropSymbols$b)
        for (var prop of __getOwnPropSymbols$b(b)) {
          if (__propIsEnum$b.call(b, prop))
            __defNormalProp$9(a, prop, b[prop]);
        }
      return a;
    };
    var __spreadProps$6 = (a, b) => __defProps$6(a, __getOwnPropDescs$6(b));
    function computedEager(fn, options) {
      var _a;
      const result = vue.shallowRef();
      vue.watchEffect(() => {
        result.value = fn();
      }, __spreadProps$6(__spreadValues$9({}, options), {
        flush: (_a = options == null ? void 0 : options.flush) != null ? _a : "sync"
      }));
      return vue.readonly(result);
    }
  
    var _a;
    const isClient = typeof window !== "undefined";
    const isDef = (val) => typeof val !== "undefined";
    const isBoolean = (val) => typeof val === "boolean";
    const isNumber = (val) => typeof val === "number";
    const isString$1 = (val) => typeof val === "string";
    const noop = () => {
    };
    isClient && ((_a = window == null ? void 0 : window.navigator) == null ? void 0 : _a.userAgent) && /iP(ad|hone|od)/.test(window.navigator.userAgent);
  
    function resolveUnref(r) {
      return typeof r === "function" ? r() : vue.unref(r);
    }
  
    function createFilterWrapper(filter, fn) {
      function wrapper(...args) {
        filter(() => fn.apply(this, args), { fn, thisArg: this, args });
      }
      return wrapper;
    }
    function debounceFilter(ms, options = {}) {
      let timer;
      let maxTimer;
      const filter = (invoke) => {
        const duration = resolveUnref(ms);
        const maxDuration = resolveUnref(options.maxWait);
        if (timer)
          clearTimeout(timer);
        if (duration <= 0 || maxDuration !== void 0 && maxDuration <= 0) {
          if (maxTimer) {
            clearTimeout(maxTimer);
            maxTimer = null;
          }
          return invoke();
        }
        if (maxDuration && !maxTimer) {
          maxTimer = setTimeout(() => {
            if (timer)
              clearTimeout(timer);
            maxTimer = null;
            invoke();
          }, maxDuration);
        }
        timer = setTimeout(() => {
          if (maxTimer)
            clearTimeout(maxTimer);
          maxTimer = null;
          invoke();
        }, duration);
      };
      return filter;
    }
    function throttleFilter(ms, trailing = true, leading = true) {
      let lastExec = 0;
      let timer;
      let isLeading = true;
      const clear = () => {
        if (timer) {
          clearTimeout(timer);
          timer = void 0;
        }
      };
      const filter = (invoke) => {
        const duration = resolveUnref(ms);
        const elapsed = Date.now() - lastExec;
        clear();
        if (duration <= 0) {
          lastExec = Date.now();
          return invoke();
        }
        if (elapsed > duration && (leading || !isLeading)) {
          lastExec = Date.now();
          invoke();
        } else if (trailing) {
          timer = setTimeout(() => {
            lastExec = Date.now();
            isLeading = true;
            clear();
            invoke();
          }, duration);
        }
        if (!leading && !timer)
          timer = setTimeout(() => isLeading = true, duration);
        isLeading = false;
      };
      return filter;
    }
    function identity(arg) {
      return arg;
    }
  
    function tryOnScopeDispose(fn) {
      if (vue.getCurrentScope()) {
        vue.onScopeDispose(fn);
        return true;
      }
      return false;
    }
  
    function useDebounceFn(fn, ms = 200, options = {}) {
      return createFilterWrapper(debounceFilter(ms, options), fn);
    }
  
    function refDebounced(value, ms = 200, options = {}) {
      if (ms <= 0)
        return value;
      const debounced = vue.ref(value.value);
      const updater = useDebounceFn(() => {
        debounced.value = value.value;
      }, ms, options);
      vue.watch(value, () => updater());
      return debounced;
    }
  
    function useThrottleFn(fn, ms = 200, trailing = false, leading = true) {
      return createFilterWrapper(throttleFilter(ms, trailing, leading), fn);
    }
  
    function tryOnMounted(fn, sync = true) {
      if (vue.getCurrentInstance())
        vue.onMounted(fn);
      else if (sync)
        fn();
      else
        vue.nextTick(fn);
    }
  
    function useTimeoutFn(cb, interval, options = {}) {
      const {
        immediate = true
      } = options;
      const isPending = vue.ref(false);
      let timer = null;
      function clear() {
        if (timer) {
          clearTimeout(timer);
          timer = null;
        }
      }
      function stop() {
        isPending.value = false;
        clear();
      }
      function start(...args) {
        clear();
        isPending.value = true;
        timer = setTimeout(() => {
          isPending.value = false;
          timer = null;
          cb(...args);
        }, resolveUnref(interval));
      }
      if (immediate) {
        isPending.value = true;
        if (isClient)
          start();
      }
      tryOnScopeDispose(stop);
      return {
        isPending,
        start,
        stop
      };
    }
  
    function unrefElement(elRef) {
      var _a;
      const plain = resolveUnref(elRef);
      return (_a = plain == null ? void 0 : plain.$el) != null ? _a : plain;
    }
  
    const defaultWindow = isClient ? window : void 0;
    const defaultDocument = isClient ? window.document : void 0;
  
    function useEventListener(...args) {
      let target;
      let event;
      let listener;
      let options;
      if (isString$1(args[0])) {
        [event, listener, options] = args;
        target = defaultWindow;
      } else {
        [target, event, listener, options] = args;
      }
      if (!target)
        return noop;
      let cleanup = noop;
      const stopWatch = vue.watch(() => unrefElement(target), (el) => {
        cleanup();
        if (!el)
          return;
        el.addEventListener(event, listener, options);
        cleanup = () => {
          el.removeEventListener(event, listener, options);
          cleanup = noop;
        };
      }, { immediate: true, flush: "post" });
      const stop = () => {
        stopWatch();
        cleanup();
      };
      tryOnScopeDispose(stop);
      return stop;
    }
  
    function onClickOutside(target, handler, options = {}) {
      const { window = defaultWindow, ignore, capture = true, detectIframe = false } = options;
      if (!window)
        return;
      const shouldListen = vue.ref(true);
      let fallback;
      const listener = (event) => {
        window.clearTimeout(fallback);
        const el = unrefElement(target);
        const composedPath = event.composedPath();
        if (!el || el === event.target || composedPath.includes(el) || !shouldListen.value)
          return;
        if (ignore && ignore.length > 0) {
          if (ignore.some((target2) => {
            const el2 = unrefElement(target2);
            return el2 && (event.target === el2 || composedPath.includes(el2));
          }))
            return;
        }
        handler(event);
      };
      const cleanup = [
        useEventListener(window, "click", listener, { passive: true, capture }),
        useEventListener(window, "pointerdown", (e) => {
          const el = unrefElement(target);
          shouldListen.value = !!el && !e.composedPath().includes(el);
        }, { passive: true }),
        useEventListener(window, "pointerup", (e) => {
          if (e.button === 0) {
            const path = e.composedPath();
            e.composedPath = () => path;
            fallback = window.setTimeout(() => listener(e), 50);
          }
        }, { passive: true }),
        detectIframe && useEventListener(window, "blur", (event) => {
          var _a;
          const el = unrefElement(target);
          if (((_a = document.activeElement) == null ? void 0 : _a.tagName) === "IFRAME" && !(el == null ? void 0 : el.contains(document.activeElement)))
            handler(event);
        })
      ].filter(Boolean);
      const stop = () => cleanup.forEach((fn) => fn());
      return stop;
    }
  
    function useSupported(callback, sync = false) {
      const isSupported = vue.ref();
      const update = () => isSupported.value = Boolean(callback());
      update();
      tryOnMounted(update, sync);
      return isSupported;
    }
  
    const _global = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
    const globalKey = "__vueuse_ssr_handlers__";
    _global[globalKey] = _global[globalKey] || {};
    _global[globalKey];
  
    function useCssVar(prop, target, { window = defaultWindow, initialValue = "" } = {}) {
      const variable = vue.ref(initialValue);
      const elRef = vue.computed(() => {
        var _a;
        return unrefElement(target) || ((_a = window == null ? void 0 : window.document) == null ? void 0 : _a.documentElement);
      });
      vue.watch([elRef, () => resolveUnref(prop)], ([el, prop2]) => {
        var _a;
        if (el && window) {
          const value = (_a = window.getComputedStyle(el).getPropertyValue(prop2)) == null ? void 0 : _a.trim();
          variable.value = value || initialValue;
        }
      }, { immediate: true });
      vue.watch(variable, (val) => {
        var _a;
        if ((_a = elRef.value) == null ? void 0 : _a.style)
          elRef.value.style.setProperty(resolveUnref(prop), val);
      });
      return variable;
    }
  
    function useDocumentVisibility({ document = defaultDocument } = {}) {
      if (!document)
        return vue.ref("visible");
      const visibility = vue.ref(document.visibilityState);
      useEventListener(document, "visibilitychange", () => {
        visibility.value = document.visibilityState;
      });
      return visibility;
    }
  
    var __getOwnPropSymbols$f = Object.getOwnPropertySymbols;
    var __hasOwnProp$f = Object.prototype.hasOwnProperty;
    var __propIsEnum$f = Object.prototype.propertyIsEnumerable;
    var __objRest$2 = (source, exclude) => {
      var target = {};
      for (var prop in source)
        if (__hasOwnProp$f.call(source, prop) && exclude.indexOf(prop) < 0)
          target[prop] = source[prop];
      if (source != null && __getOwnPropSymbols$f)
        for (var prop of __getOwnPropSymbols$f(source)) {
          if (exclude.indexOf(prop) < 0 && __propIsEnum$f.call(source, prop))
            target[prop] = source[prop];
        }
      return target;
    };
    function useResizeObserver(target, callback, options = {}) {
      const _a = options, { window = defaultWindow } = _a, observerOptions = __objRest$2(_a, ["window"]);
      let observer;
      const isSupported = useSupported(() => window && "ResizeObserver" in window);
      const cleanup = () => {
        if (observer) {
          observer.disconnect();
          observer = void 0;
        }
      };
      const stopWatch = vue.watch(() => unrefElement(target), (el) => {
        cleanup();
        if (isSupported.value && window && el) {
          observer = new ResizeObserver(callback);
          observer.observe(el, observerOptions);
        }
      }, { immediate: true, flush: "post" });
      const stop = () => {
        cleanup();
        stopWatch();
      };
      tryOnScopeDispose(stop);
      return {
        isSupported,
        stop
      };
    }
  
    function useElementBounding(target, options = {}) {
      const {
        reset = true,
        windowResize = true,
        windowScroll = true,
        immediate = true
      } = options;
      const height = vue.ref(0);
      const bottom = vue.ref(0);
      const left = vue.ref(0);
      const right = vue.ref(0);
      const top = vue.ref(0);
      const width = vue.ref(0);
      const x = vue.ref(0);
      const y = vue.ref(0);
      function update() {
        const el = unrefElement(target);
        if (!el) {
          if (reset) {
            height.value = 0;
            bottom.value = 0;
            left.value = 0;
            right.value = 0;
            top.value = 0;
            width.value = 0;
            x.value = 0;
            y.value = 0;
          }
          return;
        }
        const rect = el.getBoundingClientRect();
        height.value = rect.height;
        bottom.value = rect.bottom;
        left.value = rect.left;
        right.value = rect.right;
        top.value = rect.top;
        width.value = rect.width;
        x.value = rect.x;
        y.value = rect.y;
      }
      useResizeObserver(target, update);
      vue.watch(() => unrefElement(target), (ele) => !ele && update());
      if (windowScroll)
        useEventListener("scroll", update, { passive: true });
      if (windowResize)
        useEventListener("resize", update, { passive: true });
      tryOnMounted(() => {
        if (immediate)
          update();
      });
      return {
        height,
        bottom,
        left,
        right,
        top,
        width,
        x,
        y,
        update
      };
    }
  
    var SwipeDirection;
    (function(SwipeDirection2) {
      SwipeDirection2["UP"] = "UP";
      SwipeDirection2["RIGHT"] = "RIGHT";
      SwipeDirection2["DOWN"] = "DOWN";
      SwipeDirection2["LEFT"] = "LEFT";
      SwipeDirection2["NONE"] = "NONE";
    })(SwipeDirection || (SwipeDirection = {}));
  
    var __defProp = Object.defineProperty;
    var __getOwnPropSymbols = Object.getOwnPropertySymbols;
    var __hasOwnProp = Object.prototype.hasOwnProperty;
    var __propIsEnum = Object.prototype.propertyIsEnumerable;
    var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
    var __spreadValues = (a, b) => {
      for (var prop in b || (b = {}))
        if (__hasOwnProp.call(b, prop))
          __defNormalProp(a, prop, b[prop]);
      if (__getOwnPropSymbols)
        for (var prop of __getOwnPropSymbols(b)) {
          if (__propIsEnum.call(b, prop))
            __defNormalProp(a, prop, b[prop]);
        }
      return a;
    };
    const _TransitionPresets = {
      easeInSine: [0.12, 0, 0.39, 0],
      easeOutSine: [0.61, 1, 0.88, 1],
      easeInOutSine: [0.37, 0, 0.63, 1],
      easeInQuad: [0.11, 0, 0.5, 0],
      easeOutQuad: [0.5, 1, 0.89, 1],
      easeInOutQuad: [0.45, 0, 0.55, 1],
      easeInCubic: [0.32, 0, 0.67, 0],
      easeOutCubic: [0.33, 1, 0.68, 1],
      easeInOutCubic: [0.65, 0, 0.35, 1],
      easeInQuart: [0.5, 0, 0.75, 0],
      easeOutQuart: [0.25, 1, 0.5, 1],
      easeInOutQuart: [0.76, 0, 0.24, 1],
      easeInQuint: [0.64, 0, 0.78, 0],
      easeOutQuint: [0.22, 1, 0.36, 1],
      easeInOutQuint: [0.83, 0, 0.17, 1],
      easeInExpo: [0.7, 0, 0.84, 0],
      easeOutExpo: [0.16, 1, 0.3, 1],
      easeInOutExpo: [0.87, 0, 0.13, 1],
      easeInCirc: [0.55, 0, 1, 0.45],
      easeOutCirc: [0, 0.55, 0.45, 1],
      easeInOutCirc: [0.85, 0, 0.15, 1],
      easeInBack: [0.36, 0, 0.66, -0.56],
      easeOutBack: [0.34, 1.56, 0.64, 1],
      easeInOutBack: [0.68, -0.6, 0.32, 1.6]
    };
    __spreadValues({
      linear: identity
    }, _TransitionPresets);
  
    function useVModel(props, key, emit, options = {}) {
      var _a, _b, _c;
      const {
        passive = false,
        eventName,
        deep = false,
        defaultValue
      } = options;
      const vm = vue.getCurrentInstance();
      const _emit = emit || (vm == null ? void 0 : vm.emit) || ((_a = vm == null ? void 0 : vm.$emit) == null ? void 0 : _a.bind(vm)) || ((_c = (_b = vm == null ? void 0 : vm.proxy) == null ? void 0 : _b.$emit) == null ? void 0 : _c.bind(vm == null ? void 0 : vm.proxy));
      let event = eventName;
      if (!key) {
        {
          key = "modelValue";
        }
      }
      event = eventName || event || `update:${key.toString()}`;
      const getValue = () => isDef(props[key]) ? props[key] : defaultValue;
      if (passive) {
        const proxy = vue.ref(getValue());
        vue.watch(() => props[key], (v) => proxy.value = v);
        vue.watch(proxy, (v) => {
          if (v !== props[key] || deep)
            _emit(event, v);
        }, {
          deep
        });
        return proxy;
      } else {
        return vue.computed({
          get() {
            return getValue();
          },
          set(value) {
            _emit(event, value);
          }
        });
      }
    }
  
    function useWindowFocus({ window = defaultWindow } = {}) {
      if (!window)
        return vue.ref(false);
      const focused = vue.ref(window.document.hasFocus());
      useEventListener(window, "blur", () => {
        focused.value = false;
      });
      useEventListener(window, "focus", () => {
        focused.value = true;
      });
      return focused;
    }
  
    function useWindowSize(options = {}) {
      const {
        window = defaultWindow,
        initialWidth = Infinity,
        initialHeight = Infinity,
        listenOrientation = true
      } = options;
      const width = vue.ref(initialWidth);
      const height = vue.ref(initialHeight);
      const update = () => {
        if (window) {
          width.value = window.innerWidth;
          height.value = window.innerHeight;
        }
      };
      update();
      tryOnMounted(update);
      useEventListener("resize", update, { passive: true });
      if (listenOrientation)
        useEventListener("orientationchange", update, { passive: true });
      return { width, height };
    }
  
    const isInContainer = (el, container) => {
      if (!isClient || !el || !container)
        return false;
      const elRect = el.getBoundingClientRect();
      let containerRect;
      if (container instanceof Element) {
        containerRect = container.getBoundingClientRect();
      } else {
        containerRect = {
          top: 0,
          right: window.innerWidth,
          bottom: window.innerHeight,
          left: 0
        };
      }
      return elRect.top < containerRect.bottom && elRect.bottom > containerRect.top && elRect.right > containerRect.left && elRect.left < containerRect.right;
    };
    const getOffsetTop = (el) => {
      let offset = 0;
      let parent = el;
      while (parent) {
        offset += parent.offsetTop;
        parent = parent.offsetParent;
      }
      return offset;
    };
    const getOffsetTopDistance = (el, containerEl) => {
      return Math.abs(getOffsetTop(el) - getOffsetTop(containerEl));
    };
    const getClientXY = (event) => {
      let clientX;
      let clientY;
      if (event.type === "touchend") {
        clientY = event.changedTouches[0].clientY;
        clientX = event.changedTouches[0].clientX;
      } else if (event.type.startsWith("touch")) {
        clientY = event.touches[0].clientY;
        clientX = event.touches[0].clientX;
      } else {
        clientY = event.clientY;
        clientX = event.clientX;
      }
      return {
        clientX,
        clientY
      };
    };
  
    const NOOP = () => {
    };
    const hasOwnProperty = Object.prototype.hasOwnProperty;
    const hasOwn = (val, key) => hasOwnProperty.call(val, key);
    const isArray = Array.isArray;
    const isDate = (val) => toTypeString(val) === "[object Date]";
    const isFunction = (val) => typeof val === "function";
    const isString = (val) => typeof val === "string";
    const isObject$1 = (val) => val !== null && typeof val === "object";
    const isPromise = (val) => {
      return isObject$1(val) && isFunction(val.then) && isFunction(val.catch);
    };
    const objectToString = Object.prototype.toString;
    const toTypeString = (value) => objectToString.call(value);
    const toRawType = (value) => {
      return toTypeString(value).slice(8, -1);
    };
    const cacheStringFunction = (fn) => {
      const cache = /* @__PURE__ */ Object.create(null);
      return (str) => {
        const hit = cache[str];
        return hit || (cache[str] = fn(str));
      };
    };
    const camelizeRE = /-(\w)/g;
    const camelize = cacheStringFunction((str) => {
      return str.replace(camelizeRE, (_, c) => c ? c.toUpperCase() : "");
    });
    const hyphenateRE = /\B([A-Z])/g;
    const hyphenate = cacheStringFunction((str) => str.replace(hyphenateRE, "-$1").toLowerCase());
    const capitalize$1 = cacheStringFunction((str) => str.charAt(0).toUpperCase() + str.slice(1));
  
    const isUndefined = (val) => val === void 0;
    const isEmpty = (val) => !val && val !== 0 || isArray(val) && val.length === 0 || isObject$1(val) && !Object.keys(val).length;
    const isElement$1 = (e) => {
      if (typeof Element === "undefined")
        return false;
      return e instanceof Element;
    };
    const isPropAbsent = (prop) => {
      return isNil(prop);
    };
    const isStringNumber = (val) => {
      if (!isString(val)) {
        return false;
      }
      return !Number.isNaN(Number(val));
    };
  
    const escapeStringRegexp = (string = "") => string.replace(/[|\\{}()[\]^$+*?.]/g, "\\$&").replace(/-/g, "\\x2d");
    const capitalize = (str) => capitalize$1(str);
  
    const keysOf = (arr) => Object.keys(arr);
    const entriesOf = (arr) => Object.entries(arr);
    const getProp = (obj, path, defaultValue) => {
      return {
        get value() {
          return get(obj, path, defaultValue);
        },
        set value(val) {
          set(obj, path, val);
        }
      };
    };
  
    class ElementPlusError extends Error {
      constructor(m) {
        super(m);
        this.name = "ElementPlusError";
      }
    }
    function throwError(scope, m) {
      throw new ElementPlusError(`[${scope}] ${m}`);
    }
    function debugWarn(scope, message) {
    }
  
    const classNameToArray = (cls = "") => cls.split(" ").filter((item) => !!item.trim());
    const hasClass = (el, cls) => {
      if (!el || !cls)
        return false;
      if (cls.includes(" "))
        throw new Error("className should not contain space.");
      return el.classList.contains(cls);
    };
    const addClass = (el, cls) => {
      if (!el || !cls.trim())
        return;
      el.classList.add(...classNameToArray(cls));
    };
    const removeClass = (el, cls) => {
      if (!el || !cls.trim())
        return;
      el.classList.remove(...classNameToArray(cls));
    };
    const getStyle = (element, styleName) => {
      var _a;
      if (!isClient || !element || !styleName)
        return "";
      let key = camelize(styleName);
      if (key === "float")
        key = "cssFloat";
      try {
        const style = element.style[key];
        if (style)
          return style;
        const computed = (_a = document.defaultView) == null ? void 0 : _a.getComputedStyle(element, "");
        return computed ? computed[key] : "";
      } catch (e) {
        return element.style[key];
      }
    };
    function addUnit(value, defaultUnit = "px") {
      if (!value)
        return "";
      if (isNumber(value) || isStringNumber(value)) {
        return `${value}${defaultUnit}`;
      } else if (isString(value)) {
        return value;
      }
    }
  
    const isScroll = (el, isVertical) => {
      if (!isClient)
        return false;
      const key = {
        undefined: "overflow",
        true: "overflow-y",
        false: "overflow-x"
      }[String(isVertical)];
      const overflow = getStyle(el, key);
      return ["scroll", "auto", "overlay"].some((s) => overflow.includes(s));
    };
    const getScrollContainer = (el, isVertical) => {
      if (!isClient)
        return;
      let parent = el;
      while (parent) {
        if ([window, document, document.documentElement].includes(parent))
          return window;
        if (isScroll(parent, isVertical))
          return parent;
        parent = parent.parentNode;
      }
      return parent;
    };
    let scrollBarWidth;
    const getScrollBarWidth = (namespace) => {
      var _a;
      if (!isClient)
        return 0;
      if (scrollBarWidth !== void 0)
        return scrollBarWidth;
      const outer = document.createElement("div");
      outer.className = `${namespace}-scrollbar__wrap`;
      outer.style.visibility = "hidden";
      outer.style.width = "100px";
      outer.style.position = "absolute";
      outer.style.top = "-9999px";
      document.body.appendChild(outer);
      const widthNoScroll = outer.offsetWidth;
      outer.style.overflow = "scroll";
      const inner = document.createElement("div");
      inner.style.width = "100%";
      outer.appendChild(inner);
      const widthWithScroll = inner.offsetWidth;
      (_a = outer.parentNode) == null ? void 0 : _a.removeChild(outer);
      scrollBarWidth = widthNoScroll - widthWithScroll;
      return scrollBarWidth;
    };
    function scrollIntoView(container, selected) {
      if (!isClient)
        return;
      if (!selected) {
        container.scrollTop = 0;
        return;
      }
      const offsetParents = [];
      let pointer = selected.offsetParent;
      while (pointer !== null && container !== pointer && container.contains(pointer)) {
        offsetParents.push(pointer);
        pointer = pointer.offsetParent;
      }
      const top = selected.offsetTop + offsetParents.reduce((prev, curr) => prev + curr.offsetTop, 0);
      const bottom = top + selected.offsetHeight;
      const viewRectTop = container.scrollTop;
      const viewRectBottom = viewRectTop + container.clientHeight;
      if (top < viewRectTop) {
        container.scrollTop = top;
      } else if (bottom > viewRectBottom) {
        container.scrollTop = bottom - container.clientHeight;
      }
    }
  
    let target = !isClient ? void 0 : document.body;
    function createGlobalNode(id) {
      const el = document.createElement("div");
      if (id !== void 0) {
        el.setAttribute("id", id);
      }
      target.appendChild(el);
      return el;
    }
    function removeGlobalNode(el) {
      el.remove();
    }
  
    var export_helper_default = (sfc, props) => {
      let target = sfc.__vccOpts || sfc;
      for (let [key, val] of props)
        target[key] = val;
      return target;
    };
    var _sfc_main6 = {
      name: "ArrowDown"
    };
    var _hoisted_16$1 = {
      viewBox: "0 0 1024 1024",
      xmlns: "http://www.w3.org/2000/svg"
    };
    var _hoisted_26 = /* @__PURE__ */ vue.createElementVNode("path", {
      fill: "currentColor",
      d: "M831.872 340.864 512 652.672 192.128 340.864a30.592 30.592 0 0 0-42.752 0 29.12 29.12 0 0 0 0 41.6L489.664 714.24a32 32 0 0 0 44.672 0l340.288-331.712a29.12 29.12 0 0 0 0-41.728 30.592 30.592 0 0 0-42.752 0z"
    }, null, -1);
    var _hoisted_36 = [
      _hoisted_26
    ];
    function _sfc_render6(_ctx, _cache, $props, $setup, $data, $options) {
      return vue.openBlock(), vue.createElementBlock("svg", _hoisted_16$1, _hoisted_36);
    }
    var arrow_down_default = /* @__PURE__ */ export_helper_default(_sfc_main6, [["render", _sfc_render6], ["__file", "arrow-down.vue"]]);
    var _sfc_main8 = {
      name: "ArrowLeft"
    };
    var _hoisted_18$1 = {
      viewBox: "0 0 1024 1024",
      xmlns: "http://www.w3.org/2000/svg"
    };
    var _hoisted_28 = /* @__PURE__ */ vue.createElementVNode("path", {
      fill: "currentColor",
      d: "M609.408 149.376 277.76 489.6a32 32 0 0 0 0 44.672l331.648 340.352a29.12 29.12 0 0 0 41.728 0 30.592 30.592 0 0 0 0-42.752L339.264 511.936l311.872-319.872a30.592 30.592 0 0 0 0-42.688 29.12 29.12 0 0 0-41.728 0z"
    }, null, -1);
    var _hoisted_38 = [
      _hoisted_28
    ];
    function _sfc_render8(_ctx, _cache, $props, $setup, $data, $options) {
      return vue.openBlock(), vue.createElementBlock("svg", _hoisted_18$1, _hoisted_38);
    }
    var arrow_left_default = /* @__PURE__ */ export_helper_default(_sfc_main8, [["render", _sfc_render8], ["__file", "arrow-left.vue"]]);
    var _sfc_main10 = {
      name: "ArrowRight"
    };
    var _hoisted_110 = {
      viewBox: "0 0 1024 1024",
      xmlns: "http://www.w3.org/2000/svg"
    };
    var _hoisted_210 = /* @__PURE__ */ vue.createElementVNode("path", {
      fill: "currentColor",
      d: "M340.864 149.312a30.592 30.592 0 0 0 0 42.752L652.736 512 340.864 831.872a30.592 30.592 0 0 0 0 42.752 29.12 29.12 0 0 0 41.728 0L714.24 534.336a32 32 0 0 0 0-44.672L382.592 149.376a29.12 29.12 0 0 0-41.728 0z"
    }, null, -1);
    var _hoisted_310 = [
      _hoisted_210
    ];
    function _sfc_render10(_ctx, _cache, $props, $setup, $data, $options) {
      return vue.openBlock(), vue.createElementBlock("svg", _hoisted_110, _hoisted_310);
    }
    var arrow_right_default = /* @__PURE__ */ export_helper_default(_sfc_main10, [["render", _sfc_render10], ["__file", "arrow-right.vue"]]);
    var _sfc_main12 = {
      name: "ArrowUp"
    };
    var _hoisted_112 = {
      viewBox: "0 0 1024 1024",
      xmlns: "http://www.w3.org/2000/svg"
    };
    var _hoisted_212 = /* @__PURE__ */ vue.createElementVNode("path", {
      fill: "currentColor",
      d: "m488.832 344.32-339.84 356.672a32 32 0 0 0 0 44.16l.384.384a29.44 29.44 0 0 0 42.688 0l320-335.872 319.872 335.872a29.44 29.44 0 0 0 42.688 0l.384-.384a32 32 0 0 0 0-44.16L535.168 344.32a32 32 0 0 0-46.336 0z"
    }, null, -1);
    var _hoisted_312 = [
      _hoisted_212
    ];
    function _sfc_render12(_ctx, _cache, $props, $setup, $data, $options) {
      return vue.openBlock(), vue.createElementBlock("svg", _hoisted_112, _hoisted_312);
    }
    var arrow_up_default = /* @__PURE__ */ export_helper_default(_sfc_main12, [["render", _sfc_render12], ["__file", "arrow-up.vue"]]);
    var _sfc_main14 = {
      name: "Back"
    };
    var _hoisted_114 = {
      viewBox: "0 0 1024 1024",
      xmlns: "http://www.w3.org/2000/svg"
    };
    var _hoisted_214 = /* @__PURE__ */ vue.createElementVNode("path", {
      fill: "currentColor",
      d: "M224 480h640a32 32 0 1 1 0 64H224a32 32 0 0 1 0-64z"
    }, null, -1);
    var _hoisted_314 = /* @__PURE__ */ vue.createElementVNode("path", {
      fill: "currentColor",
      d: "m237.248 512 265.408 265.344a32 32 0 0 1-45.312 45.312l-288-288a32 32 0 0 1 0-45.312l288-288a32 32 0 1 1 45.312 45.312L237.248 512z"
    }, null, -1);
    var _hoisted_44 = [
      _hoisted_214,
      _hoisted_314
    ];
    function _sfc_render14(_ctx, _cache, $props, $setup, $data, $options) {
      return vue.openBlock(), vue.createElementBlock("svg", _hoisted_114, _hoisted_44);
    }
    var back_default = /* @__PURE__ */ export_helper_default(_sfc_main14, [["render", _sfc_render14], ["__file", "back.vue"]]);
    var _sfc_main29 = {
      name: "Calendar"
    };
    var _hoisted_129 = {
      viewBox: "0 0 1024 1024",
      xmlns: "http://www.w3.org/2000/svg"
    };
    var _hoisted_229 = /* @__PURE__ */ vue.createElementVNode("path", {
      fill: "currentColor",
      d: "M128 384v512h768V192H768v32a32 32 0 1 1-64 0v-32H320v32a32 32 0 0 1-64 0v-32H128v128h768v64H128zm192-256h384V96a32 32 0 1 1 64 0v32h160a32 32 0 0 1 32 32v768a32 32 0 0 1-32 32H96a32 32 0 0 1-32-32V160a32 32 0 0 1 32-32h160V96a32 32 0 0 1 64 0v32zm-32 384h64a32 32 0 0 1 0 64h-64a32 32 0 0 1 0-64zm0 192h64a32 32 0 1 1 0 64h-64a32 32 0 1 1 0-64zm192-192h64a32 32 0 0 1 0 64h-64a32 32 0 0 1 0-64zm0 192h64a32 32 0 1 1 0 64h-64a32 32 0 1 1 0-64zm192-192h64a32 32 0 1 1 0 64h-64a32 32 0 1 1 0-64zm0 192h64a32 32 0 1 1 0 64h-64a32 32 0 1 1 0-64z"
    }, null, -1);
    var _hoisted_328 = [
      _hoisted_229
    ];
    function _sfc_render29(_ctx, _cache, $props, $setup, $data, $options) {
      return vue.openBlock(), vue.createElementBlock("svg", _hoisted_129, _hoisted_328);
    }
    var calendar_default = /* @__PURE__ */ export_helper_default(_sfc_main29, [["render", _sfc_render29], ["__file", "calendar.vue"]]);
    var _sfc_main34 = {
      name: "CaretRight"
    };
    var _hoisted_134 = {
      viewBox: "0 0 1024 1024",
      xmlns: "http://www.w3.org/2000/svg"
    };
    var _hoisted_234 = /* @__PURE__ */ vue.createElementVNode("path", {
      fill: "currentColor",
      d: "M384 192v640l384-320.064z"
    }, null, -1);
    var _hoisted_333 = [
      _hoisted_234
    ];
    function _sfc_render34(_ctx, _cache, $props, $setup, $data, $options) {
      return vue.openBlock(), vue.createElementBlock("svg", _hoisted_134, _hoisted_333);
    }
    var caret_right_default = /* @__PURE__ */ export_helper_default(_sfc_main34, [["render", _sfc_render34], ["__file", "caret-right.vue"]]);
    var _sfc_main35 = {
      name: "CaretTop"
    };
    var _hoisted_135 = {
      viewBox: "0 0 1024 1024",
      xmlns: "http://www.w3.org/2000/svg"
    };
    var _hoisted_235 = /* @__PURE__ */ vue.createElementVNode("path", {
      fill: "currentColor",
      d: "M512 320 192 704h639.936z"
    }, null, -1);
    var _hoisted_334 = [
      _hoisted_235
    ];
    function _sfc_render35(_ctx, _cache, $props, $setup, $data, $options) {
      return vue.openBlock(), vue.createElementBlock("svg", _hoisted_135, _hoisted_334);
    }
    var caret_top_default = /* @__PURE__ */ export_helper_default(_sfc_main35, [["render", _sfc_render35], ["__file", "caret-top.vue"]]);
    var _sfc_main43 = {
      name: "Check"
    };
    var _hoisted_143 = {
      viewBox: "0 0 1024 1024",
      xmlns: "http://www.w3.org/2000/svg"
    };
    var _hoisted_243 = /* @__PURE__ */ vue.createElementVNode("path", {
      fill: "currentColor",
      d: "M406.656 706.944 195.84 496.256a32 32 0 1 0-45.248 45.248l256 256 512-512a32 32 0 0 0-45.248-45.248L406.592 706.944z"
    }, null, -1);
    var _hoisted_342 = [
      _hoisted_243
    ];
    function _sfc_render43(_ctx, _cache, $props, $setup, $data, $options) {
      return vue.openBlock(), vue.createElementBlock("svg", _hoisted_143, _hoisted_342);
    }
    var check_default = /* @__PURE__ */ export_helper_default(_sfc_main43, [["render", _sfc_render43], ["__file", "check.vue"]]);
    var _sfc_main47 = {
      name: "CircleCheckFilled"
    };
    var _hoisted_147 = {
      viewBox: "0 0 1024 1024",
      xmlns: "http://www.w3.org/2000/svg"
    };
    var _hoisted_247 = /* @__PURE__ */ vue.createElementVNode("path", {
      fill: "currentColor",
      d: "M512 64a448 448 0 1 1 0 896 448 448 0 0 1 0-896zm-55.808 536.384-99.52-99.584a38.4 38.4 0 1 0-54.336 54.336l126.72 126.72a38.272 38.272 0 0 0 54.336 0l262.4-262.464a38.4 38.4 0 1 0-54.272-54.336L456.192 600.384z"
    }, null, -1);
    var _hoisted_346 = [
      _hoisted_247
    ];
    function _sfc_render47(_ctx, _cache, $props, $setup, $data, $options) {
      return vue.openBlock(), vue.createElementBlock("svg", _hoisted_147, _hoisted_346);
    }
    var circle_check_filled_default = /* @__PURE__ */ export_helper_default(_sfc_main47, [["render", _sfc_render47], ["__file", "circle-check-filled.vue"]]);
    var _sfc_main48 = {
      name: "CircleCheck"
    };
    var _hoisted_148 = {
      viewBox: "0 0 1024 1024",
      xmlns: "http://www.w3.org/2000/svg"
    };
    var _hoisted_248 = /* @__PURE__ */ vue.createElementVNode("path", {
      fill: "currentColor",
      d: "M512 896a384 384 0 1 0 0-768 384 384 0 0 0 0 768zm0 64a448 448 0 1 1 0-896 448 448 0 0 1 0 896z"
    }, null, -1);
    var _hoisted_347 = /* @__PURE__ */ vue.createElementVNode("path", {
      fill: "currentColor",
      d: "M745.344 361.344a32 32 0 0 1 45.312 45.312l-288 288a32 32 0 0 1-45.312 0l-160-160a32 32 0 1 1 45.312-45.312L480 626.752l265.344-265.408z"
    }, null, -1);
    var _hoisted_414 = [
      _hoisted_248,
      _hoisted_347
    ];
    function _sfc_render48(_ctx, _cache, $props, $setup, $data, $options) {
      return vue.openBlock(), vue.createElementBlock("svg", _hoisted_148, _hoisted_414);
    }
    var circle_check_default = /* @__PURE__ */ export_helper_default(_sfc_main48, [["render", _sfc_render48], ["__file", "circle-check.vue"]]);
    var _sfc_main49 = {
      name: "CircleCloseFilled"
    };
    var _hoisted_149 = {
      viewBox: "0 0 1024 1024",
      xmlns: "http://www.w3.org/2000/svg"
    };
    var _hoisted_249 = /* @__PURE__ */ vue.createElementVNode("path", {
      fill: "currentColor",
      d: "M512 64a448 448 0 1 1 0 896 448 448 0 0 1 0-896zm0 393.664L407.936 353.6a38.4 38.4 0 1 0-54.336 54.336L457.664 512 353.6 616.064a38.4 38.4 0 1 0 54.336 54.336L512 566.336 616.064 670.4a38.4 38.4 0 1 0 54.336-54.336L566.336 512 670.4 407.936a38.4 38.4 0 1 0-54.336-54.336L512 457.664z"
    }, null, -1);
    var _hoisted_348 = [
      _hoisted_249
    ];
    function _sfc_render49(_ctx, _cache, $props, $setup, $data, $options) {
      return vue.openBlock(), vue.createElementBlock("svg", _hoisted_149, _hoisted_348);
    }
    var circle_close_filled_default = /* @__PURE__ */ export_helper_default(_sfc_main49, [["render", _sfc_render49], ["__file", "circle-close-filled.vue"]]);
    var _sfc_main50 = {
      name: "CircleClose"
    };
    var _hoisted_150 = {
      viewBox: "0 0 1024 1024",
      xmlns: "http://www.w3.org/2000/svg"
    };
    var _hoisted_250 = /* @__PURE__ */ vue.createElementVNode("path", {
      fill: "currentColor",
      d: "m466.752 512-90.496-90.496a32 32 0 0 1 45.248-45.248L512 466.752l90.496-90.496a32 32 0 1 1 45.248 45.248L557.248 512l90.496 90.496a32 32 0 1 1-45.248 45.248L512 557.248l-90.496 90.496a32 32 0 0 1-45.248-45.248L466.752 512z"
    }, null, -1);
    var _hoisted_349 = /* @__PURE__ */ vue.createElementVNode("path", {
      fill: "currentColor",
      d: "M512 896a384 384 0 1 0 0-768 384 384 0 0 0 0 768zm0 64a448 448 0 1 1 0-896 448 448 0 0 1 0 896z"
    }, null, -1);
    var _hoisted_415 = [
      _hoisted_250,
      _hoisted_349
    ];
    function _sfc_render50(_ctx, _cache, $props, $setup, $data, $options) {
      return vue.openBlock(), vue.createElementBlock("svg", _hoisted_150, _hoisted_415);
    }
    var circle_close_default = /* @__PURE__ */ export_helper_default(_sfc_main50, [["render", _sfc_render50], ["__file", "circle-close.vue"]]);
    var _sfc_main53 = {
      name: "Clock"
    };
    var _hoisted_153 = {
      viewBox: "0 0 1024 1024",
      xmlns: "http://www.w3.org/2000/svg"
    };
    var _hoisted_253 = /* @__PURE__ */ vue.createElementVNode("path", {
      fill: "currentColor",
      d: "M512 896a384 384 0 1 0 0-768 384 384 0 0 0 0 768zm0 64a448 448 0 1 1 0-896 448 448 0 0 1 0 896z"
    }, null, -1);
    var _hoisted_352 = /* @__PURE__ */ vue.createElementVNode("path", {
      fill: "currentColor",
      d: "M480 256a32 32 0 0 1 32 32v256a32 32 0 0 1-64 0V288a32 32 0 0 1 32-32z"
    }, null, -1);
    var _hoisted_417 = /* @__PURE__ */ vue.createElementVNode("path", {
      fill: "currentColor",
      d: "M480 512h256q32 0 32 32t-32 32H480q-32 0-32-32t32-32z"
    }, null, -1);
    var _hoisted_55 = [
      _hoisted_253,
      _hoisted_352,
      _hoisted_417
    ];
    function _sfc_render53(_ctx, _cache, $props, $setup, $data, $options) {
      return vue.openBlock(), vue.createElementBlock("svg", _hoisted_153, _hoisted_55);
    }
    var clock_default = /* @__PURE__ */ export_helper_default(_sfc_main53, [["render", _sfc_render53], ["__file", "clock.vue"]]);
    var _sfc_main55 = {
      name: "Close"
    };
    var _hoisted_155 = {
      viewBox: "0 0 1024 1024",
      xmlns: "http://www.w3.org/2000/svg"
    };
    var _hoisted_255 = /* @__PURE__ */ vue.createElementVNode("path", {
      fill: "currentColor",
      d: "M764.288 214.592 512 466.88 259.712 214.592a31.936 31.936 0 0 0-45.12 45.12L466.752 512 214.528 764.224a31.936 31.936 0 1 0 45.12 45.184L512 557.184l252.288 252.288a31.936 31.936 0 0 0 45.12-45.12L557.12 512.064l252.288-252.352a31.936 31.936 0 1 0-45.12-45.184z"
    }, null, -1);
    var _hoisted_354 = [
      _hoisted_255
    ];
    function _sfc_render55(_ctx, _cache, $props, $setup, $data, $options) {
      return vue.openBlock(), vue.createElementBlock("svg", _hoisted_155, _hoisted_354);
    }
    var close_default = /* @__PURE__ */ export_helper_default(_sfc_main55, [["render", _sfc_render55], ["__file", "close.vue"]]);
    var _sfc_main71 = {
      name: "DArrowLeft"
    };
    var _hoisted_171 = {
      viewBox: "0 0 1024 1024",
      xmlns: "http://www.w3.org/2000/svg"
    };
    var _hoisted_271 = /* @__PURE__ */ vue.createElementVNode("path", {
      fill: "currentColor",
      d: "M529.408 149.376a29.12 29.12 0 0 1 41.728 0 30.592 30.592 0 0 1 0 42.688L259.264 511.936l311.872 319.936a30.592 30.592 0 0 1-.512 43.264 29.12 29.12 0 0 1-41.216-.512L197.76 534.272a32 32 0 0 1 0-44.672l331.648-340.224zm256 0a29.12 29.12 0 0 1 41.728 0 30.592 30.592 0 0 1 0 42.688L515.264 511.936l311.872 319.936a30.592 30.592 0 0 1-.512 43.264 29.12 29.12 0 0 1-41.216-.512L453.76 534.272a32 32 0 0 1 0-44.672l331.648-340.224z"
    }, null, -1);
    var _hoisted_370 = [
      _hoisted_271
    ];
    function _sfc_render71(_ctx, _cache, $props, $setup, $data, $options) {
      return vue.openBlock(), vue.createElementBlock("svg", _hoisted_171, _hoisted_370);
    }
    var d_arrow_left_default = /* @__PURE__ */ export_helper_default(_sfc_main71, [["render", _sfc_render71], ["__file", "d-arrow-left.vue"]]);
    var _sfc_main72 = {
      name: "DArrowRight"
    };
    var _hoisted_172 = {
      viewBox: "0 0 1024 1024",
      xmlns: "http://www.w3.org/2000/svg"
    };
    var _hoisted_272 = /* @__PURE__ */ vue.createElementVNode("path", {
      fill: "currentColor",
      d: "M452.864 149.312a29.12 29.12 0 0 1 41.728.064L826.24 489.664a32 32 0 0 1 0 44.672L494.592 874.624a29.12 29.12 0 0 1-41.728 0 30.592 30.592 0 0 1 0-42.752L764.736 512 452.864 192a30.592 30.592 0 0 1 0-42.688zm-256 0a29.12 29.12 0 0 1 41.728.064L570.24 489.664a32 32 0 0 1 0 44.672L238.592 874.624a29.12 29.12 0 0 1-41.728 0 30.592 30.592 0 0 1 0-42.752L508.736 512 196.864 192a30.592 30.592 0 0 1 0-42.688z"
    }, null, -1);
    var _hoisted_371 = [
      _hoisted_272
    ];
    function _sfc_render72(_ctx, _cache, $props, $setup, $data, $options) {
      return vue.openBlock(), vue.createElementBlock("svg", _hoisted_172, _hoisted_371);
    }
    var d_arrow_right_default = /* @__PURE__ */ export_helper_default(_sfc_main72, [["render", _sfc_render72], ["__file", "d-arrow-right.vue"]]);
    var _sfc_main79 = {
      name: "Delete"
    };
    var _hoisted_179 = {
      viewBox: "0 0 1024 1024",
      xmlns: "http://www.w3.org/2000/svg"
    };
    var _hoisted_279 = /* @__PURE__ */ vue.createElementVNode("path", {
      fill: "currentColor",
      d: "M160 256H96a32 32 0 0 1 0-64h256V95.936a32 32 0 0 1 32-32h256a32 32 0 0 1 32 32V192h256a32 32 0 1 1 0 64h-64v672a32 32 0 0 1-32 32H192a32 32 0 0 1-32-32V256zm448-64v-64H416v64h192zM224 896h576V256H224v640zm192-128a32 32 0 0 1-32-32V416a32 32 0 0 1 64 0v320a32 32 0 0 1-32 32zm192 0a32 32 0 0 1-32-32V416a32 32 0 0 1 64 0v320a32 32 0 0 1-32 32z"
    }, null, -1);
    var _hoisted_378 = [
      _hoisted_279
    ];
    function _sfc_render79(_ctx, _cache, $props, $setup, $data, $options) {
      return vue.openBlock(), vue.createElementBlock("svg", _hoisted_179, _hoisted_378);
    }
    var delete_default = /* @__PURE__ */ export_helper_default(_sfc_main79, [["render", _sfc_render79], ["__file", "delete.vue"]]);
    var _sfc_main89 = {
      name: "Document"
    };
    var _hoisted_189 = {
      viewBox: "0 0 1024 1024",
      xmlns: "http://www.w3.org/2000/svg"
    };
    var _hoisted_289 = /* @__PURE__ */ vue.createElementVNode("path", {
      fill: "currentColor",
      d: "M832 384H576V128H192v768h640V384zm-26.496-64L640 154.496V320h165.504zM160 64h480l256 256v608a32 32 0 0 1-32 32H160a32 32 0 0 1-32-32V96a32 32 0 0 1 32-32zm160 448h384v64H320v-64zm0-192h160v64H320v-64zm0 384h384v64H320v-64z"
    }, null, -1);
    var _hoisted_388 = [
      _hoisted_289
    ];
    function _sfc_render89(_ctx, _cache, $props, $setup, $data, $options) {
      return vue.openBlock(), vue.createElementBlock("svg", _hoisted_189, _hoisted_388);
    }
    var document_default = /* @__PURE__ */ export_helper_default(_sfc_main89, [["render", _sfc_render89], ["__file", "document.vue"]]);
    var _sfc_main117 = {
      name: "FullScreen"
    };
    var _hoisted_1117 = {
      viewBox: "0 0 1024 1024",
      xmlns: "http://www.w3.org/2000/svg"
    };
    var _hoisted_2117 = /* @__PURE__ */ vue.createElementVNode("path", {
      fill: "currentColor",
      d: "m160 96.064 192 .192a32 32 0 0 1 0 64l-192-.192V352a32 32 0 0 1-64 0V96h64v.064zm0 831.872V928H96V672a32 32 0 1 1 64 0v191.936l192-.192a32 32 0 1 1 0 64l-192 .192zM864 96.064V96h64v256a32 32 0 1 1-64 0V160.064l-192 .192a32 32 0 1 1 0-64l192-.192zm0 831.872-192-.192a32 32 0 0 1 0-64l192 .192V672a32 32 0 1 1 64 0v256h-64v-.064z"
    }, null, -1);
    var _hoisted_3116 = [
      _hoisted_2117
    ];
    function _sfc_render117(_ctx, _cache, $props, $setup, $data, $options) {
      return vue.openBlock(), vue.createElementBlock("svg", _hoisted_1117, _hoisted_3116);
    }
    var full_screen_default = /* @__PURE__ */ export_helper_default(_sfc_main117, [["render", _sfc_render117], ["__file", "full-screen.vue"]]);
    var _sfc_main130 = {
      name: "Hide"
    };
    var _hoisted_1130 = {
      viewBox: "0 0 1024 1024",
      xmlns: "http://www.w3.org/2000/svg"
    };
    var _hoisted_2130 = /* @__PURE__ */ vue.createElementVNode("path", {
      d: "M876.8 156.8c0-9.6-3.2-16-9.6-22.4-6.4-6.4-12.8-9.6-22.4-9.6-9.6 0-16 3.2-22.4 9.6L736 220.8c-64-32-137.6-51.2-224-60.8-160 16-288 73.6-377.6 176C44.8 438.4 0 496 0 512s48 73.6 134.4 176c22.4 25.6 44.8 48 73.6 67.2l-86.4 89.6c-6.4 6.4-9.6 12.8-9.6 22.4 0 9.6 3.2 16 9.6 22.4 6.4 6.4 12.8 9.6 22.4 9.6 9.6 0 16-3.2 22.4-9.6l704-710.4c3.2-6.4 6.4-12.8 6.4-22.4Zm-646.4 528c-76.8-70.4-128-128-153.6-172.8 28.8-48 80-105.6 153.6-172.8C304 272 400 230.4 512 224c64 3.2 124.8 19.2 176 44.8l-54.4 54.4C598.4 300.8 560 288 512 288c-64 0-115.2 22.4-160 64s-64 96-64 160c0 48 12.8 89.6 35.2 124.8L256 707.2c-9.6-6.4-19.2-16-25.6-22.4Zm140.8-96c-12.8-22.4-19.2-48-19.2-76.8 0-44.8 16-83.2 48-112 32-28.8 67.2-48 112-48 28.8 0 54.4 6.4 73.6 19.2L371.2 588.8ZM889.599 336c-12.8-16-28.8-28.8-41.6-41.6l-48 48c73.6 67.2 124.8 124.8 150.4 169.6-28.8 48-80 105.6-153.6 172.8-73.6 67.2-172.8 108.8-284.8 115.2-51.2-3.2-99.2-12.8-140.8-28.8l-48 48c57.6 22.4 118.4 38.4 188.8 44.8 160-16 288-73.6 377.6-176C979.199 585.6 1024 528 1024 512s-48.001-73.6-134.401-176Z",
      fill: "currentColor"
    }, null, -1);
    var _hoisted_3129 = /* @__PURE__ */ vue.createElementVNode("path", {
      d: "M511.998 672c-12.8 0-25.6-3.2-38.4-6.4l-51.2 51.2c28.8 12.8 57.6 19.2 89.6 19.2 64 0 115.2-22.4 160-64 41.6-41.6 64-96 64-160 0-32-6.4-64-19.2-89.6l-51.2 51.2c3.2 12.8 6.4 25.6 6.4 38.4 0 44.8-16 83.2-48 112-32 28.8-67.2 48-112 48Z",
      fill: "currentColor"
    }, null, -1);
    var _hoisted_436 = [
      _hoisted_2130,
      _hoisted_3129
    ];
    function _sfc_render130(_ctx, _cache, $props, $setup, $data, $options) {
      return vue.openBlock(), vue.createElementBlock("svg", _hoisted_1130, _hoisted_436);
    }
    var hide_default = /* @__PURE__ */ export_helper_default(_sfc_main130, [["render", _sfc_render130], ["__file", "hide.vue"]]);
    var _sfc_main140 = {
      name: "InfoFilled"
    };
    var _hoisted_1140 = {
      viewBox: "0 0 1024 1024",
      xmlns: "http://www.w3.org/2000/svg"
    };
    var _hoisted_2140 = /* @__PURE__ */ vue.createElementVNode("path", {
      fill: "currentColor",
      d: "M512 64a448 448 0 1 1 0 896.064A448 448 0 0 1 512 64zm67.2 275.072c33.28 0 60.288-23.104 60.288-57.344s-27.072-57.344-60.288-57.344c-33.28 0-60.16 23.104-60.16 57.344s26.88 57.344 60.16 57.344zM590.912 699.2c0-6.848 2.368-24.64 1.024-34.752l-52.608 60.544c-10.88 11.456-24.512 19.392-30.912 17.28a12.992 12.992 0 0 1-8.256-14.72l87.68-276.992c7.168-35.136-12.544-67.2-54.336-71.296-44.096 0-108.992 44.736-148.48 101.504 0 6.784-1.28 23.68.064 33.792l52.544-60.608c10.88-11.328 23.552-19.328 29.952-17.152a12.8 12.8 0 0 1 7.808 16.128L388.48 728.576c-10.048 32.256 8.96 63.872 55.04 71.04 67.84 0 107.904-43.648 147.456-100.416z"
    }, null, -1);
    var _hoisted_3139 = [
      _hoisted_2140
    ];
    function _sfc_render140(_ctx, _cache, $props, $setup, $data, $options) {
      return vue.openBlock(), vue.createElementBlock("svg", _hoisted_1140, _hoisted_3139);
    }
    var info_filled_default = /* @__PURE__ */ export_helper_default(_sfc_main140, [["render", _sfc_render140], ["__file", "info-filled.vue"]]);
    var _sfc_main147 = {
      name: "Loading"
    };
    var _hoisted_1147 = {
      viewBox: "0 0 1024 1024",
      xmlns: "http://www.w3.org/2000/svg"
    };
    var _hoisted_2147 = /* @__PURE__ */ vue.createElementVNode("path", {
      fill: "currentColor",
      d: "M512 64a32 32 0 0 1 32 32v192a32 32 0 0 1-64 0V96a32 32 0 0 1 32-32zm0 640a32 32 0 0 1 32 32v192a32 32 0 1 1-64 0V736a32 32 0 0 1 32-32zm448-192a32 32 0 0 1-32 32H736a32 32 0 1 1 0-64h192a32 32 0 0 1 32 32zm-640 0a32 32 0 0 1-32 32H96a32 32 0 0 1 0-64h192a32 32 0 0 1 32 32zM195.2 195.2a32 32 0 0 1 45.248 0L376.32 331.008a32 32 0 0 1-45.248 45.248L195.2 240.448a32 32 0 0 1 0-45.248zm452.544 452.544a32 32 0 0 1 45.248 0L828.8 783.552a32 32 0 0 1-45.248 45.248L647.744 692.992a32 32 0 0 1 0-45.248zM828.8 195.264a32 32 0 0 1 0 45.184L692.992 376.32a32 32 0 0 1-45.248-45.248l135.808-135.808a32 32 0 0 1 45.248 0zm-452.544 452.48a32 32 0 0 1 0 45.248L240.448 828.8a32 32 0 0 1-45.248-45.248l135.808-135.808a32 32 0 0 1 45.248 0z"
    }, null, -1);
    var _hoisted_3146 = [
      _hoisted_2147
    ];
    function _sfc_render147(_ctx, _cache, $props, $setup, $data, $options) {
      return vue.openBlock(), vue.createElementBlock("svg", _hoisted_1147, _hoisted_3146);
    }
    var loading_default = /* @__PURE__ */ export_helper_default(_sfc_main147, [["render", _sfc_render147], ["__file", "loading.vue"]]);
    var _sfc_main165 = {
      name: "Minus"
    };
    var _hoisted_1165 = {
      viewBox: "0 0 1024 1024",
      xmlns: "http://www.w3.org/2000/svg"
    };
    var _hoisted_2165 = /* @__PURE__ */ vue.createElementVNode("path", {
      fill: "currentColor",
      d: "M128 544h768a32 32 0 1 0 0-64H128a32 32 0 0 0 0 64z"
    }, null, -1);
    var _hoisted_3164 = [
      _hoisted_2165
    ];
    function _sfc_render165(_ctx, _cache, $props, $setup, $data, $options) {
      return vue.openBlock(), vue.createElementBlock("svg", _hoisted_1165, _hoisted_3164);
    }
    var minus_default = /* @__PURE__ */ export_helper_default(_sfc_main165, [["render", _sfc_render165], ["__file", "minus.vue"]]);
    var _sfc_main170 = {
      name: "MoreFilled"
    };
    var _hoisted_1170 = {
      viewBox: "0 0 1024 1024",
      xmlns: "http://www.w3.org/2000/svg"
    };
    var _hoisted_2170 = /* @__PURE__ */ vue.createElementVNode("path", {
      fill: "currentColor",
      d: "M176 416a112 112 0 1 1 0 224 112 112 0 0 1 0-224zm336 0a112 112 0 1 1 0 224 112 112 0 0 1 0-224zm336 0a112 112 0 1 1 0 224 112 112 0 0 1 0-224z"
    }, null, -1);
    var _hoisted_3169 = [
      _hoisted_2170
    ];
    function _sfc_render170(_ctx, _cache, $props, $setup, $data, $options) {
      return vue.openBlock(), vue.createElementBlock("svg", _hoisted_1170, _hoisted_3169);
    }
    var more_filled_default = /* @__PURE__ */ export_helper_default(_sfc_main170, [["render", _sfc_render170], ["__file", "more-filled.vue"]]);
    var _sfc_main171 = {
      name: "More"
    };
    var _hoisted_1171 = {
      viewBox: "0 0 1024 1024",
      xmlns: "http://www.w3.org/2000/svg"
    };
    var _hoisted_2171 = /* @__PURE__ */ vue.createElementVNode("path", {
      fill: "currentColor",
      d: "M176 416a112 112 0 1 0 0 224 112 112 0 0 0 0-224m0 64a48 48 0 1 1 0 96 48 48 0 0 1 0-96zm336-64a112 112 0 1 1 0 224 112 112 0 0 1 0-224zm0 64a48 48 0 1 0 0 96 48 48 0 0 0 0-96zm336-64a112 112 0 1 1 0 224 112 112 0 0 1 0-224zm0 64a48 48 0 1 0 0 96 48 48 0 0 0 0-96z"
    }, null, -1);
    var _hoisted_3170 = [
      _hoisted_2171
    ];
    function _sfc_render171(_ctx, _cache, $props, $setup, $data, $options) {
      return vue.openBlock(), vue.createElementBlock("svg", _hoisted_1171, _hoisted_3170);
    }
    var more_default = /* @__PURE__ */ export_helper_default(_sfc_main171, [["render", _sfc_render171], ["__file", "more.vue"]]);
    var _sfc_main191 = {
      name: "PictureFilled"
    };
    var _hoisted_1191 = {
      viewBox: "0 0 1024 1024",
      xmlns: "http://www.w3.org/2000/svg"
    };
    var _hoisted_2191 = /* @__PURE__ */ vue.createElementVNode("path", {
      fill: "currentColor",
      d: "M96 896a32 32 0 0 1-32-32V160a32 32 0 0 1 32-32h832a32 32 0 0 1 32 32v704a32 32 0 0 1-32 32H96zm315.52-228.48-68.928-68.928a32 32 0 0 0-45.248 0L128 768.064h778.688l-242.112-290.56a32 32 0 0 0-49.216 0L458.752 665.408a32 32 0 0 1-47.232 2.112zM256 384a96 96 0 1 0 192.064-.064A96 96 0 0 0 256 384z"
    }, null, -1);
    var _hoisted_3190 = [
      _hoisted_2191
    ];
    function _sfc_render191(_ctx, _cache, $props, $setup, $data, $options) {
      return vue.openBlock(), vue.createElementBlock("svg", _hoisted_1191, _hoisted_3190);
    }
    var picture_filled_default = /* @__PURE__ */ export_helper_default(_sfc_main191, [["render", _sfc_render191], ["__file", "picture-filled.vue"]]);
    var _sfc_main197 = {
      name: "Plus"
    };
    var _hoisted_1197 = {
      viewBox: "0 0 1024 1024",
      xmlns: "http://www.w3.org/2000/svg"
    };
    var _hoisted_2197 = /* @__PURE__ */ vue.createElementVNode("path", {
      fill: "currentColor",
      d: "M480 480V128a32 32 0 0 1 64 0v352h352a32 32 0 1 1 0 64H544v352a32 32 0 1 1-64 0V544H128a32 32 0 0 1 0-64h352z"
    }, null, -1);
    var _hoisted_3196 = [
      _hoisted_2197
    ];
    function _sfc_render197(_ctx, _cache, $props, $setup, $data, $options) {
      return vue.openBlock(), vue.createElementBlock("svg", _hoisted_1197, _hoisted_3196);
    }
    var plus_default = /* @__PURE__ */ export_helper_default(_sfc_main197, [["render", _sfc_render197], ["__file", "plus.vue"]]);
    var _sfc_main206 = {
      name: "QuestionFilled"
    };
    var _hoisted_1206 = {
      viewBox: "0 0 1024 1024",
      xmlns: "http://www.w3.org/2000/svg"
    };
    var _hoisted_2206 = /* @__PURE__ */ vue.createElementVNode("path", {
      fill: "currentColor",
      d: "M512 64a448 448 0 1 1 0 896 448 448 0 0 1 0-896zm23.744 191.488c-52.096 0-92.928 14.784-123.2 44.352-30.976 29.568-45.76 70.4-45.76 122.496h80.256c0-29.568 5.632-52.8 17.6-68.992 13.376-19.712 35.2-28.864 66.176-28.864 23.936 0 42.944 6.336 56.32 19.712 12.672 13.376 19.712 31.68 19.712 54.912 0 17.6-6.336 34.496-19.008 49.984l-8.448 9.856c-45.76 40.832-73.216 70.4-82.368 89.408-9.856 19.008-14.08 42.24-14.08 68.992v9.856h80.96v-9.856c0-16.896 3.52-31.68 10.56-45.76 6.336-12.672 15.488-24.64 28.16-35.2 33.792-29.568 54.208-48.576 60.544-55.616 16.896-22.528 26.048-51.392 26.048-86.592 0-42.944-14.08-76.736-42.24-101.376-28.16-25.344-65.472-37.312-111.232-37.312zm-12.672 406.208a54.272 54.272 0 0 0-38.72 14.784 49.408 49.408 0 0 0-15.488 38.016c0 15.488 4.928 28.16 15.488 38.016A54.848 54.848 0 0 0 523.072 768c15.488 0 28.16-4.928 38.72-14.784a51.52 51.52 0 0 0 16.192-38.72 51.968 51.968 0 0 0-15.488-38.016 55.936 55.936 0 0 0-39.424-14.784z"
    }, null, -1);
    var _hoisted_3205 = [
      _hoisted_2206
    ];
    function _sfc_render206(_ctx, _cache, $props, $setup, $data, $options) {
      return vue.openBlock(), vue.createElementBlock("svg", _hoisted_1206, _hoisted_3205);
    }
    var question_filled_default = /* @__PURE__ */ export_helper_default(_sfc_main206, [["render", _sfc_render206], ["__file", "question-filled.vue"]]);
    var _sfc_main210 = {
      name: "RefreshLeft"
    };
    var _hoisted_1210 = {
      viewBox: "0 0 1024 1024",
      xmlns: "http://www.w3.org/2000/svg"
    };
    var _hoisted_2210 = /* @__PURE__ */ vue.createElementVNode("path", {
      fill: "currentColor",
      d: "M289.088 296.704h92.992a32 32 0 0 1 0 64H232.96a32 32 0 0 1-32-32V179.712a32 32 0 0 1 64 0v50.56a384 384 0 0 1 643.84 282.88 384 384 0 0 1-383.936 384 384 384 0 0 1-384-384h64a320 320 0 1 0 640 0 320 320 0 0 0-555.712-216.448z"
    }, null, -1);
    var _hoisted_3209 = [
      _hoisted_2210
    ];
    function _sfc_render210(_ctx, _cache, $props, $setup, $data, $options) {
      return vue.openBlock(), vue.createElementBlock("svg", _hoisted_1210, _hoisted_3209);
    }
    var refresh_left_default = /* @__PURE__ */ export_helper_default(_sfc_main210, [["render", _sfc_render210], ["__file", "refresh-left.vue"]]);
    var _sfc_main211 = {
      name: "RefreshRight"
    };
    var _hoisted_1211 = {
      viewBox: "0 0 1024 1024",
      xmlns: "http://www.w3.org/2000/svg"
    };
    var _hoisted_2211 = /* @__PURE__ */ vue.createElementVNode("path", {
      fill: "currentColor",
      d: "M784.512 230.272v-50.56a32 32 0 1 1 64 0v149.056a32 32 0 0 1-32 32H667.52a32 32 0 1 1 0-64h92.992A320 320 0 1 0 524.8 833.152a320 320 0 0 0 320-320h64a384 384 0 0 1-384 384 384 384 0 0 1-384-384 384 384 0 0 1 643.712-282.88z"
    }, null, -1);
    var _hoisted_3210 = [
      _hoisted_2211
    ];
    function _sfc_render211(_ctx, _cache, $props, $setup, $data, $options) {
      return vue.openBlock(), vue.createElementBlock("svg", _hoisted_1211, _hoisted_3210);
    }
    var refresh_right_default = /* @__PURE__ */ export_helper_default(_sfc_main211, [["render", _sfc_render211], ["__file", "refresh-right.vue"]]);
    var _sfc_main217 = {
      name: "ScaleToOriginal"
    };
    var _hoisted_1217 = {
      viewBox: "0 0 1024 1024",
      xmlns: "http://www.w3.org/2000/svg"
    };
    var _hoisted_2217 = /* @__PURE__ */ vue.createElementVNode("path", {
      fill: "currentColor",
      d: "M813.176 180.706a60.235 60.235 0 0 1 60.236 60.235v481.883a60.235 60.235 0 0 1-60.236 60.235H210.824a60.235 60.235 0 0 1-60.236-60.235V240.94a60.235 60.235 0 0 1 60.236-60.235h602.352zm0-60.235H210.824A120.47 120.47 0 0 0 90.353 240.94v481.883a120.47 120.47 0 0 0 120.47 120.47h602.353a120.47 120.47 0 0 0 120.471-120.47V240.94a120.47 120.47 0 0 0-120.47-120.47zm-120.47 180.705a30.118 30.118 0 0 0-30.118 30.118v301.177a30.118 30.118 0 0 0 60.236 0V331.294a30.118 30.118 0 0 0-30.118-30.118zm-361.412 0a30.118 30.118 0 0 0-30.118 30.118v301.177a30.118 30.118 0 1 0 60.236 0V331.294a30.118 30.118 0 0 0-30.118-30.118zM512 361.412a30.118 30.118 0 0 0-30.118 30.117v30.118a30.118 30.118 0 0 0 60.236 0V391.53A30.118 30.118 0 0 0 512 361.412zM512 512a30.118 30.118 0 0 0-30.118 30.118v30.117a30.118 30.118 0 0 0 60.236 0v-30.117A30.118 30.118 0 0 0 512 512z"
    }, null, -1);
    var _hoisted_3216 = [
      _hoisted_2217
    ];
    function _sfc_render217(_ctx, _cache, $props, $setup, $data, $options) {
      return vue.openBlock(), vue.createElementBlock("svg", _hoisted_1217, _hoisted_3216);
    }
    var scale_to_original_default = /* @__PURE__ */ export_helper_default(_sfc_main217, [["render", _sfc_render217], ["__file", "scale-to-original.vue"]]);
    var _sfc_main220 = {
      name: "Search"
    };
    var _hoisted_1220 = {
      viewBox: "0 0 1024 1024",
      xmlns: "http://www.w3.org/2000/svg"
    };
    var _hoisted_2220 = /* @__PURE__ */ vue.createElementVNode("path", {
      fill: "currentColor",
      d: "m795.904 750.72 124.992 124.928a32 32 0 0 1-45.248 45.248L750.656 795.904a416 416 0 1 1 45.248-45.248zM480 832a352 352 0 1 0 0-704 352 352 0 0 0 0 704z"
    }, null, -1);
    var _hoisted_3219 = [
      _hoisted_2220
    ];
    function _sfc_render220(_ctx, _cache, $props, $setup, $data, $options) {
      return vue.openBlock(), vue.createElementBlock("svg", _hoisted_1220, _hoisted_3219);
    }
    var search_default = /* @__PURE__ */ export_helper_default(_sfc_main220, [["render", _sfc_render220], ["__file", "search.vue"]]);
    var _sfc_main236 = {
      name: "SortDown"
    };
    var _hoisted_1236 = {
      viewBox: "0 0 1024 1024",
      xmlns: "http://www.w3.org/2000/svg"
    };
    var _hoisted_2236 = /* @__PURE__ */ vue.createElementVNode("path", {
      fill: "currentColor",
      d: "M576 96v709.568L333.312 562.816A32 32 0 1 0 288 608l297.408 297.344A32 32 0 0 0 640 882.688V96a32 32 0 0 0-64 0z"
    }, null, -1);
    var _hoisted_3235 = [
      _hoisted_2236
    ];
    function _sfc_render236(_ctx, _cache, $props, $setup, $data, $options) {
      return vue.openBlock(), vue.createElementBlock("svg", _hoisted_1236, _hoisted_3235);
    }
    var sort_down_default = /* @__PURE__ */ export_helper_default(_sfc_main236, [["render", _sfc_render236], ["__file", "sort-down.vue"]]);
    var _sfc_main237 = {
      name: "SortUp"
    };
    var _hoisted_1237 = {
      viewBox: "0 0 1024 1024",
      xmlns: "http://www.w3.org/2000/svg"
    };
    var _hoisted_2237 = /* @__PURE__ */ vue.createElementVNode("path", {
      fill: "currentColor",
      d: "M384 141.248V928a32 32 0 1 0 64 0V218.56l242.688 242.688A32 32 0 1 0 736 416L438.592 118.656A32 32 0 0 0 384 141.248z"
    }, null, -1);
    var _hoisted_3236 = [
      _hoisted_2237
    ];
    function _sfc_render237(_ctx, _cache, $props, $setup, $data, $options) {
      return vue.openBlock(), vue.createElementBlock("svg", _hoisted_1237, _hoisted_3236);
    }
    var sort_up_default = /* @__PURE__ */ export_helper_default(_sfc_main237, [["render", _sfc_render237], ["__file", "sort-up.vue"]]);
    var _sfc_main240 = {
      name: "StarFilled"
    };
    var _hoisted_1240 = {
      viewBox: "0 0 1024 1024",
      xmlns: "http://www.w3.org/2000/svg"
    };
    var _hoisted_2240 = /* @__PURE__ */ vue.createElementVNode("path", {
      fill: "currentColor",
      d: "M283.84 867.84 512 747.776l228.16 119.936a6.4 6.4 0 0 0 9.28-6.72l-43.52-254.08 184.512-179.904a6.4 6.4 0 0 0-3.52-10.88l-255.104-37.12L517.76 147.904a6.4 6.4 0 0 0-11.52 0L392.192 379.072l-255.104 37.12a6.4 6.4 0 0 0-3.52 10.88L318.08 606.976l-43.584 254.08a6.4 6.4 0 0 0 9.28 6.72z"
    }, null, -1);
    var _hoisted_3239 = [
      _hoisted_2240
    ];
    function _sfc_render240(_ctx, _cache, $props, $setup, $data, $options) {
      return vue.openBlock(), vue.createElementBlock("svg", _hoisted_1240, _hoisted_3239);
    }
    var star_filled_default = /* @__PURE__ */ export_helper_default(_sfc_main240, [["render", _sfc_render240], ["__file", "star-filled.vue"]]);
    var _sfc_main241 = {
      name: "Star"
    };
    var _hoisted_1241 = {
      viewBox: "0 0 1024 1024",
      xmlns: "http://www.w3.org/2000/svg"
    };
    var _hoisted_2241 = /* @__PURE__ */ vue.createElementVNode("path", {
      fill: "currentColor",
      d: "m512 747.84 228.16 119.936a6.4 6.4 0 0 0 9.28-6.72l-43.52-254.08 184.512-179.904a6.4 6.4 0 0 0-3.52-10.88l-255.104-37.12L517.76 147.904a6.4 6.4 0 0 0-11.52 0L392.192 379.072l-255.104 37.12a6.4 6.4 0 0 0-3.52 10.88L318.08 606.976l-43.584 254.08a6.4 6.4 0 0 0 9.28 6.72L512 747.84zM313.6 924.48a70.4 70.4 0 0 1-102.144-74.24l37.888-220.928L88.96 472.96A70.4 70.4 0 0 1 128 352.896l221.76-32.256 99.2-200.96a70.4 70.4 0 0 1 126.208 0l99.2 200.96 221.824 32.256a70.4 70.4 0 0 1 39.04 120.064L774.72 629.376l37.888 220.928a70.4 70.4 0 0 1-102.144 74.24L512 820.096l-198.4 104.32z"
    }, null, -1);
    var _hoisted_3240 = [
      _hoisted_2241
    ];
    function _sfc_render241(_ctx, _cache, $props, $setup, $data, $options) {
      return vue.openBlock(), vue.createElementBlock("svg", _hoisted_1241, _hoisted_3240);
    }
    var star_default = /* @__PURE__ */ export_helper_default(_sfc_main241, [["render", _sfc_render241], ["__file", "star.vue"]]);
    var _sfc_main243 = {
      name: "SuccessFilled"
    };
    var _hoisted_1243 = {
      viewBox: "0 0 1024 1024",
      xmlns: "http://www.w3.org/2000/svg"
    };
    var _hoisted_2243 = /* @__PURE__ */ vue.createElementVNode("path", {
      fill: "currentColor",
      d: "M512 64a448 448 0 1 1 0 896 448 448 0 0 1 0-896zm-55.808 536.384-99.52-99.584a38.4 38.4 0 1 0-54.336 54.336l126.72 126.72a38.272 38.272 0 0 0 54.336 0l262.4-262.464a38.4 38.4 0 1 0-54.272-54.336L456.192 600.384z"
    }, null, -1);
    var _hoisted_3242 = [
      _hoisted_2243
    ];
    function _sfc_render243(_ctx, _cache, $props, $setup, $data, $options) {
      return vue.openBlock(), vue.createElementBlock("svg", _hoisted_1243, _hoisted_3242);
    }
    var success_filled_default = /* @__PURE__ */ export_helper_default(_sfc_main243, [["render", _sfc_render243], ["__file", "success-filled.vue"]]);
    var _sfc_main274 = {
      name: "View"
    };
    var _hoisted_1274 = {
      viewBox: "0 0 1024 1024",
      xmlns: "http://www.w3.org/2000/svg"
    };
    var _hoisted_2274 = /* @__PURE__ */ vue.createElementVNode("path", {
      fill: "currentColor",
      d: "M512 160c320 0 512 352 512 352S832 864 512 864 0 512 0 512s192-352 512-352zm0 64c-225.28 0-384.128 208.064-436.8 288 52.608 79.872 211.456 288 436.8 288 225.28 0 384.128-208.064 436.8-288-52.608-79.872-211.456-288-436.8-288zm0 64a224 224 0 1 1 0 448 224 224 0 0 1 0-448zm0 64a160.192 160.192 0 0 0-160 160c0 88.192 71.744 160 160 160s160-71.808 160-160-71.744-160-160-160z"
    }, null, -1);
    var _hoisted_3273 = [
      _hoisted_2274
    ];
    function _sfc_render274(_ctx, _cache, $props, $setup, $data, $options) {
      return vue.openBlock(), vue.createElementBlock("svg", _hoisted_1274, _hoisted_3273);
    }
    var view_default = /* @__PURE__ */ export_helper_default(_sfc_main274, [["render", _sfc_render274], ["__file", "view.vue"]]);
    var _sfc_main277 = {
      name: "WarningFilled"
    };
    var _hoisted_1277 = {
      viewBox: "0 0 1024 1024",
      xmlns: "http://www.w3.org/2000/svg"
    };
    var _hoisted_2277 = /* @__PURE__ */ vue.createElementVNode("path", {
      fill: "currentColor",
      d: "M512 64a448 448 0 1 1 0 896 448 448 0 0 1 0-896zm0 192a58.432 58.432 0 0 0-58.24 63.744l23.36 256.384a35.072 35.072 0 0 0 69.76 0l23.296-256.384A58.432 58.432 0 0 0 512 256zm0 512a51.2 51.2 0 1 0 0-102.4 51.2 51.2 0 0 0 0 102.4z"
    }, null, -1);
    var _hoisted_3276 = [
      _hoisted_2277
    ];
    function _sfc_render277(_ctx, _cache, $props, $setup, $data, $options) {
      return vue.openBlock(), vue.createElementBlock("svg", _hoisted_1277, _hoisted_3276);
    }
    var warning_filled_default = /* @__PURE__ */ export_helper_default(_sfc_main277, [["render", _sfc_render277], ["__file", "warning-filled.vue"]]);
    var _sfc_main282 = {
      name: "ZoomIn"
    };
    var _hoisted_1282 = {
      viewBox: "0 0 1024 1024",
      xmlns: "http://www.w3.org/2000/svg"
    };
    var _hoisted_2282 = /* @__PURE__ */ vue.createElementVNode("path", {
      fill: "currentColor",
      d: "m795.904 750.72 124.992 124.928a32 32 0 0 1-45.248 45.248L750.656 795.904a416 416 0 1 1 45.248-45.248zM480 832a352 352 0 1 0 0-704 352 352 0 0 0 0 704zm-32-384v-96a32 32 0 0 1 64 0v96h96a32 32 0 0 1 0 64h-96v96a32 32 0 0 1-64 0v-96h-96a32 32 0 0 1 0-64h96z"
    }, null, -1);
    var _hoisted_3281 = [
      _hoisted_2282
    ];
    function _sfc_render282(_ctx, _cache, $props, $setup, $data, $options) {
      return vue.openBlock(), vue.createElementBlock("svg", _hoisted_1282, _hoisted_3281);
    }
    var zoom_in_default = /* @__PURE__ */ export_helper_default(_sfc_main282, [["render", _sfc_render282], ["__file", "zoom-in.vue"]]);
    var _sfc_main283 = {
      name: "ZoomOut"
    };
    var _hoisted_1283 = {
      viewBox: "0 0 1024 1024",
      xmlns: "http://www.w3.org/2000/svg"
    };
    var _hoisted_2283 = /* @__PURE__ */ vue.createElementVNode("path", {
      fill: "currentColor",
      d: "m795.904 750.72 124.992 124.928a32 32 0 0 1-45.248 45.248L750.656 795.904a416 416 0 1 1 45.248-45.248zM480 832a352 352 0 1 0 0-704 352 352 0 0 0 0 704zM352 448h256a32 32 0 0 1 0 64H352a32 32 0 0 1 0-64z"
    }, null, -1);
    var _hoisted_3282 = [
      _hoisted_2283
    ];
    function _sfc_render283(_ctx, _cache, $props, $setup, $data, $options) {
      return vue.openBlock(), vue.createElementBlock("svg", _hoisted_1283, _hoisted_3282);
    }
    var zoom_out_default = /* @__PURE__ */ export_helper_default(_sfc_main283, [["render", _sfc_render283], ["__file", "zoom-out.vue"]]);
    /*! Element Plus Icons Vue v2.0.6 */
  
    const epPropKey = "__epPropKey";
    const definePropType = (val) => val;
    const isEpProp = (val) => isObject$1(val) && !!val[epPropKey];
    const buildProp = (prop, key) => {
      if (!isObject$1(prop) || isEpProp(prop))
        return prop;
      const { values, required, default: defaultValue, type, validator } = prop;
      const _validator = values || validator ? (val) => {
        let valid = false;
        let allowedValues = [];
        if (values) {
          allowedValues = Array.from(values);
          if (hasOwn(prop, "default")) {
            allowedValues.push(defaultValue);
          }
          valid || (valid = allowedValues.includes(val));
        }
        if (validator)
          valid || (valid = validator(val));
        if (!valid && allowedValues.length > 0) {
          const allowValuesText = [...new Set(allowedValues)].map((value) => JSON.stringify(value)).join(", ");
          vue.warn(`Invalid prop: validation failed${key ? ` for prop "${key}"` : ""}. Expected one of [${allowValuesText}], got value ${JSON.stringify(val)}.`);
        }
        return valid;
      } : void 0;
      const epProp = {
        type,
        required: !!required,
        validator: _validator,
        [epPropKey]: true
      };
      if (hasOwn(prop, "default"))
        epProp.default = defaultValue;
      return epProp;
    };
    const buildProps = (props) => fromPairs(Object.entries(props).map(([key, option]) => [
      key,
      buildProp(option, key)
    ]));
  
    const iconPropType = definePropType([
      String,
      Object,
      Function
    ]);
    const CloseComponents = {
      Close: close_default
    };
    const TypeComponents = {
      Close: close_default,
      SuccessFilled: success_filled_default,
      InfoFilled: info_filled_default,
      WarningFilled: warning_filled_default,
      CircleCloseFilled: circle_close_filled_default
    };
    const TypeComponentsMap = {
      success: success_filled_default,
      warning: warning_filled_default,
      error: circle_close_filled_default,
      info: info_filled_default
    };
    const ValidateComponentsMap = {
      validating: loading_default,
      success: circle_check_default,
      error: circle_close_default
    };
  
    const withInstall = (main, extra) => {
      main.install = (app) => {
        for (const comp of [main, ...Object.values(extra != null ? extra : {})]) {
          app.component(comp.name, comp);
        }
      };
      if (extra) {
        for (const [key, comp] of Object.entries(extra)) {
          main[key] = comp;
        }
      }
      return main;
    };
    const withInstallFunction = (fn, name) => {
      fn.install = (app) => {
        fn._context = app._context;
        app.config.globalProperties[name] = fn;
      };
      return fn;
    };
    const withInstallDirective = (directive, name) => {
      directive.install = (app) => {
        app.directive(name, directive);
      };
      return directive;
    };
    const withNoopInstall = (component) => {
      component.install = NOOP;
      return component;
    };
  
    const composeRefs = (...refs) => {
      return (el) => {
        refs.forEach((ref) => {
          if (isFunction(ref)) {
            ref(el);
          } else {
            ref.value = el;
          }
        });
      };
    };
  
    const EVENT_CODE = {
      tab: "Tab",
      enter: "Enter",
      space: "Space",
      left: "ArrowLeft",
      up: "ArrowUp",
      right: "ArrowRight",
      down: "ArrowDown",
      esc: "Escape",
      delete: "Delete",
      backspace: "Backspace",
      numpadEnter: "NumpadEnter",
      pageUp: "PageUp",
      pageDown: "PageDown",
      home: "Home",
      end: "End"
    };
  
    const datePickTypes = [
      "year",
      "month",
      "date",
      "dates",
      "week",
      "datetime",
      "datetimerange",
      "daterange",
      "monthrange"
    ];
    const WEEK_DAYS = [
      "sun",
      "mon",
      "tue",
      "wed",
      "thu",
      "fri",
      "sat"
    ];
  
    const UPDATE_MODEL_EVENT = "update:modelValue";
    const CHANGE_EVENT = "change";
    const INPUT_EVENT = "input";
  
    const INSTALLED_KEY = Symbol("INSTALLED_KEY");
  
    const componentSizes = ["", "default", "small", "large"];
    const componentSizeMap = {
      large: 40,
      default: 32,
      small: 24
    };
  
    const getComponentSize = (size) => {
      return componentSizeMap[size || "default"];
    };
  
    const isValidComponentSize = (val) => ["", ...componentSizes].includes(val);
  
    var PatchFlags = /* @__PURE__ */ ((PatchFlags2) => {
      PatchFlags2[PatchFlags2["TEXT"] = 1] = "TEXT";
      PatchFlags2[PatchFlags2["CLASS"] = 2] = "CLASS";
      PatchFlags2[PatchFlags2["STYLE"] = 4] = "STYLE";
      PatchFlags2[PatchFlags2["PROPS"] = 8] = "PROPS";
      PatchFlags2[PatchFlags2["FULL_PROPS"] = 16] = "FULL_PROPS";
      PatchFlags2[PatchFlags2["HYDRATE_EVENTS"] = 32] = "HYDRATE_EVENTS";
      PatchFlags2[PatchFlags2["STABLE_FRAGMENT"] = 64] = "STABLE_FRAGMENT";
      PatchFlags2[PatchFlags2["KEYED_FRAGMENT"] = 128] = "KEYED_FRAGMENT";
      PatchFlags2[PatchFlags2["UNKEYED_FRAGMENT"] = 256] = "UNKEYED_FRAGMENT";
      PatchFlags2[PatchFlags2["NEED_PATCH"] = 512] = "NEED_PATCH";
      PatchFlags2[PatchFlags2["DYNAMIC_SLOTS"] = 1024] = "DYNAMIC_SLOTS";
      PatchFlags2[PatchFlags2["HOISTED"] = -1] = "HOISTED";
      PatchFlags2[PatchFlags2["BAIL"] = -2] = "BAIL";
      return PatchFlags2;
    })(PatchFlags || {});
    function isFragment(node) {
      return vue.isVNode(node) && node.type === vue.Fragment;
    }
    function isComment(node) {
      return vue.isVNode(node) && node.type === vue.Comment;
    }
    function isValidElementNode(node) {
      return vue.isVNode(node) && !isFragment(node) && !isComment(node);
    }
    const getNormalizedProps = (node) => {
      if (!vue.isVNode(node)) {
        return {};
      }
      const raw = node.props || {};
      const type = (vue.isVNode(node.type) ? node.type.props : void 0) || {};
      const props = {};
      Object.keys(type).forEach((key) => {
        if (hasOwn(type[key], "default")) {
          props[key] = type[key].default;
        }
      });
      Object.keys(raw).forEach((key) => {
        props[camelize(key)] = raw[key];
      });
      return props;
    };
    const ensureOnlyChild = (children) => {
      if (!isArray(children) || children.length > 1) {
        throw new Error("expect to receive a single Vue element child");
      }
      return children[0];
    };
    const flattedChildren = (children) => {
      const vNodes = isArray(children) ? children : [children];
      const result = [];
      vNodes.forEach((child) => {
        var _a;
        if (isArray(child)) {
          result.push(...flattedChildren(child));
        } else if (vue.isVNode(child) && isArray(child.children)) {
          result.push(...flattedChildren(child.children));
        } else {
          result.push(child);
          if (vue.isVNode(child) && ((_a = child.component) == null ? void 0 : _a.subTree)) {
            result.push(...flattedChildren(child.component.subTree));
          }
        }
      });
      return result;
    };
  
    const cubic = (value) => {
      return value ** 3;
    };
    const easeInOutCubic = (value) => value < 0.5 ? cubic(value * 2) / 2 : 1 - cubic((1 - value) * 2) / 2;
  
    const unique = (arr) => [...new Set(arr)];
    const castArray = (arr) => {
      if (!arr && arr !== 0)
        return [];
      return Array.isArray(arr) ? arr : [arr];
    };
  
    const isFirefox = () => isClient && /firefox/i.test(window.navigator.userAgent);
  
    const isKorean = (text) => /([(\uAC00-\uD7AF)|(\u3130-\u318F)])+/gi.test(text);
  
    const rAF = (fn) => isClient ? window.requestAnimationFrame(fn) : setTimeout(fn, 16);
    const cAF = (handle) => isClient ? window.cancelAnimationFrame(handle) : clearTimeout(handle);
  
    const generateId = () => Math.floor(Math.random() * 1e4);
  
    const mutable = (val) => val;
  
    const DEFAULT_EXCLUDE_KEYS = ["class", "style"];
    const LISTENER_PREFIX = /^on[A-Z]/;
    const useAttrs = (params = {}) => {
      const { excludeListeners = false, excludeKeys } = params;
      const allExcludeKeys = vue.computed(() => {
        return ((excludeKeys == null ? void 0 : excludeKeys.value) || []).concat(DEFAULT_EXCLUDE_KEYS);
      });
      const instance = vue.getCurrentInstance();
      if (!instance) {
        return vue.computed(() => ({}));
      }
      return vue.computed(() => {
        var _a;
        return fromPairs(Object.entries((_a = instance.proxy) == null ? void 0 : _a.$attrs).filter(([key]) => !allExcludeKeys.value.includes(key) && !(excludeListeners && LISTENER_PREFIX.test(key))));
      });
    };
  
    const breadcrumbKey = Symbol("breadcrumbKey");
  
    const buttonGroupContextKey = Symbol("buttonGroupContextKey");
  
    const carouselContextKey = Symbol("carouselContextKey");
  
    const checkboxGroupContextKey = Symbol("checkboxGroupContextKey");
  
    const collapseContextKey = Symbol("collapseContextKey");
  
    const configProviderContextKey = Symbol();
  
    const dialogInjectionKey = Symbol("dialogInjectionKey");
  
    const formContextKey = Symbol("formContextKey");
    const formItemContextKey = Symbol("formItemContextKey");
  
    const elPaginationKey = Symbol("elPaginationKey");
  
    const radioGroupKey = Symbol("radioGroupKey");
  
    const rowContextKey = Symbol("rowContextKey");
  
    const scrollbarContextKey = Symbol("scrollbarContextKey");
  
    const sliderContextKey = Symbol("sliderContextKey");
  
    const tabsRootContextKey = Symbol("tabsRootContextKey");
  
    const uploadContextKey = Symbol("uploadContextKey");
  
    const POPPER_INJECTION_KEY = Symbol("popper");
    const POPPER_CONTENT_INJECTION_KEY = Symbol("popperContent");
  
    const TOOLTIP_INJECTION_KEY = Symbol("elTooltip");
  
    const tooltipV2RootKey = Symbol("tooltipV2");
    const tooltipV2ContentKey = Symbol("tooltipV2Content");
    const TOOLTIP_V2_OPEN = "tooltip_v2.open";
  
    const ROOT_PICKER_INJECTION_KEY = Symbol();
  
    const useProp = (name) => {
      const vm = vue.getCurrentInstance();
      return vue.computed(() => {
        var _a, _b;
        return (_b = ((_a = vm.proxy) == null ? void 0 : _a.$props)[name]) != null ? _b : void 0;
      });
    };
  
    const globalConfig = vue.ref();
    function useGlobalConfig(key, defaultValue = void 0) {
      const config = vue.getCurrentInstance() ? vue.inject(configProviderContextKey, globalConfig) : globalConfig;
      if (key) {
        return vue.computed(() => {
          var _a, _b;
          return (_b = (_a = config.value) == null ? void 0 : _a[key]) != null ? _b : defaultValue;
        });
      } else {
        return config;
      }
    }
    const provideGlobalConfig = (config, app, global = false) => {
      var _a;
      const inSetup = !!vue.getCurrentInstance();
      const oldConfig = inSetup ? useGlobalConfig() : void 0;
      const provideFn = (_a = app == null ? void 0 : app.provide) != null ? _a : inSetup ? vue.provide : void 0;
      if (!provideFn) {
        return;
      }
      const context = vue.computed(() => {
        const cfg = vue.unref(config);
        if (!(oldConfig == null ? void 0 : oldConfig.value))
          return cfg;
        return mergeConfig(oldConfig.value, cfg);
      });
      provideFn(configProviderContextKey, context);
      if (global || !globalConfig.value) {
        globalConfig.value = context.value;
      }
      return context;
    };
    const mergeConfig = (a, b) => {
      var _a;
      const keys = [.../* @__PURE__ */ new Set([...keysOf(a), ...keysOf(b)])];
      const obj = {};
      for (const key of keys) {
        obj[key] = (_a = b[key]) != null ? _a : a[key];
      }
      return obj;
    };
  
    const useSizeProp = buildProp({
      type: String,
      values: componentSizes,
      required: false
    });
    const useSize = (fallback, ignore = {}) => {
      const emptyRef = vue.ref(void 0);
      const size = ignore.prop ? emptyRef : useProp("size");
      const globalConfig = ignore.global ? emptyRef : useGlobalConfig("size");
      const form = ignore.form ? { size: void 0 } : vue.inject(formContextKey, void 0);
      const formItem = ignore.formItem ? { size: void 0 } : vue.inject(formItemContextKey, void 0);
      return vue.computed(() => size.value || vue.unref(fallback) || (formItem == null ? void 0 : formItem.size) || (form == null ? void 0 : form.size) || globalConfig.value || "");
    };
    const useDisabled = (fallback) => {
      const disabled = useProp("disabled");
      const form = vue.inject(formContextKey, void 0);
      return vue.computed(() => disabled.value || vue.unref(fallback) || (form == null ? void 0 : form.disabled) || false);
    };
  
    const useDeprecated = ({ from, replacement, scope, version, ref, type = "API" }, condition) => {
      vue.watch(() => vue.unref(condition), (val) => {
      }, {
        immediate: true
      });
    };
  
    const useDraggable = (targetRef, dragRef, draggable) => {
      let transform = {
        offsetX: 0,
        offsetY: 0
      };
      const onMousedown = (e) => {
        const downX = e.clientX;
        const downY = e.clientY;
        const { offsetX, offsetY } = transform;
        const targetRect = targetRef.value.getBoundingClientRect();
        const targetLeft = targetRect.left;
        const targetTop = targetRect.top;
        const targetWidth = targetRect.width;
        const targetHeight = targetRect.height;
        const clientWidth = document.documentElement.clientWidth;
        const clientHeight = document.documentElement.clientHeight;
        const minLeft = -targetLeft + offsetX;
        const minTop = -targetTop + offsetY;
        const maxLeft = clientWidth - targetLeft - targetWidth + offsetX;
        const maxTop = clientHeight - targetTop - targetHeight + offsetY;
        const onMousemove = (e2) => {
          const moveX = Math.min(Math.max(offsetX + e2.clientX - downX, minLeft), maxLeft);
          const moveY = Math.min(Math.max(offsetY + e2.clientY - downY, minTop), maxTop);
          transform = {
            offsetX: moveX,
            offsetY: moveY
          };
          targetRef.value.style.transform = `translate(${addUnit(moveX)}, ${addUnit(moveY)})`;
        };
        const onMouseup = () => {
          document.removeEventListener("mousemove", onMousemove);
          document.removeEventListener("mouseup", onMouseup);
        };
        document.addEventListener("mousemove", onMousemove);
        document.addEventListener("mouseup", onMouseup);
      };
      const onDraggable = () => {
        if (dragRef.value && targetRef.value) {
          dragRef.value.addEventListener("mousedown", onMousedown);
        }
      };
      const offDraggable = () => {
        if (dragRef.value && targetRef.value) {
          dragRef.value.removeEventListener("mousedown", onMousedown);
        }
      };
      vue.onMounted(() => {
        vue.watchEffect(() => {
          if (draggable.value) {
            onDraggable();
          } else {
            offDraggable();
          }
        });
      });
      vue.onBeforeUnmount(() => {
        offDraggable();
      });
    };
  
    const useFocus = (el) => {
      return {
        focus: () => {
          var _a, _b;
          (_b = (_a = el.value) == null ? void 0 : _a.focus) == null ? void 0 : _b.call(_a);
        }
      };
    };
  
    const defaultNamespace = "el";
    const statePrefix = "is-";
    const _bem = (namespace, block, blockSuffix, element, modifier) => {
      let cls = `${namespace}-${block}`;
      if (blockSuffix) {
        cls += `-${blockSuffix}`;
      }
      if (element) {
        cls += `__${element}`;
      }
      if (modifier) {
        cls += `--${modifier}`;
      }
      return cls;
    };
    const useNamespace = (block) => {
      const namespace = useGlobalConfig("namespace", defaultNamespace);
      const b = (blockSuffix = "") => _bem(namespace.value, block, blockSuffix, "", "");
      const e = (element) => element ? _bem(namespace.value, block, "", element, "") : "";
      const m = (modifier) => modifier ? _bem(namespace.value, block, "", "", modifier) : "";
      const be = (blockSuffix, element) => blockSuffix && element ? _bem(namespace.value, block, blockSuffix, element, "") : "";
      const em = (element, modifier) => element && modifier ? _bem(namespace.value, block, "", element, modifier) : "";
      const bm = (blockSuffix, modifier) => blockSuffix && modifier ? _bem(namespace.value, block, blockSuffix, "", modifier) : "";
      const bem = (blockSuffix, element, modifier) => blockSuffix && element && modifier ? _bem(namespace.value, block, blockSuffix, element, modifier) : "";
      const is = (name, ...args) => {
        const state = args.length >= 1 ? args[0] : true;
        return name && state ? `${statePrefix}${name}` : "";
      };
      const cssVar = (object) => {
        const styles = {};
        for (const key in object) {
          if (object[key]) {
            styles[`--${namespace.value}-${key}`] = object[key];
          }
        }
        return styles;
      };
      const cssVarBlock = (object) => {
        const styles = {};
        for (const key in object) {
          if (object[key]) {
            styles[`--${namespace.value}-${block}-${key}`] = object[key];
          }
        }
        return styles;
      };
      const cssVarName = (name) => `--${namespace.value}-${name}`;
      const cssVarBlockName = (name) => `--${namespace.value}-${block}-${name}`;
      return {
        namespace,
        b,
        e,
        m,
        be,
        em,
        bm,
        bem,
        is,
        cssVar,
        cssVarName,
        cssVarBlock,
        cssVarBlockName
      };
    };
  
    const defaultIdInjection = {
      prefix: Math.floor(Math.random() * 1e4),
      current: 0
    };
    const ID_INJECTION_KEY = Symbol("elIdInjection");
    const useId = (deterministicId) => {
      const idInjection = vue.inject(ID_INJECTION_KEY, defaultIdInjection);
      const namespace = useGlobalConfig("namespace", defaultNamespace);
      const idRef = vue.computed(() => vue.unref(deterministicId) || `${namespace.value}-id-${idInjection.prefix}-${idInjection.current++}`);
      return idRef;
    };
  
    const useFormItem = () => {
      const form = vue.inject(formContextKey, void 0);
      const formItem = vue.inject(formItemContextKey, void 0);
      return {
        form,
        formItem
      };
    };
    const useFormItemInputId = (props, {
      formItemContext,
      disableIdGeneration,
      disableIdManagement
    }) => {
      if (!disableIdGeneration) {
        disableIdGeneration = vue.ref(false);
      }
      if (!disableIdManagement) {
        disableIdManagement = vue.ref(false);
      }
      const inputId = vue.ref();
      let idUnwatch = void 0;
      const isLabeledByFormItem = vue.computed(() => {
        var _a;
        return !!(!props.label && formItemContext && formItemContext.inputIds && ((_a = formItemContext.inputIds) == null ? void 0 : _a.length) <= 1);
      });
      vue.onMounted(() => {
        idUnwatch = vue.watch([vue.toRef(props, "id"), disableIdGeneration], ([id, disableIdGeneration2]) => {
          const newId = id != null ? id : !disableIdGeneration2 ? useId().value : void 0;
          if (newId !== inputId.value) {
            if (formItemContext == null ? void 0 : formItemContext.removeInputId) {
              inputId.value && formItemContext.removeInputId(inputId.value);
              if (!(disableIdManagement == null ? void 0 : disableIdManagement.value) && !disableIdGeneration2 && newId) {
                formItemContext.addInputId(newId);
              }
            }
            inputId.value = newId;
          }
        }, { immediate: true });
      });
      vue.onUnmounted(() => {
        idUnwatch && idUnwatch();
        if (formItemContext == null ? void 0 : formItemContext.removeInputId) {
          inputId.value && formItemContext.removeInputId(inputId.value);
        }
      });
      return {
        isLabeledByFormItem,
        inputId
      };
    };
  
    var English = {
      name: "en",
      el: {
        colorpicker: {
          confirm: "OK",
          clear: "Clear",
          defaultLabel: "color picker",
          description: "current color is {color}. press enter to select a new color."
        },
        datepicker: {
          now: "Now",
          today: "Today",
          cancel: "Cancel",
          clear: "Clear",
          confirm: "OK",
          dateTablePrompt: "Use the arrow keys and enter to select the day of the month",
          monthTablePrompt: "Use the arrow keys and enter to select the month",
          yearTablePrompt: "Use the arrow keys and enter to select the year",
          selectedDate: "Selected date",
          selectDate: "Select date",
          selectTime: "Select time",
          startDate: "Start Date",
          startTime: "Start Time",
          endDate: "End Date",
          endTime: "End Time",
          prevYear: "Previous Year",
          nextYear: "Next Year",
          prevMonth: "Previous Month",
          nextMonth: "Next Month",
          year: "",
          month1: "January",
          month2: "February",
          month3: "March",
          month4: "April",
          month5: "May",
          month6: "June",
          month7: "July",
          month8: "August",
          month9: "September",
          month10: "October",
          month11: "November",
          month12: "December",
          week: "week",
          weeks: {
            sun: "Sun",
            mon: "Mon",
            tue: "Tue",
            wed: "Wed",
            thu: "Thu",
            fri: "Fri",
            sat: "Sat"
          },
          weeksFull: {
            sun: "Sunday",
            mon: "Monday",
            tue: "Tuesday",
            wed: "Wednesday",
            thu: "Thursday",
            fri: "Friday",
            sat: "Saturday"
          },
          months: {
            jan: "Jan",
            feb: "Feb",
            mar: "Mar",
            apr: "Apr",
            may: "May",
            jun: "Jun",
            jul: "Jul",
            aug: "Aug",
            sep: "Sep",
            oct: "Oct",
            nov: "Nov",
            dec: "Dec"
          }
        },
        inputNumber: {
          decrease: "decrease number",
          increase: "increase number"
        },
        select: {
          loading: "Loading",
          noMatch: "No matching data",
          noData: "No data",
          placeholder: "Select"
        },
        dropdown: {
          toggleDropdown: "Toggle Dropdown"
        },
        cascader: {
          noMatch: "No matching data",
          loading: "Loading",
          placeholder: "Select",
          noData: "No data"
        },
        pagination: {
          goto: "Go to",
          pagesize: "/page",
          total: "Total {total}",
          pageClassifier: "",
          deprecationWarning: "Deprecated usages detected, please refer to the el-pagination documentation for more details"
        },
        dialog: {
          close: "Close this dialog"
        },
        drawer: {
          close: "Close this dialog"
        },
        messagebox: {
          title: "Message",
          confirm: "OK",
          cancel: "Cancel",
          error: "Illegal input",
          close: "Close this dialog"
        },
        upload: {
          deleteTip: "press delete to remove",
          delete: "Delete",
          preview: "Preview",
          continue: "Continue"
        },
        slider: {
          defaultLabel: "slider between {min} and {max}",
          defaultRangeStartLabel: "pick start value",
          defaultRangeEndLabel: "pick end value"
        },
        table: {
          emptyText: "No Data",
          confirmFilter: "Confirm",
          resetFilter: "Reset",
          clearFilter: "All",
          sumText: "Sum"
        },
        tree: {
          emptyText: "No Data"
        },
        transfer: {
          noMatch: "No matching data",
          noData: "No data",
          titles: ["List 1", "List 2"],
          filterPlaceholder: "Enter keyword",
          noCheckedFormat: "{total} items",
          hasCheckedFormat: "{checked}/{total} checked"
        },
        image: {
          error: "FAILED"
        },
        pageHeader: {
          title: "Back"
        },
        popconfirm: {
          confirmButtonText: "Yes",
          cancelButtonText: "No"
        }
      }
    };
  
    const buildTranslator = (locale) => (path, option) => translate(path, option, vue.unref(locale));
    const translate = (path, option, locale) => get(locale, path, path).replace(/\{(\w+)\}/g, (_, key) => {
      var _a;
      return `${(_a = option == null ? void 0 : option[key]) != null ? _a : `{${key}}`}`;
    });
    const buildLocaleContext = (locale) => {
      const lang = vue.computed(() => vue.unref(locale).name);
      const localeRef = vue.isRef(locale) ? locale : vue.ref(locale);
      return {
        lang,
        locale: localeRef,
        t: buildTranslator(locale)
      };
    };
    const useLocale = () => {
      const locale = useGlobalConfig("locale");
      return buildLocaleContext(vue.computed(() => locale.value || English));
    };
  
    let activeEffectScope;
    function recordEffectScope(effect2, scope = activeEffectScope) {
      if (scope && scope.active) {
        scope.effects.push(effect2);
      }
    }
    const createDep = (effects) => {
      const dep = new Set(effects);
      dep.w = 0;
      dep.n = 0;
      return dep;
    };
    const wasTracked = (dep) => (dep.w & trackOpBit) > 0;
    const newTracked = (dep) => (dep.n & trackOpBit) > 0;
    const initDepMarkers = ({ deps }) => {
      if (deps.length) {
        for (let i = 0; i < deps.length; i++) {
          deps[i].w |= trackOpBit;
        }
      }
    };
    const finalizeDepMarkers = (effect2) => {
      const { deps } = effect2;
      if (deps.length) {
        let ptr = 0;
        for (let i = 0; i < deps.length; i++) {
          const dep = deps[i];
          if (wasTracked(dep) && !newTracked(dep)) {
            dep.delete(effect2);
          } else {
            deps[ptr++] = dep;
          }
          dep.w &= ~trackOpBit;
          dep.n &= ~trackOpBit;
        }
        deps.length = ptr;
      }
    };
    let effectTrackDepth = 0;
    let trackOpBit = 1;
    const maxMarkerBits = 30;
    let activeEffect;
    class ReactiveEffect {
      constructor(fn, scheduler2 = null, scope) {
        this.fn = fn;
        this.scheduler = scheduler2;
        this.active = true;
        this.deps = [];
        this.parent = void 0;
        recordEffectScope(this, scope);
      }
      run() {
        if (!this.active) {
          return this.fn();
        }
        let parent = activeEffect;
        let lastShouldTrack = shouldTrack;
        while (parent) {
          if (parent === this) {
            return;
          }
          parent = parent.parent;
        }
        try {
          this.parent = activeEffect;
          activeEffect = this;
          shouldTrack = true;
          trackOpBit = 1 << ++effectTrackDepth;
          if (effectTrackDepth <= maxMarkerBits) {
            initDepMarkers(this);
          } else {
            cleanupEffect(this);
          }
          return this.fn();
        } finally {
          if (effectTrackDepth <= maxMarkerBits) {
            finalizeDepMarkers(this);
          }
          trackOpBit = 1 << --effectTrackDepth;
          activeEffect = this.parent;
          shouldTrack = lastShouldTrack;
          this.parent = void 0;
          if (this.deferStop) {
            this.stop();
          }
        }
      }
      stop() {
        if (activeEffect === this) {
          this.deferStop = true;
        } else if (this.active) {
          cleanupEffect(this);
          if (this.onStop) {
            this.onStop();
          }
          this.active = false;
        }
      }
    }
    function cleanupEffect(effect2) {
      const { deps } = effect2;
      if (deps.length) {
        for (let i = 0; i < deps.length; i++) {
          deps[i].delete(effect2);
        }
        deps.length = 0;
      }
    }
    let shouldTrack = true;
    function trackEffects(dep, debuggerEventExtraInfo) {
      let shouldTrack2 = false;
      if (effectTrackDepth <= maxMarkerBits) {
        if (!newTracked(dep)) {
          dep.n |= trackOpBit;
          shouldTrack2 = !wasTracked(dep);
        }
      } else {
        shouldTrack2 = !dep.has(activeEffect);
      }
      if (shouldTrack2) {
        dep.add(activeEffect);
        activeEffect.deps.push(dep);
      }
    }
    function triggerEffects(dep, debuggerEventExtraInfo) {
      const effects = isArray(dep) ? dep : [...dep];
      for (const effect2 of effects) {
        if (effect2.computed) {
          triggerEffect(effect2);
        }
      }
      for (const effect2 of effects) {
        if (!effect2.computed) {
          triggerEffect(effect2);
        }
      }
    }
    function triggerEffect(effect2, debuggerEventExtraInfo) {
      if (effect2 !== activeEffect || effect2.allowRecurse) {
        if (effect2.scheduler) {
          effect2.scheduler();
        } else {
          effect2.run();
        }
      }
    }
    function toRaw(observed) {
      const raw = observed && observed["__v_raw"];
      return raw ? toRaw(raw) : observed;
    }
    function trackRefValue(ref2) {
      if (shouldTrack && activeEffect) {
        ref2 = toRaw(ref2);
        {
          trackEffects(ref2.dep || (ref2.dep = createDep()));
        }
      }
    }
    function triggerRefValue(ref2, newVal) {
      ref2 = toRaw(ref2);
      if (ref2.dep) {
        {
          triggerEffects(ref2.dep);
        }
      }
    }
    class ComputedRefImpl {
      constructor(getter, _setter, isReadonly2, isSSR) {
        this._setter = _setter;
        this.dep = void 0;
        this.__v_isRef = true;
        this._dirty = true;
        this.effect = new ReactiveEffect(getter, () => {
          if (!this._dirty) {
            this._dirty = true;
            triggerRefValue(this);
          }
        });
        this.effect.computed = this;
        this.effect.active = this._cacheable = !isSSR;
        this["__v_isReadonly"] = isReadonly2;
      }
      get value() {
        const self = toRaw(this);
        trackRefValue(self);
        if (self._dirty || !self._cacheable) {
          self._dirty = false;
          self._value = self.effect.run();
        }
        return self._value;
      }
      set value(newValue) {
        this._setter(newValue);
      }
    }
    function computed(getterOrOptions, debugOptions, isSSR = false) {
      let getter;
      let setter;
      const onlyGetter = isFunction(getterOrOptions);
      if (onlyGetter) {
        getter = getterOrOptions;
        setter = NOOP;
      } else {
        getter = getterOrOptions.get;
        setter = getterOrOptions.set;
      }
      const cRef = new ComputedRefImpl(getter, setter, onlyGetter || !setter, isSSR);
      return cRef;
    }
  
    const useLockscreen = (trigger) => {
      if (!vue.isRef(trigger)) {
        throwError("[useLockscreen]", "You need to pass a ref param to this function");
      }
      const ns = useNamespace("popup");
      const hiddenCls = computed(() => ns.bm("parent", "hidden"));
      if (!isClient || hasClass(document.body, hiddenCls.value)) {
        return;
      }
      let scrollBarWidth = 0;
      let withoutHiddenClass = false;
      let bodyWidth = "0";
      const cleanup = () => {
        setTimeout(() => {
          removeClass(document.body, hiddenCls.value);
          if (withoutHiddenClass) {
            document.body.style.width = bodyWidth;
          }
        }, 200);
      };
      vue.watch(trigger, (val) => {
        if (!val) {
          cleanup();
          return;
        }
        withoutHiddenClass = !hasClass(document.body, hiddenCls.value);
        if (withoutHiddenClass) {
          bodyWidth = document.body.style.width;
        }
        scrollBarWidth = getScrollBarWidth(ns.namespace.value);
        const bodyHasOverflow = document.documentElement.clientHeight < document.body.scrollHeight;
        const bodyOverflowY = getStyle(document.body, "overflowY");
        if (scrollBarWidth > 0 && (bodyHasOverflow || bodyOverflowY === "scroll") && withoutHiddenClass) {
          document.body.style.width = `calc(100% - ${scrollBarWidth}px)`;
        }
        addClass(document.body, hiddenCls.value);
      });
      vue.onScopeDispose(() => cleanup());
    };
  
    const modalStack = [];
    const closeModal = (e) => {
      if (modalStack.length === 0)
        return;
      if (e.code === EVENT_CODE.esc) {
        e.stopPropagation();
        const topModal = modalStack[modalStack.length - 1];
        topModal.handleClose();
      }
    };
    const useModal = (instance, visibleRef) => {
      vue.watch(visibleRef, (val) => {
        if (val) {
          modalStack.push(instance);
        } else {
          modalStack.splice(modalStack.indexOf(instance), 1);
        }
      });
    };
    if (isClient)
      useEventListener(document, "keydown", closeModal);
  
    const _prop = buildProp({
      type: definePropType(Boolean),
      default: null
    });
    const _event = buildProp({
      type: definePropType(Function)
    });
    const createModelToggleComposable = (name) => {
      const updateEventKey = `update:${name}`;
      const updateEventKeyRaw = `onUpdate:${name}`;
      const useModelToggleEmits2 = [updateEventKey];
      const useModelToggleProps2 = {
        [name]: _prop,
        [updateEventKeyRaw]: _event
      };
      const useModelToggle2 = ({
        indicator,
        toggleReason,
        shouldHideWhenRouteChanges,
        shouldProceed,
        onShow,
        onHide
      }) => {
        const instance = vue.getCurrentInstance();
        const { emit } = instance;
        const props = instance.props;
        const hasUpdateHandler = vue.computed(() => isFunction(props[updateEventKeyRaw]));
        const isModelBindingAbsent = vue.computed(() => props[name] === null);
        const doShow = (event) => {
          if (indicator.value === true) {
            return;
          }
          indicator.value = true;
          if (toggleReason) {
            toggleReason.value = event;
          }
          if (isFunction(onShow)) {
            onShow(event);
          }
        };
        const doHide = (event) => {
          if (indicator.value === false) {
            return;
          }
          indicator.value = false;
          if (toggleReason) {
            toggleReason.value = event;
          }
          if (isFunction(onHide)) {
            onHide(event);
          }
        };
        const show = (event) => {
          if (props.disabled === true || isFunction(shouldProceed) && !shouldProceed())
            return;
          const shouldEmit = hasUpdateHandler.value && isClient;
          if (shouldEmit) {
            emit(updateEventKey, true);
          }
          if (isModelBindingAbsent.value || !shouldEmit) {
            doShow(event);
          }
        };
        const hide = (event) => {
          if (props.disabled === true || !isClient)
            return;
          const shouldEmit = hasUpdateHandler.value && isClient;
          if (shouldEmit) {
            emit(updateEventKey, false);
          }
          if (isModelBindingAbsent.value || !shouldEmit) {
            doHide(event);
          }
        };
        const onChange = (val) => {
          if (!isBoolean(val))
            return;
          if (props.disabled && val) {
            if (hasUpdateHandler.value) {
              emit(updateEventKey, false);
            }
          } else if (indicator.value !== val) {
            if (val) {
              doShow();
            } else {
              doHide();
            }
          }
        };
        const toggle = () => {
          if (indicator.value) {
            hide();
          } else {
            show();
          }
        };
        vue.watch(() => props[name], onChange);
        if (shouldHideWhenRouteChanges && instance.appContext.config.globalProperties.$route !== void 0) {
          vue.watch(() => ({
            ...instance.proxy.$route
          }), () => {
            if (shouldHideWhenRouteChanges.value && indicator.value) {
              hide();
            }
          });
        }
        vue.onMounted(() => {
          onChange(props[name]);
        });
        return {
          hide,
          show,
          toggle,
          hasUpdateHandler
        };
      };
      return {
        useModelToggle: useModelToggle2,
        useModelToggleProps: useModelToggleProps2,
        useModelToggleEmits: useModelToggleEmits2
      };
    };
    const { useModelToggle, useModelToggleProps, useModelToggleEmits } = createModelToggleComposable("modelValue");
  
    const usePreventGlobal = (indicator, evt, cb) => {
      const prevent = (e) => {
        if (cb(e))
          e.stopImmediatePropagation();
      };
      let stop = void 0;
      vue.watch(() => indicator.value, (val) => {
        if (val) {
          stop = useEventListener(document, evt, prevent, true);
        } else {
          stop == null ? void 0 : stop();
        }
      }, { immediate: true });
    };
  
    const useRestoreActive = (toggle, initialFocus) => {
      let previousActive;
      vue.watch(() => toggle.value, (val) => {
        var _a, _b;
        if (val) {
          previousActive = document.activeElement;
          if (vue.isRef(initialFocus)) {
            (_b = (_a = initialFocus.value).focus) == null ? void 0 : _b.call(_a);
          }
        } else {
          {
            previousActive.focus();
          }
        }
      });
    };
  
    const useSameTarget = (handleClick) => {
      if (!handleClick) {
        return { onClick: NOOP, onMousedown: NOOP, onMouseup: NOOP };
      }
      let mousedownTarget = false;
      let mouseupTarget = false;
      const onClick = (e) => {
        if (mousedownTarget && mouseupTarget) {
          handleClick(e);
        }
        mousedownTarget = mouseupTarget = false;
      };
      const onMousedown = (e) => {
        mousedownTarget = e.target === e.currentTarget;
      };
      const onMouseup = (e) => {
        mouseupTarget = e.target === e.currentTarget;
      };
      return { onClick, onMousedown, onMouseup };
    };
  
    const useTeleport = (contentRenderer, appendToBody) => {
      const isTeleportVisible = vue.ref(false);
      if (!isClient) {
        return {
          isTeleportVisible,
          showTeleport: NOOP,
          hideTeleport: NOOP,
          renderTeleport: NOOP
        };
      }
      let $el = null;
      const showTeleport = () => {
        isTeleportVisible.value = true;
        if ($el !== null)
          return;
        $el = createGlobalNode();
      };
      const hideTeleport = () => {
        isTeleportVisible.value = false;
        if ($el !== null) {
          removeGlobalNode($el);
          $el = null;
        }
      };
      const renderTeleport = () => {
        return appendToBody.value !== true ? contentRenderer() : isTeleportVisible.value ? [vue.h(vue.Teleport, { to: $el }, contentRenderer())] : void 0;
      };
      vue.onUnmounted(hideTeleport);
      return {
        isTeleportVisible,
        showTeleport,
        hideTeleport,
        renderTeleport
      };
    };
  
    const useThrottleRender = (loading, throttle = 0) => {
      if (throttle === 0)
        return loading;
      const throttled = vue.ref(false);
      let timeoutHandle = 0;
      const dispatchThrottling = () => {
        if (timeoutHandle) {
          clearTimeout(timeoutHandle);
        }
        timeoutHandle = window.setTimeout(() => {
          throttled.value = loading.value;
        }, throttle);
      };
      vue.onMounted(dispatchThrottling);
      vue.watch(() => loading.value, (val) => {
        if (val) {
          dispatchThrottling();
        } else {
          throttled.value = val;
        }
      });
      return throttled;
    };
  
    function useTimeout() {
      let timeoutHandle;
      const registerTimeout = (fn, delay) => {
        cancelTimeout();
        timeoutHandle = window.setTimeout(fn, delay);
      };
      const cancelTimeout = () => window.clearTimeout(timeoutHandle);
      tryOnScopeDispose(() => cancelTimeout());
      return {
        registerTimeout,
        cancelTimeout
      };
    }
  
    const AFTER_APPEAR = "after-appear";
    const AFTER_ENTER = "after-enter";
    const AFTER_LEAVE = "after-leave";
    const APPEAR = "appear";
    const APPEAR_CANCELLED = "appear-cancelled";
    const BEFORE_ENTER = "before-enter";
    const BEFORE_LEAVE = "before-leave";
    const ENTER = "enter";
    const ENTER_CANCELLED = "enter-cancelled";
    const LEAVE = "leave";
    const LEAVE_CANCELLED = "leave-cancelled";
    const useTransitionFallthroughEmits = [
      AFTER_APPEAR,
      AFTER_ENTER,
      AFTER_LEAVE,
      APPEAR,
      APPEAR_CANCELLED,
      BEFORE_ENTER,
      BEFORE_LEAVE,
      ENTER,
      ENTER_CANCELLED,
      LEAVE,
      LEAVE_CANCELLED
    ];
    const useTransitionFallthrough = () => {
      const { emit } = vue.getCurrentInstance();
      return {
        onAfterAppear: () => {
          emit(AFTER_APPEAR);
        },
        onAfterEnter: () => {
          emit(AFTER_ENTER);
        },
        onAfterLeave: () => {
          emit(AFTER_LEAVE);
        },
        onAppearCancelled: () => {
          emit(APPEAR_CANCELLED);
        },
        onBeforeEnter: () => {
          emit(BEFORE_ENTER);
        },
        onBeforeLeave: () => {
          emit(BEFORE_LEAVE);
        },
        onEnter: () => {
          emit(ENTER);
        },
        onEnterCancelled: () => {
          emit(ENTER_CANCELLED);
        },
        onLeave: () => {
          emit(LEAVE);
        },
        onLeaveCancelled: () => {
          emit(LEAVE_CANCELLED);
        }
      };
    };
  
    let registeredEscapeHandlers = [];
    const cachedHandler = (e) => {
      const event = e;
      if (event.key === EVENT_CODE.esc) {
        registeredEscapeHandlers.forEach((registeredHandler) => registeredHandler(event));
      }
    };
    const useEscapeKeydown = (handler) => {
      vue.onMounted(() => {
        if (registeredEscapeHandlers.length === 0) {
          document.addEventListener("keydown", cachedHandler);
        }
        if (isClient)
          registeredEscapeHandlers.push(handler);
      });
      vue.onBeforeUnmount(() => {
        registeredEscapeHandlers = registeredEscapeHandlers.filter((registeredHandler) => registeredHandler !== handler);
        if (registeredEscapeHandlers.length === 0) {
          if (isClient)
            document.removeEventListener("keydown", cachedHandler);
        }
      });
    };
  
    let cachedContainer;
    const namespace = useGlobalConfig("namespace", defaultNamespace);
    const POPPER_CONTAINER_ID = `${namespace.value}-popper-container-${generateId()}`;
    const POPPER_CONTAINER_SELECTOR = `#${POPPER_CONTAINER_ID}`;
    const createContainer = () => {
      const container = document.createElement("div");
      container.id = POPPER_CONTAINER_ID;
      document.body.appendChild(container);
      return container;
    };
    const usePopperContainer = () => {
      vue.onBeforeMount(() => {
        if (!isClient)
          return;
        if (!cachedContainer || !document.body.querySelector(POPPER_CONTAINER_SELECTOR)) {
          cachedContainer = createContainer();
        }
      });
    };
  
    const useDelayedRender = ({
      indicator,
      intermediateIndicator,
      shouldSetIntermediate = () => true,
      beforeShow,
      afterShow,
      afterHide,
      beforeHide
    }) => {
      vue.watch(() => vue.unref(indicator), (val) => {
        if (val) {
          beforeShow == null ? void 0 : beforeShow();
          vue.nextTick(() => {
            if (!vue.unref(indicator))
              return;
            if (shouldSetIntermediate("show")) {
              intermediateIndicator.value = true;
            }
          });
        } else {
          beforeHide == null ? void 0 : beforeHide();
          vue.nextTick(() => {
            if (vue.unref(indicator))
              return;
            if (shouldSetIntermediate("hide")) {
              intermediateIndicator.value = false;
            }
          });
        }
      });
      vue.watch(() => intermediateIndicator.value, (val) => {
        if (val) {
          afterShow == null ? void 0 : afterShow();
        } else {
          afterHide == null ? void 0 : afterHide();
        }
      });
    };
  
    const useDelayedToggleProps = buildProps({
      showAfter: {
        type: Number,
        default: 0
      },
      hideAfter: {
        type: Number,
        default: 200
      }
    });
    const useDelayedToggle = ({
      showAfter,
      hideAfter,
      open,
      close
    }) => {
      const { registerTimeout } = useTimeout();
      const onOpen = (event) => {
        registerTimeout(() => {
          open(event);
        }, vue.unref(showAfter));
      };
      const onClose = (event) => {
        registerTimeout(() => {
          close(event);
        }, vue.unref(hideAfter));
      };
      return {
        onOpen,
        onClose
      };
    };
  
    const FORWARD_REF_INJECTION_KEY = Symbol("elForwardRef");
    const useForwardRef = (forwardRef) => {
      const setForwardRef = (el) => {
        forwardRef.value = el;
      };
      vue.provide(FORWARD_REF_INJECTION_KEY, {
        setForwardRef
      });
    };
    const useForwardRefDirective = (setForwardRef) => {
      return {
        mounted(el) {
          setForwardRef(el);
        },
        updated(el) {
          setForwardRef(el);
        },
        unmounted() {
          setForwardRef(null);
        }
      };
    };
  
    const zIndex = vue.ref(0);
    const useZIndex = () => {
      const initialZIndex = useGlobalConfig("zIndex", 2e3);
      const currentZIndex = vue.computed(() => initialZIndex.value + zIndex.value);
      const nextZIndex = () => {
        zIndex.value++;
        return currentZIndex.value;
      };
      return {
        initialZIndex,
        currentZIndex,
        nextZIndex
      };
    };
  
    function getSide(placement) {
      return placement.split('-')[0];
    }
  
    function getAlignment(placement) {
      return placement.split('-')[1];
    }
  
    function getMainAxisFromPlacement(placement) {
      return ['top', 'bottom'].includes(getSide(placement)) ? 'x' : 'y';
    }
  
    function getLengthFromAxis(axis) {
      return axis === 'y' ? 'height' : 'width';
    }
  
    function computeCoordsFromPlacement(_ref, placement, rtl) {
      let {
        reference,
        floating
      } = _ref;
      const commonX = reference.x + reference.width / 2 - floating.width / 2;
      const commonY = reference.y + reference.height / 2 - floating.height / 2;
      const mainAxis = getMainAxisFromPlacement(placement);
      const length = getLengthFromAxis(mainAxis);
      const commonAlign = reference[length] / 2 - floating[length] / 2;
      const side = getSide(placement);
      const isVertical = mainAxis === 'x';
      let coords;
  
      switch (side) {
        case 'top':
          coords = {
            x: commonX,
            y: reference.y - floating.height
          };
          break;
  
        case 'bottom':
          coords = {
            x: commonX,
            y: reference.y + reference.height
          };
          break;
  
        case 'right':
          coords = {
            x: reference.x + reference.width,
            y: commonY
          };
          break;
  
        case 'left':
          coords = {
            x: reference.x - floating.width,
            y: commonY
          };
          break;
  
        default:
          coords = {
            x: reference.x,
            y: reference.y
          };
      }
  
      switch (getAlignment(placement)) {
        case 'start':
          coords[mainAxis] -= commonAlign * (rtl && isVertical ? -1 : 1);
          break;
  
        case 'end':
          coords[mainAxis] += commonAlign * (rtl && isVertical ? -1 : 1);
          break;
      }
  
      return coords;
    }
  
    /**
     * Computes the `x` and `y` coordinates that will place the floating element
     * next to a reference element when it is given a certain positioning strategy.
     *
     * This export does not have any `platform` interface logic. You will need to
     * write one for the platform you are using Floating UI with.
     */
  
    const computePosition$1 = async (reference, floating, config) => {
      const {
        placement = 'bottom',
        strategy = 'absolute',
        middleware = [],
        platform
      } = config;
      const rtl = await (platform.isRTL == null ? void 0 : platform.isRTL(floating));
  
      if (process.env.NODE_ENV !== "production") {
        if (platform == null) {
          console.error(['Floating UI: `platform` property was not passed to config. If you', 'want to use Floating UI on the web, install @floating-ui/dom', 'instead of the /core package. Otherwise, you can create your own', '`platform`: https://floating-ui.com/docs/platform'].join(' '));
        }
  
        if (middleware.filter(_ref => {
          let {
            name
          } = _ref;
          return name === 'autoPlacement' || name === 'flip';
        }).length > 1) {
          throw new Error(['Floating UI: duplicate `flip` and/or `autoPlacement`', 'middleware detected. This will lead to an infinite loop. Ensure only', 'one of either has been passed to the `middleware` array.'].join(' '));
        }
      }
  
      let rects = await platform.getElementRects({
        reference,
        floating,
        strategy
      });
      let {
        x,
        y
      } = computeCoordsFromPlacement(rects, placement, rtl);
      let statefulPlacement = placement;
      let middlewareData = {};
      let resetCount = 0;
  
      for (let i = 0; i < middleware.length; i++) {
        const {
          name,
          fn
        } = middleware[i];
        const {
          x: nextX,
          y: nextY,
          data,
          reset
        } = await fn({
          x,
          y,
          initialPlacement: placement,
          placement: statefulPlacement,
          strategy,
          middlewareData,
          rects,
          platform,
          elements: {
            reference,
            floating
          }
        });
        x = nextX != null ? nextX : x;
        y = nextY != null ? nextY : y;
        middlewareData = { ...middlewareData,
          [name]: { ...middlewareData[name],
            ...data
          }
        };
  
        if (process.env.NODE_ENV !== "production") {
          if (resetCount > 50) {
            console.warn(['Floating UI: The middleware lifecycle appears to be running in an', 'infinite loop. This is usually caused by a `reset` continually', 'being returned without a break condition.'].join(' '));
          }
        }
  
        if (reset && resetCount <= 50) {
          resetCount++;
  
          if (typeof reset === 'object') {
            if (reset.placement) {
              statefulPlacement = reset.placement;
            }
  
            if (reset.rects) {
              rects = reset.rects === true ? await platform.getElementRects({
                reference,
                floating,
                strategy
              }) : reset.rects;
            }
  
            ({
              x,
              y
            } = computeCoordsFromPlacement(rects, statefulPlacement, rtl));
          }
  
          i = -1;
          continue;
        }
      }
  
      return {
        x,
        y,
        placement: statefulPlacement,
        strategy,
        middlewareData
      };
    };
  
    function expandPaddingObject(padding) {
      return {
        top: 0,
        right: 0,
        bottom: 0,
        left: 0,
        ...padding
      };
    }
  
    function getSideObjectFromPadding(padding) {
      return typeof padding !== 'number' ? expandPaddingObject(padding) : {
        top: padding,
        right: padding,
        bottom: padding,
        left: padding
      };
    }
  
    function rectToClientRect(rect) {
      return { ...rect,
        top: rect.y,
        left: rect.x,
        right: rect.x + rect.width,
        bottom: rect.y + rect.height
      };
    }
  
    const min$2 = Math.min;
    const max$2 = Math.max;
  
    function within(min$1, value, max$1) {
      return max$2(min$1, min$2(value, max$1));
    }
  
    /**
     * Positions an inner element of the floating element such that it is centered
     * to the reference element.
     * @see https://floating-ui.com/docs/arrow
     */
    const arrow = options => ({
      name: 'arrow',
      options,
  
      async fn(middlewareArguments) {
        // Since `element` is required, we don't Partial<> the type
        const {
          element,
          padding = 0
        } = options != null ? options : {};
        const {
          x,
          y,
          placement,
          rects,
          platform
        } = middlewareArguments;
  
        if (element == null) {
          if (process.env.NODE_ENV !== "production") {
            console.warn('Floating UI: No `element` was passed to the `arrow` middleware.');
          }
  
          return {};
        }
  
        const paddingObject = getSideObjectFromPadding(padding);
        const coords = {
          x,
          y
        };
        const axis = getMainAxisFromPlacement(placement);
        const alignment = getAlignment(placement);
        const length = getLengthFromAxis(axis);
        const arrowDimensions = await platform.getDimensions(element);
        const minProp = axis === 'y' ? 'top' : 'left';
        const maxProp = axis === 'y' ? 'bottom' : 'right';
        const endDiff = rects.reference[length] + rects.reference[axis] - coords[axis] - rects.floating[length];
        const startDiff = coords[axis] - rects.reference[axis];
        const arrowOffsetParent = await (platform.getOffsetParent == null ? void 0 : platform.getOffsetParent(element));
        let clientSize = arrowOffsetParent ? axis === 'y' ? arrowOffsetParent.clientHeight || 0 : arrowOffsetParent.clientWidth || 0 : 0;
  
        if (clientSize === 0) {
          clientSize = rects.floating[length];
        }
  
        const centerToReference = endDiff / 2 - startDiff / 2; // Make sure the arrow doesn't overflow the floating element if the center
        // point is outside the floating element's bounds
  
        const min = paddingObject[minProp];
        const max = clientSize - arrowDimensions[length] - paddingObject[maxProp];
        const center = clientSize / 2 - arrowDimensions[length] / 2 + centerToReference;
        const offset = within(min, center, max); // Make sure that arrow points at the reference
  
        const alignmentPadding = alignment === 'start' ? paddingObject[minProp] : paddingObject[maxProp];
        const shouldAddOffset = alignmentPadding > 0 && center !== offset && rects.reference[length] <= rects.floating[length];
        const alignmentOffset = shouldAddOffset ? center < min ? min - center : max - center : 0;
        return {
          [axis]: coords[axis] - alignmentOffset,
          data: {
            [axis]: offset,
            centerOffset: center - offset
          }
        };
      }
  
    });
  
    async function convertValueToCoords(middlewareArguments, value) {
      const {
        placement,
        platform,
        elements
      } = middlewareArguments;
      const rtl = await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating));
      const side = getSide(placement);
      const alignment = getAlignment(placement);
      const isVertical = getMainAxisFromPlacement(placement) === 'x';
      const mainAxisMulti = ['left', 'top'].includes(side) ? -1 : 1;
      const crossAxisMulti = rtl && isVertical ? -1 : 1;
      const rawValue = typeof value === 'function' ? value(middlewareArguments) : value; // eslint-disable-next-line prefer-const
  
      let {
        mainAxis,
        crossAxis,
        alignmentAxis
      } = typeof rawValue === 'number' ? {
        mainAxis: rawValue,
        crossAxis: 0,
        alignmentAxis: null
      } : {
        mainAxis: 0,
        crossAxis: 0,
        alignmentAxis: null,
        ...rawValue
      };
  
      if (alignment && typeof alignmentAxis === 'number') {
        crossAxis = alignment === 'end' ? alignmentAxis * -1 : alignmentAxis;
      }
  
      return isVertical ? {
        x: crossAxis * crossAxisMulti,
        y: mainAxis * mainAxisMulti
      } : {
        x: mainAxis * mainAxisMulti,
        y: crossAxis * crossAxisMulti
      };
    }
    /**
     * Displaces the floating element from its reference element.
     * @see https://floating-ui.com/docs/offset
     */
  
    const offset = function (value) {
      if (value === void 0) {
        value = 0;
      }
  
      return {
        name: 'offset',
        options: value,
  
        async fn(middlewareArguments) {
          const {
            x,
            y
          } = middlewareArguments;
          const diffCoords = await convertValueToCoords(middlewareArguments, value);
          return {
            x: x + diffCoords.x,
            y: y + diffCoords.y,
            data: diffCoords
          };
        }
  
      };
    };
  
    function isWindow(value) {
      return value && value.document && value.location && value.alert && value.setInterval;
    }
    function getWindow(node) {
      if (node == null) {
        return window;
      }
  
      if (!isWindow(node)) {
        const ownerDocument = node.ownerDocument;
        return ownerDocument ? ownerDocument.defaultView || window : window;
      }
  
      return node;
    }
  
    function getComputedStyle$1(element) {
      return getWindow(element).getComputedStyle(element);
    }
  
    function getNodeName(node) {
      return isWindow(node) ? '' : node ? (node.nodeName || '').toLowerCase() : '';
    }
  
    function getUAString() {
      const uaData = navigator.userAgentData;
  
      if (uaData != null && uaData.brands) {
        return uaData.brands.map(item => item.brand + "/" + item.version).join(' ');
      }
  
      return navigator.userAgent;
    }
  
    function isHTMLElement(value) {
      return value instanceof getWindow(value).HTMLElement;
    }
    function isElement(value) {
      return value instanceof getWindow(value).Element;
    }
    function isNode(value) {
      return value instanceof getWindow(value).Node;
    }
    function isShadowRoot(node) {
      // Browsers without `ShadowRoot` support
      if (typeof ShadowRoot === 'undefined') {
        return false;
      }
  
      const OwnElement = getWindow(node).ShadowRoot;
      return node instanceof OwnElement || node instanceof ShadowRoot;
    }
    function isOverflowElement(element) {
      // Firefox wants us to check `-x` and `-y` variations as well
      const {
        overflow,
        overflowX,
        overflowY
      } = getComputedStyle$1(element);
      return /auto|scroll|overlay|hidden/.test(overflow + overflowY + overflowX);
    }
    function isTableElement(element) {
      return ['table', 'td', 'th'].includes(getNodeName(element));
    }
    function isContainingBlock(element) {
      // TODO: Try and use feature detection here instead
      const isFirefox = /firefox/i.test(getUAString());
      const css = getComputedStyle$1(element); // This is non-exhaustive but covers the most common CSS properties that
      // create a containing block.
      // https://developer.mozilla.org/en-US/docs/Web/CSS/Containing_block#identifying_the_containing_block
  
      return css.transform !== 'none' || css.perspective !== 'none' || // @ts-ignore (TS 4.1 compat)
      css.contain === 'paint' || ['transform', 'perspective'].includes(css.willChange) || isFirefox && css.willChange === 'filter' || isFirefox && (css.filter ? css.filter !== 'none' : false);
    }
    function isLayoutViewport() {
      // Not Safari
      return !/^((?!chrome|android).)*safari/i.test(getUAString()); // Feature detection for this fails in various ways
      // • Always-visible scrollbar or not
      // • Width of <html>, etc.
      // const vV = win.visualViewport;
      // return vV ? Math.abs(win.innerWidth / vV.scale - vV.width) < 0.5 : true;
    }
  
    const min$1 = Math.min;
    const max$1 = Math.max;
    const round = Math.round;
  
    function getBoundingClientRect(element, includeScale, isFixedStrategy) {
      var _win$visualViewport$o, _win$visualViewport, _win$visualViewport$o2, _win$visualViewport2;
  
      if (includeScale === void 0) {
        includeScale = false;
      }
  
      if (isFixedStrategy === void 0) {
        isFixedStrategy = false;
      }
  
      const clientRect = element.getBoundingClientRect();
      let scaleX = 1;
      let scaleY = 1;
  
      if (includeScale && isHTMLElement(element)) {
        scaleX = element.offsetWidth > 0 ? round(clientRect.width) / element.offsetWidth || 1 : 1;
        scaleY = element.offsetHeight > 0 ? round(clientRect.height) / element.offsetHeight || 1 : 1;
      }
  
      const win = isElement(element) ? getWindow(element) : window;
      const addVisualOffsets = !isLayoutViewport() && isFixedStrategy;
      const x = (clientRect.left + (addVisualOffsets ? (_win$visualViewport$o = (_win$visualViewport = win.visualViewport) == null ? void 0 : _win$visualViewport.offsetLeft) != null ? _win$visualViewport$o : 0 : 0)) / scaleX;
      const y = (clientRect.top + (addVisualOffsets ? (_win$visualViewport$o2 = (_win$visualViewport2 = win.visualViewport) == null ? void 0 : _win$visualViewport2.offsetTop) != null ? _win$visualViewport$o2 : 0 : 0)) / scaleY;
      const width = clientRect.width / scaleX;
      const height = clientRect.height / scaleY;
      return {
        width,
        height,
        top: y,
        right: x + width,
        bottom: y + height,
        left: x,
        x,
        y
      };
    }
  
    function getDocumentElement(node) {
      return ((isNode(node) ? node.ownerDocument : node.document) || window.document).documentElement;
    }
  
    function getNodeScroll(element) {
      if (isElement(element)) {
        return {
          scrollLeft: element.scrollLeft,
          scrollTop: element.scrollTop
        };
      }
  
      return {
        scrollLeft: element.pageXOffset,
        scrollTop: element.pageYOffset
      };
    }
  
    function getWindowScrollBarX(element) {
      // If <html> has a CSS width greater than the viewport, then this will be
      // incorrect for RTL.
      return getBoundingClientRect(getDocumentElement(element)).left + getNodeScroll(element).scrollLeft;
    }
  
    function isScaled(element) {
      const rect = getBoundingClientRect(element);
      return round(rect.width) !== element.offsetWidth || round(rect.height) !== element.offsetHeight;
    }
  
    function getRectRelativeToOffsetParent(element, offsetParent, strategy) {
      const isOffsetParentAnElement = isHTMLElement(offsetParent);
      const documentElement = getDocumentElement(offsetParent);
      const rect = getBoundingClientRect(element, // @ts-ignore - checked above (TS 4.1 compat)
      isOffsetParentAnElement && isScaled(offsetParent), strategy === 'fixed');
      let scroll = {
        scrollLeft: 0,
        scrollTop: 0
      };
      const offsets = {
        x: 0,
        y: 0
      };
  
      if (isOffsetParentAnElement || !isOffsetParentAnElement && strategy !== 'fixed') {
        if (getNodeName(offsetParent) !== 'body' || isOverflowElement(documentElement)) {
          scroll = getNodeScroll(offsetParent);
        }
  
        if (isHTMLElement(offsetParent)) {
          const offsetRect = getBoundingClientRect(offsetParent, true);
          offsets.x = offsetRect.x + offsetParent.clientLeft;
          offsets.y = offsetRect.y + offsetParent.clientTop;
        } else if (documentElement) {
          offsets.x = getWindowScrollBarX(documentElement);
        }
      }
  
      return {
        x: rect.left + scroll.scrollLeft - offsets.x,
        y: rect.top + scroll.scrollTop - offsets.y,
        width: rect.width,
        height: rect.height
      };
    }
  
    function getParentNode(node) {
      if (getNodeName(node) === 'html') {
        return node;
      }
  
      return (// this is a quicker (but less type safe) way to save quite some bytes from the bundle
        // @ts-ignore
        node.assignedSlot || // step into the shadow DOM of the parent of a slotted node
        node.parentNode || ( // DOM Element detected
        isShadowRoot(node) ? node.host : null) || // ShadowRoot detected
        getDocumentElement(node) // fallback
  
      );
    }
  
    function getTrueOffsetParent(element) {
      if (!isHTMLElement(element) || getComputedStyle$1(element).position === 'fixed') {
        return null;
      }
  
      return composedOffsetParent(element);
    }
    /**
     * Polyfills the old offsetParent behavior from before the spec was changed:
     * https://github.com/w3c/csswg-drafts/issues/159
     */
  
  
    function composedOffsetParent(element) {
      let {
        offsetParent
      } = element;
      let ancestor = element;
      let foundInsideSlot = false;
  
      while (ancestor && ancestor !== offsetParent) {
        const {
          assignedSlot
        } = ancestor;
  
        if (assignedSlot) {
          let newOffsetParent = assignedSlot.offsetParent;
  
          if (getComputedStyle$1(assignedSlot).display === 'contents') {
            const hadStyleAttribute = assignedSlot.hasAttribute('style');
            const oldDisplay = assignedSlot.style.display;
            assignedSlot.style.display = getComputedStyle$1(ancestor).display;
            newOffsetParent = assignedSlot.offsetParent;
            assignedSlot.style.display = oldDisplay;
  
            if (!hadStyleAttribute) {
              assignedSlot.removeAttribute('style');
            }
          }
  
          ancestor = assignedSlot;
  
          if (offsetParent !== newOffsetParent) {
            offsetParent = newOffsetParent;
            foundInsideSlot = true;
          }
        } else if (isShadowRoot(ancestor) && ancestor.host && foundInsideSlot) {
          break;
        }
  
        ancestor = isShadowRoot(ancestor) && ancestor.host || ancestor.parentNode;
      }
  
      return offsetParent;
    }
  
    function getContainingBlock(element) {
      let currentNode = getParentNode(element);
  
      if (isShadowRoot(currentNode)) {
        currentNode = currentNode.host;
      }
  
      while (isHTMLElement(currentNode) && !['html', 'body'].includes(getNodeName(currentNode))) {
        if (isContainingBlock(currentNode)) {
          return currentNode;
        } else {
          const parent = currentNode.parentNode;
          currentNode = isShadowRoot(parent) ? parent.host : parent;
        }
      }
  
      return null;
    } // Gets the closest ancestor positioned element. Handles some edge cases,
    // such as table ancestors and cross browser bugs.
  
  
    function getOffsetParent(element) {
      const window = getWindow(element);
      let offsetParent = getTrueOffsetParent(element);
  
      while (offsetParent && isTableElement(offsetParent) && getComputedStyle$1(offsetParent).position === 'static') {
        offsetParent = getTrueOffsetParent(offsetParent);
      }
  
      if (offsetParent && (getNodeName(offsetParent) === 'html' || getNodeName(offsetParent) === 'body' && getComputedStyle$1(offsetParent).position === 'static' && !isContainingBlock(offsetParent))) {
        return window;
      }
  
      return offsetParent || getContainingBlock(element) || window;
    }
  
    function getDimensions(element) {
      if (isHTMLElement(element)) {
        return {
          width: element.offsetWidth,
          height: element.offsetHeight
        };
      }
  
      const rect = getBoundingClientRect(element);
      return {
        width: rect.width,
        height: rect.height
      };
    }
  
    function convertOffsetParentRelativeRectToViewportRelativeRect(_ref) {
      let {
        rect,
        offsetParent,
        strategy
      } = _ref;
      const isOffsetParentAnElement = isHTMLElement(offsetParent);
      const documentElement = getDocumentElement(offsetParent);
  
      if (offsetParent === documentElement) {
        return rect;
      }
  
      let scroll = {
        scrollLeft: 0,
        scrollTop: 0
      };
      const offsets = {
        x: 0,
        y: 0
      };
  
      if (isOffsetParentAnElement || !isOffsetParentAnElement && strategy !== 'fixed') {
        if (getNodeName(offsetParent) !== 'body' || isOverflowElement(documentElement)) {
          scroll = getNodeScroll(offsetParent);
        }
  
        if (isHTMLElement(offsetParent)) {
          const offsetRect = getBoundingClientRect(offsetParent, true);
          offsets.x = offsetRect.x + offsetParent.clientLeft;
          offsets.y = offsetRect.y + offsetParent.clientTop;
        } // This doesn't appear to be need to be negated.
        // else if (documentElement) {
        //   offsets.x = getWindowScrollBarX(documentElement);
        // }
  
      }
  
      return { ...rect,
        x: rect.x - scroll.scrollLeft + offsets.x,
        y: rect.y - scroll.scrollTop + offsets.y
      };
    }
  
    function getViewportRect(element, strategy) {
      const win = getWindow(element);
      const html = getDocumentElement(element);
      const visualViewport = win.visualViewport;
      let width = html.clientWidth;
      let height = html.clientHeight;
      let x = 0;
      let y = 0;
  
      if (visualViewport) {
        width = visualViewport.width;
        height = visualViewport.height;
        const layoutViewport = isLayoutViewport();
  
        if (layoutViewport || !layoutViewport && strategy === 'fixed') {
          x = visualViewport.offsetLeft;
          y = visualViewport.offsetTop;
        }
      }
  
      return {
        width,
        height,
        x,
        y
      };
    }
  
    // of the `<html>` and `<body>` rect bounds if horizontally scrollable
  
    function getDocumentRect(element) {
      var _element$ownerDocumen;
  
      const html = getDocumentElement(element);
      const scroll = getNodeScroll(element);
      const body = (_element$ownerDocumen = element.ownerDocument) == null ? void 0 : _element$ownerDocumen.body;
      const width = max$1(html.scrollWidth, html.clientWidth, body ? body.scrollWidth : 0, body ? body.clientWidth : 0);
      const height = max$1(html.scrollHeight, html.clientHeight, body ? body.scrollHeight : 0, body ? body.clientHeight : 0);
      let x = -scroll.scrollLeft + getWindowScrollBarX(element);
      const y = -scroll.scrollTop;
  
      if (getComputedStyle$1(body || html).direction === 'rtl') {
        x += max$1(html.clientWidth, body ? body.clientWidth : 0) - width;
      }
  
      return {
        width,
        height,
        x,
        y
      };
    }
  
    function getNearestOverflowAncestor(node) {
      const parentNode = getParentNode(node);
  
      if (['html', 'body', '#document'].includes(getNodeName(parentNode))) {
        // @ts-ignore assume body is always available
        return node.ownerDocument.body;
      }
  
      if (isHTMLElement(parentNode) && isOverflowElement(parentNode)) {
        return parentNode;
      }
  
      return getNearestOverflowAncestor(parentNode);
    }
  
    function getOverflowAncestors(node, list) {
      var _node$ownerDocument;
  
      if (list === void 0) {
        list = [];
      }
  
      const scrollableAncestor = getNearestOverflowAncestor(node);
      const isBody = scrollableAncestor === ((_node$ownerDocument = node.ownerDocument) == null ? void 0 : _node$ownerDocument.body);
      const win = getWindow(scrollableAncestor);
      const target = isBody ? [win].concat(win.visualViewport || [], isOverflowElement(scrollableAncestor) ? scrollableAncestor : []) : scrollableAncestor;
      const updatedList = list.concat(target);
      return isBody ? updatedList : // @ts-ignore: isBody tells us target will be an HTMLElement here
      updatedList.concat(getOverflowAncestors(target));
    }
  
    function contains(parent, child) {
      const rootNode = child.getRootNode == null ? void 0 : child.getRootNode(); // First, attempt with faster native method
  
      if (parent.contains(child)) {
        return true;
      } // then fallback to custom implementation with Shadow DOM support
      else if (rootNode && isShadowRoot(rootNode)) {
        let next = child;
  
        do {
          // use `===` replace node.isSameNode()
          if (next && parent === next) {
            return true;
          } // @ts-ignore: need a better way to handle this...
  
  
          next = next.parentNode || next.host;
        } while (next);
      }
  
      return false;
    }
  
    function getInnerBoundingClientRect(element, strategy) {
      const clientRect = getBoundingClientRect(element, false, strategy === 'fixed');
      const top = clientRect.top + element.clientTop;
      const left = clientRect.left + element.clientLeft;
      return {
        top,
        left,
        x: left,
        y: top,
        right: left + element.clientWidth,
        bottom: top + element.clientHeight,
        width: element.clientWidth,
        height: element.clientHeight
      };
    }
  
    function getClientRectFromClippingAncestor(element, clippingParent, strategy) {
      if (clippingParent === 'viewport') {
        return rectToClientRect(getViewportRect(element, strategy));
      }
  
      if (isElement(clippingParent)) {
        return getInnerBoundingClientRect(clippingParent, strategy);
      }
  
      return rectToClientRect(getDocumentRect(getDocumentElement(element)));
    } // A "clipping ancestor" is an overflowable container with the characteristic of
    // clipping (or hiding) overflowing elements with a position different from
    // `initial`
  
  
    function getClippingAncestors(element) {
      const clippingAncestors = getOverflowAncestors(element);
      const canEscapeClipping = ['absolute', 'fixed'].includes(getComputedStyle$1(element).position);
      const clipperElement = canEscapeClipping && isHTMLElement(element) ? getOffsetParent(element) : element;
  
      if (!isElement(clipperElement)) {
        return [];
      } // @ts-ignore isElement check ensures we return Array<Element>
  
  
      return clippingAncestors.filter(clippingAncestors => isElement(clippingAncestors) && contains(clippingAncestors, clipperElement) && getNodeName(clippingAncestors) !== 'body');
    } // Gets the maximum area that the element is visible in due to any number of
    // clipping ancestors
  
  
    function getClippingRect(_ref) {
      let {
        element,
        boundary,
        rootBoundary,
        strategy
      } = _ref;
      const mainClippingAncestors = boundary === 'clippingAncestors' ? getClippingAncestors(element) : [].concat(boundary);
      const clippingAncestors = [...mainClippingAncestors, rootBoundary];
      const firstClippingAncestor = clippingAncestors[0];
      const clippingRect = clippingAncestors.reduce((accRect, clippingAncestor) => {
        const rect = getClientRectFromClippingAncestor(element, clippingAncestor, strategy);
        accRect.top = max$1(rect.top, accRect.top);
        accRect.right = min$1(rect.right, accRect.right);
        accRect.bottom = min$1(rect.bottom, accRect.bottom);
        accRect.left = max$1(rect.left, accRect.left);
        return accRect;
      }, getClientRectFromClippingAncestor(element, firstClippingAncestor, strategy));
      return {
        width: clippingRect.right - clippingRect.left,
        height: clippingRect.bottom - clippingRect.top,
        x: clippingRect.left,
        y: clippingRect.top
      };
    }
  
    const platform = {
      getClippingRect,
      convertOffsetParentRelativeRectToViewportRelativeRect,
      isElement,
      getDimensions,
      getOffsetParent,
      getDocumentElement,
      getElementRects: _ref => {
        let {
          reference,
          floating,
          strategy
        } = _ref;
        return {
          reference: getRectRelativeToOffsetParent(reference, getOffsetParent(floating), strategy),
          floating: { ...getDimensions(floating),
            x: 0,
            y: 0
          }
        };
      },
      getClientRects: element => Array.from(element.getClientRects()),
      isRTL: element => getComputedStyle$1(element).direction === 'rtl'
    };
  
    /**
     * Computes the `x` and `y` coordinates that will place the floating element
     * next to a reference element when it is given a certain CSS positioning
     * strategy.
     */
  
    const computePosition = (reference, floating, options) => computePosition$1(reference, floating, {
      platform,
      ...options
    });
  
    const useFloatingProps = buildProps({});
    const unrefReference = (elRef) => {
      if (!isClient)
        return;
      if (!elRef)
        return elRef;
      const unrefEl = unrefElement(elRef);
      if (unrefEl)
        return unrefEl;
      return vue.isRef(elRef) ? unrefEl : elRef;
    };
    const getPositionDataWithUnit = (record, key) => {
      const value = record == null ? void 0 : record[key];
      return isNil(value) ? "" : `${value}px`;
    };
    const useFloating = ({
      middleware,
      placement,
      strategy
    }) => {
      const referenceRef = vue.ref();
      const contentRef = vue.ref();
      const x = vue.ref();
      const y = vue.ref();
      const middlewareData = vue.ref({});
      const states = {
        x,
        y,
        placement,
        strategy,
        middlewareData
      };
      const update = async () => {
        if (!isClient)
          return;
        const referenceEl = unrefReference(referenceRef);
        const contentEl = unrefElement(contentRef);
        if (!referenceEl || !contentEl)
          return;
        const data = await computePosition(referenceEl, contentEl, {
          placement: vue.unref(placement),
          strategy: vue.unref(strategy),
          middleware: vue.unref(middleware)
        });
        keysOf(states).forEach((key) => {
          states[key].value = data[key];
        });
      };
      vue.onMounted(() => {
        vue.watchEffect(() => {
          update();
        });
      });
      return {
        ...states,
        update,
        referenceRef,
        contentRef
      };
    };
    const arrowMiddleware = ({
      arrowRef,
      padding
    }) => {
      return {
        name: "arrow",
        options: {
          element: arrowRef,
          padding
        },
        fn(args) {
          const arrowEl = vue.unref(arrowRef);
          if (!arrowEl)
            return {};
          return arrow({
            element: arrowEl,
            padding
          }).fn(args);
        }
      };
    };
  
    function useCursor(input) {
      const selectionRef = vue.ref();
      function recordCursor() {
        if (input.value == void 0)
          return;
        const { selectionStart, selectionEnd, value } = input.value;
        if (selectionStart == null || selectionEnd == null)
          return;
        const beforeTxt = value.slice(0, Math.max(0, selectionStart));
        const afterTxt = value.slice(Math.max(0, selectionEnd));
        selectionRef.value = {
          selectionStart,
          selectionEnd,
          value,
          beforeTxt,
          afterTxt
        };
      }
      function setCursor() {
        if (input.value == void 0 || selectionRef.value == void 0)
          return;
        const { value } = input.value;
        const { beforeTxt, afterTxt, selectionStart } = selectionRef.value;
        if (beforeTxt == void 0 || afterTxt == void 0 || selectionStart == void 0)
          return;
        let startPos = value.length;
        if (value.endsWith(afterTxt)) {
          startPos = value.length - afterTxt.length;
        } else if (value.startsWith(beforeTxt)) {
          startPos = beforeTxt.length;
        } else {
          const beforeLastChar = beforeTxt[selectionStart - 1];
          const newIndex = value.indexOf(beforeLastChar, selectionStart - 1);
          if (newIndex !== -1) {
            startPos = newIndex + 1;
          }
        }
        input.value.setSelectionRange(startPos, startPos);
      }
      return [recordCursor, setCursor];
    }
  
    const getOrderedChildren = (vm, childComponentName, children) => {
      const nodes = flattedChildren(vm.subTree).filter((n) => {
        var _a;
        return vue.isVNode(n) && ((_a = n.type) == null ? void 0 : _a.name) === childComponentName && !!n.component;
      });
      const uids = nodes.map((n) => n.component.uid);
      return uids.map((uid) => children[uid]).filter((p) => !!p);
    };
    const useOrderedChildren = (vm, childComponentName) => {
      const children = {};
      const orderedChildren = vue.shallowRef([]);
      const addChild = (child) => {
        children[child.uid] = child;
        orderedChildren.value = getOrderedChildren(vm, childComponentName, children);
      };
      const removeChild = (uid) => {
        delete children[uid];
        orderedChildren.value = orderedChildren.value.filter((children2) => children2.uid !== uid);
      };
      return {
        children: orderedChildren,
        addChild,
        removeChild
      };
    };
  
    const version$1 = "2.2.21";
  
    const makeInstaller = (components = []) => {
      const install = (app, options) => {
        if (app[INSTALLED_KEY])
          return;
        app[INSTALLED_KEY] = true;
        components.forEach((c) => app.use(c));
        if (options)
          provideGlobalConfig(options, app, true);
      };
      return {
        version: version$1,
        install
      };
    };
  
    const affixProps = buildProps({
      zIndex: {
        type: definePropType([Number, String]),
        default: 100
      },
      target: {
        type: String,
        default: ""
      },
      offset: {
        type: Number,
        default: 0
      },
      position: {
        type: String,
        values: ["top", "bottom"],
        default: "top"
      }
    });
    const affixEmits = {
      scroll: ({ scrollTop, fixed }) => isNumber(scrollTop) && isBoolean(fixed),
      [CHANGE_EVENT]: (fixed) => isBoolean(fixed)
    };
  
    var _export_sfc = (sfc, props) => {
      const target = sfc.__vccOpts || sfc;
      for (const [key, val] of props) {
        target[key] = val;
      }
      return target;
    };
  
    const COMPONENT_NAME$l = "ElAffix";
    const __default__$1w = vue.defineComponent({
      name: COMPONENT_NAME$l
    });
    const _sfc_main$2f = /* @__PURE__ */ vue.defineComponent({
      ...__default__$1w,
      props: affixProps,
      emits: affixEmits,
      setup(__props, { expose, emit }) {
        const props = __props;
        const ns = useNamespace("affix");
        const target = vue.shallowRef();
        const root = vue.shallowRef();
        const scrollContainer = vue.shallowRef();
        const { height: windowHeight } = useWindowSize();
        const {
          height: rootHeight,
          width: rootWidth,
          top: rootTop,
          bottom: rootBottom,
          update: updateRoot
        } = useElementBounding(root, { windowScroll: false });
        const targetRect = useElementBounding(target);
        const fixed = vue.ref(false);
        const scrollTop = vue.ref(0);
        const transform = vue.ref(0);
        const rootStyle = vue.computed(() => {
          return {
            height: fixed.value ? `${rootHeight.value}px` : "",
            width: fixed.value ? `${rootWidth.value}px` : ""
          };
        });
        const affixStyle = vue.computed(() => {
          if (!fixed.value)
            return {};
          const offset = props.offset ? addUnit(props.offset) : 0;
          return {
            height: `${rootHeight.value}px`,
            width: `${rootWidth.value}px`,
            top: props.position === "top" ? offset : "",
            bottom: props.position === "bottom" ? offset : "",
            transform: transform.value ? `translateY(${transform.value}px)` : "",
            zIndex: props.zIndex
          };
        });
        const update = () => {
          if (!scrollContainer.value)
            return;
          scrollTop.value = scrollContainer.value instanceof Window ? document.documentElement.scrollTop : scrollContainer.value.scrollTop || 0;
          if (props.position === "top") {
            if (props.target) {
              const difference = targetRect.bottom.value - props.offset - rootHeight.value;
              fixed.value = props.offset > rootTop.value && targetRect.bottom.value > 0;
              transform.value = difference < 0 ? difference : 0;
            } else {
              fixed.value = props.offset > rootTop.value;
            }
          } else if (props.target) {
            const difference = windowHeight.value - targetRect.top.value - props.offset - rootHeight.value;
            fixed.value = windowHeight.value - props.offset < rootBottom.value && windowHeight.value > targetRect.top.value;
            transform.value = difference < 0 ? -difference : 0;
          } else {
            fixed.value = windowHeight.value - props.offset < rootBottom.value;
          }
        };
        const handleScroll = () => {
          updateRoot();
          emit("scroll", {
            scrollTop: scrollTop.value,
            fixed: fixed.value
          });
        };
        vue.watch(fixed, (val) => emit("change", val));
        vue.onMounted(() => {
          var _a;
          if (props.target) {
            target.value = (_a = document.querySelector(props.target)) != null ? _a : void 0;
            if (!target.value)
              throwError(COMPONENT_NAME$l, `Target is not existed: ${props.target}`);
          } else {
            target.value = document.documentElement;
          }
          scrollContainer.value = getScrollContainer(root.value, true);
          updateRoot();
        });
        useEventListener(scrollContainer, "scroll", handleScroll);
        vue.watchEffect(update);
        expose({
          update,
          updateRoot
        });
        return (_ctx, _cache) => {
          return vue.openBlock(), vue.createElementBlock("div", {
            ref_key: "root",
            ref: root,
            class: vue.normalizeClass(vue.unref(ns).b()),
            style: vue.normalizeStyle(vue.unref(rootStyle))
          }, [
            vue.createElementVNode("div", {
              class: vue.normalizeClass({ [vue.unref(ns).m("fixed")]: fixed.value }),
              style: vue.normalizeStyle(vue.unref(affixStyle))
            }, [
              vue.renderSlot(_ctx.$slots, "default")
            ], 6)
          ], 6);
        };
      }
    });
    var Affix = /* @__PURE__ */ _export_sfc(_sfc_main$2f, [["__file", "affix.vue"]]);
  
    const ElAffix = withInstall(Affix);
  
    const iconProps = buildProps({
      size: {
        type: definePropType([Number, String])
      },
      color: {
        type: String
      }
    });
  
    const __default__$1v = vue.defineComponent({
      name: "ElIcon",
      inheritAttrs: false
    });
    const _sfc_main$2e = /* @__PURE__ */ vue.defineComponent({
      ...__default__$1v,
      props: iconProps,
      setup(__props) {
        const props = __props;
        const ns = useNamespace("icon");
        const style = vue.computed(() => {
          const { size, color } = props;
          if (!size && !color)
            return {};
          return {
            fontSize: isUndefined(size) ? void 0 : addUnit(size),
            "--color": color
          };
        });
        return (_ctx, _cache) => {
          return vue.openBlock(), vue.createElementBlock("i", vue.mergeProps({
            class: vue.unref(ns).b(),
            style: vue.unref(style)
          }, _ctx.$attrs), [
            vue.renderSlot(_ctx.$slots, "default")
          ], 16);
        };
      }
    });
    var Icon = /* @__PURE__ */ _export_sfc(_sfc_main$2e, [["__file", "icon.vue"]]);
  
    const ElIcon = withInstall(Icon);
  
    const alertEffects = ["light", "dark"];
    const alertProps = buildProps({
      title: {
        type: String,
        default: ""
      },
      description: {
        type: String,
        default: ""
      },
      type: {
        type: String,
        values: keysOf(TypeComponentsMap),
        default: "info"
      },
      closable: {
        type: Boolean,
        default: true
      },
      closeText: {
        type: String,
        default: ""
      },
      showIcon: Boolean,
      center: Boolean,
      effect: {
        type: String,
        values: alertEffects,
        default: "light"
      }
    });
    const alertEmits = {
      close: (evt) => evt instanceof MouseEvent
    };
  
    const __default__$1u = vue.defineComponent({
      name: "ElAlert"
    });
    const _sfc_main$2d = /* @__PURE__ */ vue.defineComponent({
      ...__default__$1u,
      props: alertProps,
      emits: alertEmits,
      setup(__props, { emit }) {
        const props = __props;
        const { Close } = TypeComponents;
        const slots = vue.useSlots();
        const ns = useNamespace("alert");
        const visible = vue.ref(true);
        const iconComponent = vue.computed(() => TypeComponentsMap[props.type]);
        const iconClass = vue.computed(() => [
          ns.e("icon"),
          { [ns.is("big")]: !!props.description || !!slots.default }
        ]);
        const isBoldTitle = vue.computed(() => {
          return { [ns.is("bold")]: props.description || slots.default };
        });
        const close = (evt) => {
          visible.value = false;
          emit("close", evt);
        };
        return (_ctx, _cache) => {
          return vue.openBlock(), vue.createBlock(vue.Transition, {
            name: vue.unref(ns).b("fade"),
            persisted: ""
          }, {
            default: vue.withCtx(() => [
              vue.withDirectives(vue.createElementVNode("div", {
                class: vue.normalizeClass([vue.unref(ns).b(), vue.unref(ns).m(_ctx.type), vue.unref(ns).is("center", _ctx.center), vue.unref(ns).is(_ctx.effect)]),
                role: "alert"
              }, [
                _ctx.showIcon && vue.unref(iconComponent) ? (vue.openBlock(), vue.createBlock(vue.unref(ElIcon), {
                  key: 0,
                  class: vue.normalizeClass(vue.unref(iconClass))
                }, {
                  default: vue.withCtx(() => [
                    (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(vue.unref(iconComponent))))
                  ]),
                  _: 1
                }, 8, ["class"])) : vue.createCommentVNode("v-if", true),
                vue.createElementVNode("div", {
                  class: vue.normalizeClass(vue.unref(ns).e("content"))
                }, [
                  _ctx.title || _ctx.$slots.title ? (vue.openBlock(), vue.createElementBlock("span", {
                    key: 0,
                    class: vue.normalizeClass([vue.unref(ns).e("title"), vue.unref(isBoldTitle)])
                  }, [
                    vue.renderSlot(_ctx.$slots, "title", {}, () => [
                      vue.createTextVNode(vue.toDisplayString(_ctx.title), 1)
                    ])
                  ], 2)) : vue.createCommentVNode("v-if", true),
                  _ctx.$slots.default || _ctx.description ? (vue.openBlock(), vue.createElementBlock("p", {
                    key: 1,
                    class: vue.normalizeClass(vue.unref(ns).e("description"))
                  }, [
                    vue.renderSlot(_ctx.$slots, "default", {}, () => [
                      vue.createTextVNode(vue.toDisplayString(_ctx.description), 1)
                    ])
                  ], 2)) : vue.createCommentVNode("v-if", true),
                  _ctx.closable ? (vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: 2 }, [
                    _ctx.closeText ? (vue.openBlock(), vue.createElementBlock("div", {
                      key: 0,
                      class: vue.normalizeClass([vue.unref(ns).e("close-btn"), vue.unref(ns).is("customed")]),
                      onClick: close
                    }, vue.toDisplayString(_ctx.closeText), 3)) : (vue.openBlock(), vue.createBlock(vue.unref(ElIcon), {
                      key: 1,
                      class: vue.normalizeClass(vue.unref(ns).e("close-btn")),
                      onClick: close
                    }, {
                      default: vue.withCtx(() => [
                        vue.createVNode(vue.unref(Close))
                      ]),
                      _: 1
                    }, 8, ["class"]))
                  ], 64)) : vue.createCommentVNode("v-if", true)
                ], 2)
              ], 2), [
                [vue.vShow, visible.value]
              ])
            ]),
            _: 3
          }, 8, ["name"]);
        };
      }
    });
    var Alert = /* @__PURE__ */ _export_sfc(_sfc_main$2d, [["__file", "alert.vue"]]);
  
    const ElAlert = withInstall(Alert);
  
    let hiddenTextarea = void 0;
    const HIDDEN_STYLE = `
    height:0 !important;
    visibility:hidden !important;
    overflow:hidden !important;
    position:absolute !important;
    z-index:-1000 !important;
    top:0 !important;
    right:0 !important;
  `;
    const CONTEXT_STYLE = [
      "letter-spacing",
      "line-height",
      "padding-top",
      "padding-bottom",
      "font-family",
      "font-weight",
      "font-size",
      "text-rendering",
      "text-transform",
      "width",
      "text-indent",
      "padding-left",
      "padding-right",
      "border-width",
      "box-sizing"
    ];
    function calculateNodeStyling(targetElement) {
      const style = window.getComputedStyle(targetElement);
      const boxSizing = style.getPropertyValue("box-sizing");
      const paddingSize = Number.parseFloat(style.getPropertyValue("padding-bottom")) + Number.parseFloat(style.getPropertyValue("padding-top"));
      const borderSize = Number.parseFloat(style.getPropertyValue("border-bottom-width")) + Number.parseFloat(style.getPropertyValue("border-top-width"));
      const contextStyle = CONTEXT_STYLE.map((name) => `${name}:${style.getPropertyValue(name)}`).join(";");
      return { contextStyle, paddingSize, borderSize, boxSizing };
    }
    function calcTextareaHeight(targetElement, minRows = 1, maxRows) {
      var _a;
      if (!hiddenTextarea) {
        hiddenTextarea = document.createElement("textarea");
        document.body.appendChild(hiddenTextarea);
      }
      const { paddingSize, borderSize, boxSizing, contextStyle } = calculateNodeStyling(targetElement);
      hiddenTextarea.setAttribute("style", `${contextStyle};${HIDDEN_STYLE}`);
      hiddenTextarea.value = targetElement.value || targetElement.placeholder || "";
      let height = hiddenTextarea.scrollHeight;
      const result = {};
      if (boxSizing === "border-box") {
        height = height + borderSize;
      } else if (boxSizing === "content-box") {
        height = height - paddingSize;
      }
      hiddenTextarea.value = "";
      const singleRowHeight = hiddenTextarea.scrollHeight - paddingSize;
      if (isNumber(minRows)) {
        let minHeight = singleRowHeight * minRows;
        if (boxSizing === "border-box") {
          minHeight = minHeight + paddingSize + borderSize;
        }
        height = Math.max(minHeight, height);
        result.minHeight = `${minHeight}px`;
      }
      if (isNumber(maxRows)) {
        let maxHeight = singleRowHeight * maxRows;
        if (boxSizing === "border-box") {
          maxHeight = maxHeight + paddingSize + borderSize;
        }
        height = Math.min(maxHeight, height);
      }
      result.height = `${height}px`;
      (_a = hiddenTextarea.parentNode) == null ? void 0 : _a.removeChild(hiddenTextarea);
      hiddenTextarea = void 0;
      return result;
    }
  
    const inputProps = buildProps({
      id: {
        type: String,
        default: void 0
      },
      size: useSizeProp,
      disabled: Boolean,
      modelValue: {
        type: definePropType([
          String,
          Number,
          Object
        ]),
        default: ""
      },
      type: {
        type: String,
        default: "text"
      },
      resize: {
        type: String,
        values: ["none", "both", "horizontal", "vertical"]
      },
      autosize: {
        type: definePropType([Boolean, Object]),
        default: false
      },
      autocomplete: {
        type: String,
        default: "off"
      },
      formatter: {
        type: Function
      },
      parser: {
        type: Function
      },
      placeholder: {
        type: String
      },
      form: {
        type: String
      },
      readonly: {
        type: Boolean,
        default: false
      },
      clearable: {
        type: Boolean,
        default: false
      },
      showPassword: {
        type: Boolean,
        default: false
      },
      showWordLimit: {
        type: Boolean,
        default: false
      },
      suffixIcon: {
        type: iconPropType
      },
      prefixIcon: {
        type: iconPropType
      },
      containerRole: {
        type: String,
        default: void 0
      },
      label: {
        type: String,
        default: void 0
      },
      tabindex: {
        type: [String, Number],
        default: 0
      },
      validateEvent: {
        type: Boolean,
        default: true
      },
      inputStyle: {
        type: definePropType([Object, Array, String]),
        default: () => mutable({})
      }
    });
    const inputEmits = {
      [UPDATE_MODEL_EVENT]: (value) => isString(value),
      input: (value) => isString(value),
      change: (value) => isString(value),
      focus: (evt) => evt instanceof FocusEvent,
      blur: (evt) => evt instanceof FocusEvent,
      clear: () => true,
      mouseleave: (evt) => evt instanceof MouseEvent,
      mouseenter: (evt) => evt instanceof MouseEvent,
      keydown: (evt) => evt instanceof Event,
      compositionstart: (evt) => evt instanceof CompositionEvent,
      compositionupdate: (evt) => evt instanceof CompositionEvent,
      compositionend: (evt) => evt instanceof CompositionEvent
    };
  
    const _hoisted_1$13 = ["role"];
    const _hoisted_2$G = ["id", "type", "disabled", "formatter", "parser", "readonly", "autocomplete", "tabindex", "aria-label", "placeholder", "form"];
    const _hoisted_3$k = ["id", "tabindex", "disabled", "readonly", "autocomplete", "aria-label", "placeholder", "form"];
    const __default__$1t = vue.defineComponent({
      name: "ElInput",
      inheritAttrs: false
    });
    const _sfc_main$2c = /* @__PURE__ */ vue.defineComponent({
      ...__default__$1t,
      props: inputProps,
      emits: inputEmits,
      setup(__props, { expose, emit }) {
        const props = __props;
        const rawAttrs = vue.useAttrs();
        const slots = vue.useSlots();
        const containerAttrs = vue.computed(() => {
          const comboBoxAttrs = {};
          if (props.containerRole === "combobox") {
            comboBoxAttrs["aria-haspopup"] = rawAttrs["aria-haspopup"];
            comboBoxAttrs["aria-owns"] = rawAttrs["aria-owns"];
            comboBoxAttrs["aria-expanded"] = rawAttrs["aria-expanded"];
          }
          return comboBoxAttrs;
        });
        const attrs = useAttrs({
          excludeKeys: vue.computed(() => {
            return Object.keys(containerAttrs.value);
          })
        });
        const { form, formItem } = useFormItem();
        const { inputId } = useFormItemInputId(props, {
          formItemContext: formItem
        });
        const inputSize = useSize();
        const inputDisabled = useDisabled();
        const nsInput = useNamespace("input");
        const nsTextarea = useNamespace("textarea");
        const input = vue.shallowRef();
        const textarea = vue.shallowRef();
        const focused = vue.ref(false);
        const hovering = vue.ref(false);
        const isComposing = vue.ref(false);
        const passwordVisible = vue.ref(false);
        const countStyle = vue.ref();
        const textareaCalcStyle = vue.shallowRef(props.inputStyle);
        const _ref = vue.computed(() => input.value || textarea.value);
        const needStatusIcon = vue.computed(() => {
          var _a;
          return (_a = form == null ? void 0 : form.statusIcon) != null ? _a : false;
        });
        const validateState = vue.computed(() => (formItem == null ? void 0 : formItem.validateState) || "");
        const validateIcon = vue.computed(() => validateState.value && ValidateComponentsMap[validateState.value]);
        const passwordIcon = vue.computed(() => passwordVisible.value ? view_default : hide_default);
        const containerStyle = vue.computed(() => [
          rawAttrs.style,
          props.inputStyle
        ]);
        const textareaStyle = vue.computed(() => [
          props.inputStyle,
          textareaCalcStyle.value,
          { resize: props.resize }
        ]);
        const nativeInputValue = vue.computed(() => isNil(props.modelValue) ? "" : String(props.modelValue));
        const showClear = vue.computed(() => props.clearable && !inputDisabled.value && !props.readonly && !!nativeInputValue.value && (focused.value || hovering.value));
        const showPwdVisible = vue.computed(() => props.showPassword && !inputDisabled.value && !props.readonly && !!nativeInputValue.value && (!!nativeInputValue.value || focused.value));
        const isWordLimitVisible = vue.computed(() => props.showWordLimit && !!attrs.value.maxlength && (props.type === "text" || props.type === "textarea") && !inputDisabled.value && !props.readonly && !props.showPassword);
        const textLength = vue.computed(() => Array.from(nativeInputValue.value).length);
        const inputExceed = vue.computed(() => !!isWordLimitVisible.value && textLength.value > Number(attrs.value.maxlength));
        const suffixVisible = vue.computed(() => !!slots.suffix || !!props.suffixIcon || showClear.value || props.showPassword || isWordLimitVisible.value || !!validateState.value && needStatusIcon.value);
        const [recordCursor, setCursor] = useCursor(input);
        useResizeObserver(textarea, (entries) => {
          if (!isWordLimitVisible.value || props.resize !== "both")
            return;
          const entry = entries[0];
          const { width } = entry.contentRect;
          countStyle.value = {
            right: `calc(100% - ${width + 15 + 6}px)`
          };
        });
        const resizeTextarea = () => {
          const { type, autosize } = props;
          if (!isClient || type !== "textarea")
            return;
          if (autosize) {
            const minRows = isObject$1(autosize) ? autosize.minRows : void 0;
            const maxRows = isObject$1(autosize) ? autosize.maxRows : void 0;
            textareaCalcStyle.value = {
              ...calcTextareaHeight(textarea.value, minRows, maxRows)
            };
          } else {
            textareaCalcStyle.value = {
              minHeight: calcTextareaHeight(textarea.value).minHeight
            };
          }
        };
        const setNativeInputValue = () => {
          const input2 = _ref.value;
          if (!input2 || input2.value === nativeInputValue.value)
            return;
          input2.value = nativeInputValue.value;
        };
        const handleInput = async (event) => {
          recordCursor();
          let { value } = event.target;
          if (props.formatter) {
            value = props.parser ? props.parser(value) : value;
            value = props.formatter(value);
          }
          if (isComposing.value)
            return;
          if (value === nativeInputValue.value) {
            setNativeInputValue();
            return;
          }
          emit(UPDATE_MODEL_EVENT, value);
          emit("input", value);
          await vue.nextTick();
          setNativeInputValue();
          setCursor();
        };
        const handleChange = (event) => {
          emit("change", event.target.value);
        };
        const handleCompositionStart = (event) => {
          emit("compositionstart", event);
          isComposing.value = true;
        };
        const handleCompositionUpdate = (event) => {
          var _a;
          emit("compositionupdate", event);
          const text = (_a = event.target) == null ? void 0 : _a.value;
          const lastCharacter = text[text.length - 1] || "";
          isComposing.value = !isKorean(lastCharacter);
        };
        const handleCompositionEnd = (event) => {
          emit("compositionend", event);
          if (isComposing.value) {
            isComposing.value = false;
            handleInput(event);
          }
        };
        const handlePasswordVisible = () => {
          passwordVisible.value = !passwordVisible.value;
          focus();
        };
        const focus = async () => {
          var _a;
          await vue.nextTick();
          (_a = _ref.value) == null ? void 0 : _a.focus();
        };
        const blur = () => {
          var _a;
          return (_a = _ref.value) == null ? void 0 : _a.blur();
        };
        const handleFocus = (event) => {
          focused.value = true;
          emit("focus", event);
        };
        const handleBlur = (event) => {
          var _a;
          focused.value = false;
          emit("blur", event);
          if (props.validateEvent) {
            (_a = formItem == null ? void 0 : formItem.validate) == null ? void 0 : _a.call(formItem, "blur").catch((err) => debugWarn());
          }
        };
        const handleMouseLeave = (evt) => {
          hovering.value = false;
          emit("mouseleave", evt);
        };
        const handleMouseEnter = (evt) => {
          hovering.value = true;
          emit("mouseenter", evt);
        };
        const handleKeydown = (evt) => {
          emit("keydown", evt);
        };
        const select = () => {
          var _a;
          (_a = _ref.value) == null ? void 0 : _a.select();
        };
        const clear = () => {
          emit(UPDATE_MODEL_EVENT, "");
          emit("change", "");
          emit("clear");
          emit("input", "");
        };
        vue.watch(() => props.modelValue, () => {
          var _a;
          vue.nextTick(() => resizeTextarea());
          if (props.validateEvent) {
            (_a = formItem == null ? void 0 : formItem.validate) == null ? void 0 : _a.call(formItem, "change").catch((err) => debugWarn());
          }
        });
        vue.watch(nativeInputValue, () => setNativeInputValue());
        vue.watch(() => props.type, async () => {
          await vue.nextTick();
          setNativeInputValue();
          resizeTextarea();
        });
        vue.onMounted(() => {
          if (!props.formatter && props.parser) ;
          setNativeInputValue();
          vue.nextTick(resizeTextarea);
        });
        expose({
          input,
          textarea,
          ref: _ref,
          textareaStyle,
          autosize: vue.toRef(props, "autosize"),
          focus,
          blur,
          select,
          clear,
          resizeTextarea
        });
        return (_ctx, _cache) => {
          return vue.withDirectives((vue.openBlock(), vue.createElementBlock("div", vue.mergeProps(vue.unref(containerAttrs), {
            class: [
              _ctx.type === "textarea" ? vue.unref(nsTextarea).b() : vue.unref(nsInput).b(),
              vue.unref(nsInput).m(vue.unref(inputSize)),
              vue.unref(nsInput).is("disabled", vue.unref(inputDisabled)),
              vue.unref(nsInput).is("exceed", vue.unref(inputExceed)),
              {
                [vue.unref(nsInput).b("group")]: _ctx.$slots.prepend || _ctx.$slots.append,
                [vue.unref(nsInput).bm("group", "append")]: _ctx.$slots.append,
                [vue.unref(nsInput).bm("group", "prepend")]: _ctx.$slots.prepend,
                [vue.unref(nsInput).m("prefix")]: _ctx.$slots.prefix || _ctx.prefixIcon,
                [vue.unref(nsInput).m("suffix")]: _ctx.$slots.suffix || _ctx.suffixIcon || _ctx.clearable || _ctx.showPassword,
                [vue.unref(nsInput).bm("suffix", "password-clear")]: vue.unref(showClear) && vue.unref(showPwdVisible)
              },
              _ctx.$attrs.class
            ],
            style: vue.unref(containerStyle),
            role: _ctx.containerRole,
            onMouseenter: handleMouseEnter,
            onMouseleave: handleMouseLeave
          }), [
            vue.createCommentVNode(" input "),
            _ctx.type !== "textarea" ? (vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: 0 }, [
              vue.createCommentVNode(" prepend slot "),
              _ctx.$slots.prepend ? (vue.openBlock(), vue.createElementBlock("div", {
                key: 0,
                class: vue.normalizeClass(vue.unref(nsInput).be("group", "prepend"))
              }, [
                vue.renderSlot(_ctx.$slots, "prepend")
              ], 2)) : vue.createCommentVNode("v-if", true),
              vue.createElementVNode("div", {
                class: vue.normalizeClass([vue.unref(nsInput).e("wrapper"), vue.unref(nsInput).is("focus", focused.value)])
              }, [
                vue.createCommentVNode(" prefix slot "),
                _ctx.$slots.prefix || _ctx.prefixIcon ? (vue.openBlock(), vue.createElementBlock("span", {
                  key: 0,
                  class: vue.normalizeClass(vue.unref(nsInput).e("prefix"))
                }, [
                  vue.createElementVNode("span", {
                    class: vue.normalizeClass(vue.unref(nsInput).e("prefix-inner"))
                  }, [
                    vue.renderSlot(_ctx.$slots, "prefix"),
                    _ctx.prefixIcon ? (vue.openBlock(), vue.createBlock(vue.unref(ElIcon), {
                      key: 0,
                      class: vue.normalizeClass(vue.unref(nsInput).e("icon"))
                    }, {
                      default: vue.withCtx(() => [
                        (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(_ctx.prefixIcon)))
                      ]),
                      _: 1
                    }, 8, ["class"])) : vue.createCommentVNode("v-if", true)
                  ], 2)
                ], 2)) : vue.createCommentVNode("v-if", true),
                vue.createElementVNode("input", vue.mergeProps({
                  id: vue.unref(inputId),
                  ref_key: "input",
                  ref: input,
                  class: vue.unref(nsInput).e("inner")
                }, vue.unref(attrs), {
                  type: _ctx.showPassword ? passwordVisible.value ? "text" : "password" : _ctx.type,
                  disabled: vue.unref(inputDisabled),
                  formatter: _ctx.formatter,
                  parser: _ctx.parser,
                  readonly: _ctx.readonly,
                  autocomplete: _ctx.autocomplete,
                  tabindex: _ctx.tabindex,
                  "aria-label": _ctx.label,
                  placeholder: _ctx.placeholder,
                  style: _ctx.inputStyle,
                  form: props.form,
                  onCompositionstart: handleCompositionStart,
                  onCompositionupdate: handleCompositionUpdate,
                  onCompositionend: handleCompositionEnd,
                  onInput: handleInput,
                  onFocus: handleFocus,
                  onBlur: handleBlur,
                  onChange: handleChange,
                  onKeydown: handleKeydown
                }), null, 16, _hoisted_2$G),
                vue.createCommentVNode(" suffix slot "),
                vue.unref(suffixVisible) ? (vue.openBlock(), vue.createElementBlock("span", {
                  key: 1,
                  class: vue.normalizeClass(vue.unref(nsInput).e("suffix"))
                }, [
                  vue.createElementVNode("span", {
                    class: vue.normalizeClass(vue.unref(nsInput).e("suffix-inner"))
                  }, [
                    !vue.unref(showClear) || !vue.unref(showPwdVisible) || !vue.unref(isWordLimitVisible) ? (vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: 0 }, [
                      vue.renderSlot(_ctx.$slots, "suffix"),
                      _ctx.suffixIcon ? (vue.openBlock(), vue.createBlock(vue.unref(ElIcon), {
                        key: 0,
                        class: vue.normalizeClass(vue.unref(nsInput).e("icon"))
                      }, {
                        default: vue.withCtx(() => [
                          (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(_ctx.suffixIcon)))
                        ]),
                        _: 1
                      }, 8, ["class"])) : vue.createCommentVNode("v-if", true)
                    ], 64)) : vue.createCommentVNode("v-if", true),
                    vue.unref(showClear) ? (vue.openBlock(), vue.createBlock(vue.unref(ElIcon), {
                      key: 1,
                      class: vue.normalizeClass([vue.unref(nsInput).e("icon"), vue.unref(nsInput).e("clear")]),
                      onMousedown: vue.withModifiers(vue.unref(NOOP), ["prevent"]),
                      onClick: clear
                    }, {
                      default: vue.withCtx(() => [
                        vue.createVNode(vue.unref(circle_close_default))
                      ]),
                      _: 1
                    }, 8, ["class", "onMousedown"])) : vue.createCommentVNode("v-if", true),
                    vue.unref(showPwdVisible) ? (vue.openBlock(), vue.createBlock(vue.unref(ElIcon), {
                      key: 2,
                      class: vue.normalizeClass([vue.unref(nsInput).e("icon"), vue.unref(nsInput).e("password")]),
                      onClick: handlePasswordVisible
                    }, {
                      default: vue.withCtx(() => [
                        (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(vue.unref(passwordIcon))))
                      ]),
                      _: 1
                    }, 8, ["class"])) : vue.createCommentVNode("v-if", true),
                    vue.unref(isWordLimitVisible) ? (vue.openBlock(), vue.createElementBlock("span", {
                      key: 3,
                      class: vue.normalizeClass(vue.unref(nsInput).e("count"))
                    }, [
                      vue.createElementVNode("span", {
                        class: vue.normalizeClass(vue.unref(nsInput).e("count-inner"))
                      }, vue.toDisplayString(vue.unref(textLength)) + " / " + vue.toDisplayString(vue.unref(attrs).maxlength), 3)
                    ], 2)) : vue.createCommentVNode("v-if", true),
                    vue.unref(validateState) && vue.unref(validateIcon) && vue.unref(needStatusIcon) ? (vue.openBlock(), vue.createBlock(vue.unref(ElIcon), {
                      key: 4,
                      class: vue.normalizeClass([
                        vue.unref(nsInput).e("icon"),
                        vue.unref(nsInput).e("validateIcon"),
                        vue.unref(nsInput).is("loading", vue.unref(validateState) === "validating")
                      ])
                    }, {
                      default: vue.withCtx(() => [
                        (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(vue.unref(validateIcon))))
                      ]),
                      _: 1
                    }, 8, ["class"])) : vue.createCommentVNode("v-if", true)
                  ], 2)
                ], 2)) : vue.createCommentVNode("v-if", true)
              ], 2),
              vue.createCommentVNode(" append slot "),
              _ctx.$slots.append ? (vue.openBlock(), vue.createElementBlock("div", {
                key: 1,
                class: vue.normalizeClass(vue.unref(nsInput).be("group", "append"))
              }, [
                vue.renderSlot(_ctx.$slots, "append")
              ], 2)) : vue.createCommentVNode("v-if", true)
            ], 64)) : (vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: 1 }, [
              vue.createCommentVNode(" textarea "),
              vue.createElementVNode("textarea", vue.mergeProps({
                id: vue.unref(inputId),
                ref_key: "textarea",
                ref: textarea,
                class: vue.unref(nsTextarea).e("inner")
              }, vue.unref(attrs), {
                tabindex: _ctx.tabindex,
                disabled: vue.unref(inputDisabled),
                readonly: _ctx.readonly,
                autocomplete: _ctx.autocomplete,
                style: vue.unref(textareaStyle),
                "aria-label": _ctx.label,
                placeholder: _ctx.placeholder,
                form: props.form,
                onCompositionstart: handleCompositionStart,
                onCompositionupdate: handleCompositionUpdate,
                onCompositionend: handleCompositionEnd,
                onInput: handleInput,
                onFocus: handleFocus,
                onBlur: handleBlur,
                onChange: handleChange,
                onKeydown: handleKeydown
              }), null, 16, _hoisted_3$k),
              vue.unref(isWordLimitVisible) ? (vue.openBlock(), vue.createElementBlock("span", {
                key: 0,
                style: vue.normalizeStyle(countStyle.value),
                class: vue.normalizeClass(vue.unref(nsInput).e("count"))
              }, vue.toDisplayString(vue.unref(textLength)) + " / " + vue.toDisplayString(vue.unref(attrs).maxlength), 7)) : vue.createCommentVNode("v-if", true)
            ], 64))
          ], 16, _hoisted_1$13)), [
            [vue.vShow, _ctx.type !== "hidden"]
          ]);
        };
      }
    });
    var Input = /* @__PURE__ */ _export_sfc(_sfc_main$2c, [["__file", "input.vue"]]);
  
    const ElInput = withInstall(Input);
  
    const GAP = 4;
    const BAR_MAP = {
      vertical: {
        offset: "offsetHeight",
        scroll: "scrollTop",
        scrollSize: "scrollHeight",
        size: "height",
        key: "vertical",
        axis: "Y",
        client: "clientY",
        direction: "top"
      },
      horizontal: {
        offset: "offsetWidth",
        scroll: "scrollLeft",
        scrollSize: "scrollWidth",
        size: "width",
        key: "horizontal",
        axis: "X",
        client: "clientX",
        direction: "left"
      }
    };
    const renderThumbStyle$1 = ({
      move,
      size,
      bar
    }) => ({
      [bar.size]: size,
      transform: `translate${bar.axis}(${move}%)`
    });
  
    const thumbProps = buildProps({
      vertical: Boolean,
      size: String,
      move: Number,
      ratio: {
        type: Number,
        required: true
      },
      always: Boolean
    });
  
    const COMPONENT_NAME$k = "Thumb";
    const _sfc_main$2b = /* @__PURE__ */ vue.defineComponent({
      __name: "thumb",
      props: thumbProps,
      setup(__props) {
        const props = __props;
        const scrollbar = vue.inject(scrollbarContextKey);
        const ns = useNamespace("scrollbar");
        if (!scrollbar)
          throwError(COMPONENT_NAME$k, "can not inject scrollbar context");
        const instance = vue.ref();
        const thumb = vue.ref();
        const thumbState = vue.ref({});
        const visible = vue.ref(false);
        let cursorDown = false;
        let cursorLeave = false;
        let originalOnSelectStart = isClient ? document.onselectstart : null;
        const bar = vue.computed(() => BAR_MAP[props.vertical ? "vertical" : "horizontal"]);
        const thumbStyle = vue.computed(() => renderThumbStyle$1({
          size: props.size,
          move: props.move,
          bar: bar.value
        }));
        const offsetRatio = vue.computed(() => instance.value[bar.value.offset] ** 2 / scrollbar.wrapElement[bar.value.scrollSize] / props.ratio / thumb.value[bar.value.offset]);
        const clickThumbHandler = (e) => {
          var _a;
          e.stopPropagation();
          if (e.ctrlKey || [1, 2].includes(e.button))
            return;
          (_a = window.getSelection()) == null ? void 0 : _a.removeAllRanges();
          startDrag(e);
          const el = e.currentTarget;
          if (!el)
            return;
          thumbState.value[bar.value.axis] = el[bar.value.offset] - (e[bar.value.client] - el.getBoundingClientRect()[bar.value.direction]);
        };
        const clickTrackHandler = (e) => {
          if (!thumb.value || !instance.value || !scrollbar.wrapElement)
            return;
          const offset = Math.abs(e.target.getBoundingClientRect()[bar.value.direction] - e[bar.value.client]);
          const thumbHalf = thumb.value[bar.value.offset] / 2;
          const thumbPositionPercentage = (offset - thumbHalf) * 100 * offsetRatio.value / instance.value[bar.value.offset];
          scrollbar.wrapElement[bar.value.scroll] = thumbPositionPercentage * scrollbar.wrapElement[bar.value.scrollSize] / 100;
        };
        const startDrag = (e) => {
          e.stopImmediatePropagation();
          cursorDown = true;
          document.addEventListener("mousemove", mouseMoveDocumentHandler);
          document.addEventListener("mouseup", mouseUpDocumentHandler);
          originalOnSelectStart = document.onselectstart;
          document.onselectstart = () => false;
        };
        const mouseMoveDocumentHandler = (e) => {
          if (!instance.value || !thumb.value)
            return;
          if (cursorDown === false)
            return;
          const prevPage = thumbState.value[bar.value.axis];
          if (!prevPage)
            return;
          const offset = (instance.value.getBoundingClientRect()[bar.value.direction] - e[bar.value.client]) * -1;
          const thumbClickPosition = thumb.value[bar.value.offset] - prevPage;
          const thumbPositionPercentage = (offset - thumbClickPosition) * 100 * offsetRatio.value / instance.value[bar.value.offset];
          scrollbar.wrapElement[bar.value.scroll] = thumbPositionPercentage * scrollbar.wrapElement[bar.value.scrollSize] / 100;
        };
        const mouseUpDocumentHandler = () => {
          cursorDown = false;
          thumbState.value[bar.value.axis] = 0;
          document.removeEventListener("mousemove", mouseMoveDocumentHandler);
          document.removeEventListener("mouseup", mouseUpDocumentHandler);
          restoreOnselectstart();
          if (cursorLeave)
            visible.value = false;
        };
        const mouseMoveScrollbarHandler = () => {
          cursorLeave = false;
          visible.value = !!props.size;
        };
        const mouseLeaveScrollbarHandler = () => {
          cursorLeave = true;
          visible.value = cursorDown;
        };
        vue.onBeforeUnmount(() => {
          restoreOnselectstart();
          document.removeEventListener("mouseup", mouseUpDocumentHandler);
        });
        const restoreOnselectstart = () => {
          if (document.onselectstart !== originalOnSelectStart)
            document.onselectstart = originalOnSelectStart;
        };
        useEventListener(vue.toRef(scrollbar, "scrollbarElement"), "mousemove", mouseMoveScrollbarHandler);
        useEventListener(vue.toRef(scrollbar, "scrollbarElement"), "mouseleave", mouseLeaveScrollbarHandler);
        return (_ctx, _cache) => {
          return vue.openBlock(), vue.createBlock(vue.Transition, {
            name: vue.unref(ns).b("fade"),
            persisted: ""
          }, {
            default: vue.withCtx(() => [
              vue.withDirectives(vue.createElementVNode("div", {
                ref_key: "instance",
                ref: instance,
                class: vue.normalizeClass([vue.unref(ns).e("bar"), vue.unref(ns).is(vue.unref(bar).key)]),
                onMousedown: clickTrackHandler
              }, [
                vue.createElementVNode("div", {
                  ref_key: "thumb",
                  ref: thumb,
                  class: vue.normalizeClass(vue.unref(ns).e("thumb")),
                  style: vue.normalizeStyle(vue.unref(thumbStyle)),
                  onMousedown: clickThumbHandler
                }, null, 38)
              ], 34), [
                [vue.vShow, _ctx.always || visible.value]
              ])
            ]),
            _: 1
          }, 8, ["name"]);
        };
      }
    });
    var Thumb = /* @__PURE__ */ _export_sfc(_sfc_main$2b, [["__file", "thumb.vue"]]);
  
    const barProps = buildProps({
      always: {
        type: Boolean,
        default: true
      },
      width: String,
      height: String,
      ratioX: {
        type: Number,
        default: 1
      },
      ratioY: {
        type: Number,
        default: 1
      }
    });
  
    const _sfc_main$2a = /* @__PURE__ */ vue.defineComponent({
      __name: "bar",
      props: barProps,
      setup(__props, { expose }) {
        const props = __props;
        const moveX = vue.ref(0);
        const moveY = vue.ref(0);
        const handleScroll = (wrap) => {
          if (wrap) {
            const offsetHeight = wrap.offsetHeight - GAP;
            const offsetWidth = wrap.offsetWidth - GAP;
            moveY.value = wrap.scrollTop * 100 / offsetHeight * props.ratioY;
            moveX.value = wrap.scrollLeft * 100 / offsetWidth * props.ratioX;
          }
        };
        expose({
          handleScroll
        });
        return (_ctx, _cache) => {
          return vue.openBlock(), vue.createElementBlock(vue.Fragment, null, [
            vue.createVNode(Thumb, {
              move: moveX.value,
              ratio: _ctx.ratioX,
              size: _ctx.width,
              always: _ctx.always
            }, null, 8, ["move", "ratio", "size", "always"]),
            vue.createVNode(Thumb, {
              move: moveY.value,
              ratio: _ctx.ratioY,
              size: _ctx.height,
              vertical: "",
              always: _ctx.always
            }, null, 8, ["move", "ratio", "size", "always"])
          ], 64);
        };
      }
    });
    var Bar = /* @__PURE__ */ _export_sfc(_sfc_main$2a, [["__file", "bar.vue"]]);
  
    const scrollbarProps = buildProps({
      height: {
        type: [String, Number],
        default: ""
      },
      maxHeight: {
        type: [String, Number],
        default: ""
      },
      native: Boolean,
      wrapStyle: {
        type: definePropType([String, Object, Array]),
        default: ""
      },
      wrapClass: {
        type: [String, Array],
        default: ""
      },
      viewClass: {
        type: [String, Array],
        default: ""
      },
      viewStyle: {
        type: [String, Array, Object],
        default: ""
      },
      noresize: Boolean,
      tag: {
        type: String,
        default: "div"
      },
      always: Boolean,
      minSize: {
        type: Number,
        default: 20
      }
    });
    const scrollbarEmits = {
      scroll: ({
        scrollTop,
        scrollLeft
      }) => [scrollTop, scrollLeft].every(isNumber)
    };
  
    const __default__$1s = vue.defineComponent({
      name: "ElScrollbar"
    });
    const _sfc_main$29 = /* @__PURE__ */ vue.defineComponent({
      ...__default__$1s,
      props: scrollbarProps,
      emits: scrollbarEmits,
      setup(__props, { expose, emit }) {
        const props = __props;
        const ns = useNamespace("scrollbar");
        let stopResizeObserver = void 0;
        let stopResizeListener = void 0;
        const scrollbar$ = vue.ref();
        const wrap$ = vue.ref();
        const resize$ = vue.ref();
        const sizeWidth = vue.ref("0");
        const sizeHeight = vue.ref("0");
        const barRef = vue.ref();
        const ratioY = vue.ref(1);
        const ratioX = vue.ref(1);
        const style = vue.computed(() => {
          const style2 = {};
          if (props.height)
            style2.height = addUnit(props.height);
          if (props.maxHeight)
            style2.maxHeight = addUnit(props.maxHeight);
          return [props.wrapStyle, style2];
        });
        const handleScroll = () => {
          var _a;
          if (wrap$.value) {
            (_a = barRef.value) == null ? void 0 : _a.handleScroll(wrap$.value);
            emit("scroll", {
              scrollTop: wrap$.value.scrollTop,
              scrollLeft: wrap$.value.scrollLeft
            });
          }
        };
        function scrollTo(arg1, arg2) {
          if (isObject$1(arg1)) {
            wrap$.value.scrollTo(arg1);
          } else if (isNumber(arg1) && isNumber(arg2)) {
            wrap$.value.scrollTo(arg1, arg2);
          }
        }
        const setScrollTop = (value) => {
          if (!isNumber(value)) {
            return;
          }
          wrap$.value.scrollTop = value;
        };
        const setScrollLeft = (value) => {
          if (!isNumber(value)) {
            return;
          }
          wrap$.value.scrollLeft = value;
        };
        const update = () => {
          if (!wrap$.value)
            return;
          const offsetHeight = wrap$.value.offsetHeight - GAP;
          const offsetWidth = wrap$.value.offsetWidth - GAP;
          const originalHeight = offsetHeight ** 2 / wrap$.value.scrollHeight;
          const originalWidth = offsetWidth ** 2 / wrap$.value.scrollWidth;
          const height = Math.max(originalHeight, props.minSize);
          const width = Math.max(originalWidth, props.minSize);
          ratioY.value = originalHeight / (offsetHeight - originalHeight) / (height / (offsetHeight - height));
          ratioX.value = originalWidth / (offsetWidth - originalWidth) / (width / (offsetWidth - width));
          sizeHeight.value = height + GAP < offsetHeight ? `${height}px` : "";
          sizeWidth.value = width + GAP < offsetWidth ? `${width}px` : "";
        };
        vue.watch(() => props.noresize, (noresize) => {
          if (noresize) {
            stopResizeObserver == null ? void 0 : stopResizeObserver();
            stopResizeListener == null ? void 0 : stopResizeListener();
          } else {
            ({ stop: stopResizeObserver } = useResizeObserver(resize$, update));
            stopResizeListener = useEventListener("resize", update);
          }
        }, { immediate: true });
        vue.watch(() => [props.maxHeight, props.height], () => {
          if (!props.native)
            vue.nextTick(() => {
              var _a;
              update();
              if (wrap$.value) {
                (_a = barRef.value) == null ? void 0 : _a.handleScroll(wrap$.value);
              }
            });
        });
        vue.provide(scrollbarContextKey, vue.reactive({
          scrollbarElement: scrollbar$,
          wrapElement: wrap$
        }));
        vue.onMounted(() => {
          if (!props.native)
            vue.nextTick(() => {
              update();
            });
        });
        vue.onUpdated(() => update());
        expose({
          wrap$,
          update,
          scrollTo,
          setScrollTop,
          setScrollLeft,
          handleScroll
        });
        return (_ctx, _cache) => {
          return vue.openBlock(), vue.createElementBlock("div", {
            ref_key: "scrollbar$",
            ref: scrollbar$,
            class: vue.normalizeClass(vue.unref(ns).b())
          }, [
            vue.createElementVNode("div", {
              ref_key: "wrap$",
              ref: wrap$,
              class: vue.normalizeClass([
                _ctx.wrapClass,
                vue.unref(ns).e("wrap"),
                { [vue.unref(ns).em("wrap", "hidden-default")]: !_ctx.native }
              ]),
              style: vue.normalizeStyle(vue.unref(style)),
              onScroll: handleScroll
            }, [
              (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(_ctx.tag), {
                ref_key: "resize$",
                ref: resize$,
                class: vue.normalizeClass([vue.unref(ns).e("view"), _ctx.viewClass]),
                style: vue.normalizeStyle(_ctx.viewStyle)
              }, {
                default: vue.withCtx(() => [
                  vue.renderSlot(_ctx.$slots, "default")
                ]),
                _: 3
              }, 8, ["class", "style"]))
            ], 38),
            !_ctx.native ? (vue.openBlock(), vue.createBlock(Bar, {
              key: 0,
              ref_key: "barRef",
              ref: barRef,
              height: sizeHeight.value,
              width: sizeWidth.value,
              always: _ctx.always,
              "ratio-x": ratioX.value,
              "ratio-y": ratioY.value
            }, null, 8, ["height", "width", "always", "ratio-x", "ratio-y"])) : vue.createCommentVNode("v-if", true)
          ], 2);
        };
      }
    });
    var Scrollbar$1 = /* @__PURE__ */ _export_sfc(_sfc_main$29, [["__file", "scrollbar.vue"]]);
  
    const ElScrollbar = withInstall(Scrollbar$1);
  
    const Effect = {
      LIGHT: "light",
      DARK: "dark"
    };
    const roleTypes = [
      "dialog",
      "grid",
      "group",
      "listbox",
      "menu",
      "navigation",
      "tooltip",
      "tree"
    ];
    const popperProps = buildProps({
      role: {
        type: String,
        values: roleTypes,
        default: "tooltip"
      }
    });
    const usePopperProps = popperProps;
  
    const __default__$1r = vue.defineComponent({
      name: "ElPopperRoot",
      inheritAttrs: false
    });
    const _sfc_main$28 = /* @__PURE__ */ vue.defineComponent({
      ...__default__$1r,
      props: popperProps,
      setup(__props, { expose }) {
        const props = __props;
        const triggerRef = vue.ref();
        const popperInstanceRef = vue.ref();
        const contentRef = vue.ref();
        const referenceRef = vue.ref();
        const role = vue.computed(() => props.role);
        const popperProvides = {
          triggerRef,
          popperInstanceRef,
          contentRef,
          referenceRef,
          role
        };
        expose(popperProvides);
        vue.provide(POPPER_INJECTION_KEY, popperProvides);
        return (_ctx, _cache) => {
          return vue.renderSlot(_ctx.$slots, "default");
        };
      }
    });
    var Popper = /* @__PURE__ */ _export_sfc(_sfc_main$28, [["__file", "popper.vue"]]);
  
    const popperArrowProps = buildProps({
      arrowOffset: {
        type: Number,
        default: 5
      }
    });
    const usePopperArrowProps = popperArrowProps;
  
    const __default__$1q = vue.defineComponent({
      name: "ElPopperArrow",
      inheritAttrs: false
    });
    const _sfc_main$27 = /* @__PURE__ */ vue.defineComponent({
      ...__default__$1q,
      props: popperArrowProps,
      setup(__props, { expose }) {
        const props = __props;
        const ns = useNamespace("popper");
        const { arrowOffset, arrowRef } = vue.inject(POPPER_CONTENT_INJECTION_KEY, void 0);
        vue.watch(() => props.arrowOffset, (val) => {
          arrowOffset.value = val;
        });
        vue.onBeforeUnmount(() => {
          arrowRef.value = void 0;
        });
        expose({
          arrowRef
        });
        return (_ctx, _cache) => {
          return vue.openBlock(), vue.createElementBlock("span", {
            ref_key: "arrowRef",
            ref: arrowRef,
            class: vue.normalizeClass(vue.unref(ns).e("arrow")),
            "data-popper-arrow": ""
          }, null, 2);
        };
      }
    });
    var ElPopperArrow = /* @__PURE__ */ _export_sfc(_sfc_main$27, [["__file", "arrow.vue"]]);
  
    const NAME = "ElOnlyChild";
    const OnlyChild = vue.defineComponent({
      name: NAME,
      setup(_, {
        slots,
        attrs
      }) {
        var _a;
        const forwardRefInjection = vue.inject(FORWARD_REF_INJECTION_KEY);
        const forwardRefDirective = useForwardRefDirective((_a = forwardRefInjection == null ? void 0 : forwardRefInjection.setForwardRef) != null ? _a : NOOP);
        return () => {
          var _a2;
          const defaultSlot = (_a2 = slots.default) == null ? void 0 : _a2.call(slots, attrs);
          if (!defaultSlot)
            return null;
          if (defaultSlot.length > 1) {
            return null;
          }
          const firstLegitNode = findFirstLegitChild(defaultSlot);
          if (!firstLegitNode) {
            return null;
          }
          return vue.withDirectives(vue.cloneVNode(firstLegitNode, attrs), [[forwardRefDirective]]);
        };
      }
    });
    function findFirstLegitChild(node) {
      if (!node)
        return null;
      const children = node;
      for (const child of children) {
        if (isObject$1(child)) {
          switch (child.type) {
            case vue.Comment:
              continue;
            case vue.Text:
            case "svg":
              return wrapTextContent(child);
            case vue.Fragment:
              return findFirstLegitChild(child.children);
            default:
              return child;
          }
        }
        return wrapTextContent(child);
      }
      return null;
    }
    function wrapTextContent(s) {
      const ns = useNamespace("only-child");
      return vue.createVNode("span", {
        "class": ns.e("content")
      }, [s]);
    }
  
    const popperTriggerProps = buildProps({
      virtualRef: {
        type: definePropType(Object)
      },
      virtualTriggering: Boolean,
      onMouseenter: {
        type: definePropType(Function)
      },
      onMouseleave: {
        type: definePropType(Function)
      },
      onClick: {
        type: definePropType(Function)
      },
      onKeydown: {
        type: definePropType(Function)
      },
      onFocus: {
        type: definePropType(Function)
      },
      onBlur: {
        type: definePropType(Function)
      },
      onContextmenu: {
        type: definePropType(Function)
      },
      id: String,
      open: Boolean
    });
    const usePopperTriggerProps = popperTriggerProps;
  
    const __default__$1p = vue.defineComponent({
      name: "ElPopperTrigger",
      inheritAttrs: false
    });
    const _sfc_main$26 = /* @__PURE__ */ vue.defineComponent({
      ...__default__$1p,
      props: popperTriggerProps,
      setup(__props, { expose }) {
        const props = __props;
        const { role, triggerRef } = vue.inject(POPPER_INJECTION_KEY, void 0);
        useForwardRef(triggerRef);
        const ariaControls = vue.computed(() => {
          return ariaHaspopup.value ? props.id : void 0;
        });
        const ariaDescribedby = vue.computed(() => {
          if (role && role.value === "tooltip") {
            return props.open && props.id ? props.id : void 0;
          }
          return void 0;
        });
        const ariaHaspopup = vue.computed(() => {
          if (role && role.value !== "tooltip") {
            return role.value;
          }
          return void 0;
        });
        const ariaExpanded = vue.computed(() => {
          return ariaHaspopup.value ? `${props.open}` : void 0;
        });
        let virtualTriggerAriaStopWatch = void 0;
        vue.onMounted(() => {
          vue.watch(() => props.virtualRef, (virtualEl) => {
            if (virtualEl) {
              triggerRef.value = unrefElement(virtualEl);
            }
          }, {
            immediate: true
          });
          vue.watch(triggerRef, (el, prevEl) => {
            virtualTriggerAriaStopWatch == null ? void 0 : virtualTriggerAriaStopWatch();
            virtualTriggerAriaStopWatch = void 0;
            if (isElement$1(el)) {
              [
                "onMouseenter",
                "onMouseleave",
                "onClick",
                "onKeydown",
                "onFocus",
                "onBlur",
                "onContextmenu"
              ].forEach((eventName) => {
                var _a;
                const handler = props[eventName];
                if (handler) {
                  el.addEventListener(eventName.slice(2).toLowerCase(), handler);
                  (_a = prevEl == null ? void 0 : prevEl.removeEventListener) == null ? void 0 : _a.call(prevEl, eventName.slice(2).toLowerCase(), handler);
                }
              });
              virtualTriggerAriaStopWatch = vue.watch([ariaControls, ariaDescribedby, ariaHaspopup, ariaExpanded], (watches) => {
                [
                  "aria-controls",
                  "aria-describedby",
                  "aria-haspopup",
                  "aria-expanded"
                ].forEach((key, idx) => {
                  isNil(watches[idx]) ? el.removeAttribute(key) : el.setAttribute(key, watches[idx]);
                });
              }, { immediate: true });
            }
            if (isElement$1(prevEl)) {
              [
                "aria-controls",
                "aria-describedby",
                "aria-haspopup",
                "aria-expanded"
              ].forEach((key) => prevEl.removeAttribute(key));
            }
          }, {
            immediate: true
          });
        });
        vue.onBeforeUnmount(() => {
          virtualTriggerAriaStopWatch == null ? void 0 : virtualTriggerAriaStopWatch();
          virtualTriggerAriaStopWatch = void 0;
        });
        expose({
          triggerRef
        });
        return (_ctx, _cache) => {
          return !_ctx.virtualTriggering ? (vue.openBlock(), vue.createBlock(vue.unref(OnlyChild), vue.mergeProps({ key: 0 }, _ctx.$attrs, {
            "aria-controls": vue.unref(ariaControls),
            "aria-describedby": vue.unref(ariaDescribedby),
            "aria-expanded": vue.unref(ariaExpanded),
            "aria-haspopup": vue.unref(ariaHaspopup)
          }), {
            default: vue.withCtx(() => [
              vue.renderSlot(_ctx.$slots, "default")
            ]),
            _: 3
          }, 16, ["aria-controls", "aria-describedby", "aria-expanded", "aria-haspopup"])) : vue.createCommentVNode("v-if", true);
        };
      }
    });
    var ElPopperTrigger = /* @__PURE__ */ _export_sfc(_sfc_main$26, [["__file", "trigger.vue"]]);
  
    var E$1="top",R="bottom",W="right",P$1="left",me="auto",G=[E$1,R,W,P$1],U$1="start",J="end",Xe="clippingParents",je="viewport",K="popper",Ye="reference",De=G.reduce(function(t,e){return t.concat([e+"-"+U$1,e+"-"+J])},[]),Ee=[].concat(G,[me]).reduce(function(t,e){return t.concat([e,e+"-"+U$1,e+"-"+J])},[]),Ge="beforeRead",Je="read",Ke="afterRead",Qe="beforeMain",Ze="main",et="afterMain",tt="beforeWrite",nt="write",rt="afterWrite",ot=[Ge,Je,Ke,Qe,Ze,et,tt,nt,rt];function C(t){return t?(t.nodeName||"").toLowerCase():null}function H(t){if(t==null)return window;if(t.toString()!=="[object Window]"){var e=t.ownerDocument;return e&&e.defaultView||window}return t}function Q(t){var e=H(t).Element;return t instanceof e||t instanceof Element}function B(t){var e=H(t).HTMLElement;return t instanceof e||t instanceof HTMLElement}function Pe(t){if(typeof ShadowRoot=="undefined")return !1;var e=H(t).ShadowRoot;return t instanceof e||t instanceof ShadowRoot}function Mt(t){var e=t.state;Object.keys(e.elements).forEach(function(n){var r=e.styles[n]||{},o=e.attributes[n]||{},i=e.elements[n];!B(i)||!C(i)||(Object.assign(i.style,r),Object.keys(o).forEach(function(a){var s=o[a];s===!1?i.removeAttribute(a):i.setAttribute(a,s===!0?"":s);}));});}function Rt(t){var e=t.state,n={popper:{position:e.options.strategy,left:"0",top:"0",margin:"0"},arrow:{position:"absolute"},reference:{}};return Object.assign(e.elements.popper.style,n.popper),e.styles=n,e.elements.arrow&&Object.assign(e.elements.arrow.style,n.arrow),function(){Object.keys(e.elements).forEach(function(r){var o=e.elements[r],i=e.attributes[r]||{},a=Object.keys(e.styles.hasOwnProperty(r)?e.styles[r]:n[r]),s=a.reduce(function(f,c){return f[c]="",f},{});!B(o)||!C(o)||(Object.assign(o.style,s),Object.keys(i).forEach(function(f){o.removeAttribute(f);}));});}}var Ae={name:"applyStyles",enabled:!0,phase:"write",fn:Mt,effect:Rt,requires:["computeStyles"]};function q(t){return t.split("-")[0]}var X$1=Math.max,ve=Math.min,Z=Math.round;function ee(t,e){e===void 0&&(e=!1);var n=t.getBoundingClientRect(),r=1,o=1;if(B(t)&&e){var i=t.offsetHeight,a=t.offsetWidth;a>0&&(r=Z(n.width)/a||1),i>0&&(o=Z(n.height)/i||1);}return {width:n.width/r,height:n.height/o,top:n.top/o,right:n.right/r,bottom:n.bottom/o,left:n.left/r,x:n.left/r,y:n.top/o}}function ke(t){var e=ee(t),n=t.offsetWidth,r=t.offsetHeight;return Math.abs(e.width-n)<=1&&(n=e.width),Math.abs(e.height-r)<=1&&(r=e.height),{x:t.offsetLeft,y:t.offsetTop,width:n,height:r}}function it(t,e){var n=e.getRootNode&&e.getRootNode();if(t.contains(e))return !0;if(n&&Pe(n)){var r=e;do{if(r&&t.isSameNode(r))return !0;r=r.parentNode||r.host;}while(r)}return !1}function N$1(t){return H(t).getComputedStyle(t)}function Wt(t){return ["table","td","th"].indexOf(C(t))>=0}function I$1(t){return ((Q(t)?t.ownerDocument:t.document)||window.document).documentElement}function ge(t){return C(t)==="html"?t:t.assignedSlot||t.parentNode||(Pe(t)?t.host:null)||I$1(t)}function at(t){return !B(t)||N$1(t).position==="fixed"?null:t.offsetParent}function Bt(t){var e=navigator.userAgent.toLowerCase().indexOf("firefox")!==-1,n=navigator.userAgent.indexOf("Trident")!==-1;if(n&&B(t)){var r=N$1(t);if(r.position==="fixed")return null}var o=ge(t);for(Pe(o)&&(o=o.host);B(o)&&["html","body"].indexOf(C(o))<0;){var i=N$1(o);if(i.transform!=="none"||i.perspective!=="none"||i.contain==="paint"||["transform","perspective"].indexOf(i.willChange)!==-1||e&&i.willChange==="filter"||e&&i.filter&&i.filter!=="none")return o;o=o.parentNode;}return null}function se(t){for(var e=H(t),n=at(t);n&&Wt(n)&&N$1(n).position==="static";)n=at(n);return n&&(C(n)==="html"||C(n)==="body"&&N$1(n).position==="static")?e:n||Bt(t)||e}function Le(t){return ["top","bottom"].indexOf(t)>=0?"x":"y"}function fe(t,e,n){return X$1(t,ve(e,n))}function St(t,e,n){var r=fe(t,e,n);return r>n?n:r}function st(){return {top:0,right:0,bottom:0,left:0}}function ft(t){return Object.assign({},st(),t)}function ct(t,e){return e.reduce(function(n,r){return n[r]=t,n},{})}var Tt=function(t,e){return t=typeof t=="function"?t(Object.assign({},e.rects,{placement:e.placement})):t,ft(typeof t!="number"?t:ct(t,G))};function Ht(t){var e,n=t.state,r=t.name,o=t.options,i=n.elements.arrow,a=n.modifiersData.popperOffsets,s=q(n.placement),f=Le(s),c=[P$1,W].indexOf(s)>=0,u=c?"height":"width";if(!(!i||!a)){var m=Tt(o.padding,n),v=ke(i),l=f==="y"?E$1:P$1,h=f==="y"?R:W,p=n.rects.reference[u]+n.rects.reference[f]-a[f]-n.rects.popper[u],g=a[f]-n.rects.reference[f],x=se(i),y=x?f==="y"?x.clientHeight||0:x.clientWidth||0:0,$=p/2-g/2,d=m[l],b=y-v[u]-m[h],w=y/2-v[u]/2+$,O=fe(d,w,b),j=f;n.modifiersData[r]=(e={},e[j]=O,e.centerOffset=O-w,e);}}function Ct(t){var e=t.state,n=t.options,r=n.element,o=r===void 0?"[data-popper-arrow]":r;o!=null&&(typeof o=="string"&&(o=e.elements.popper.querySelector(o),!o)||!it(e.elements.popper,o)||(e.elements.arrow=o));}var pt={name:"arrow",enabled:!0,phase:"main",fn:Ht,effect:Ct,requires:["popperOffsets"],requiresIfExists:["preventOverflow"]};function te(t){return t.split("-")[1]}var qt={top:"auto",right:"auto",bottom:"auto",left:"auto"};function Vt(t){var e=t.x,n=t.y,r=window,o=r.devicePixelRatio||1;return {x:Z(e*o)/o||0,y:Z(n*o)/o||0}}function ut(t){var e,n=t.popper,r=t.popperRect,o=t.placement,i=t.variation,a=t.offsets,s=t.position,f=t.gpuAcceleration,c=t.adaptive,u=t.roundOffsets,m=t.isFixed,v=a.x,l=v===void 0?0:v,h=a.y,p=h===void 0?0:h,g=typeof u=="function"?u({x:l,y:p}):{x:l,y:p};l=g.x,p=g.y;var x=a.hasOwnProperty("x"),y=a.hasOwnProperty("y"),$=P$1,d=E$1,b=window;if(c){var w=se(n),O="clientHeight",j="clientWidth";if(w===H(n)&&(w=I$1(n),N$1(w).position!=="static"&&s==="absolute"&&(O="scrollHeight",j="scrollWidth")),w=w,o===E$1||(o===P$1||o===W)&&i===J){d=R;var A=m&&w===b&&b.visualViewport?b.visualViewport.height:w[O];p-=A-r.height,p*=f?1:-1;}if(o===P$1||(o===E$1||o===R)&&i===J){$=W;var k=m&&w===b&&b.visualViewport?b.visualViewport.width:w[j];l-=k-r.width,l*=f?1:-1;}}var D=Object.assign({position:s},c&&qt),S=u===!0?Vt({x:l,y:p}):{x:l,y:p};if(l=S.x,p=S.y,f){var L;return Object.assign({},D,(L={},L[d]=y?"0":"",L[$]=x?"0":"",L.transform=(b.devicePixelRatio||1)<=1?"translate("+l+"px, "+p+"px)":"translate3d("+l+"px, "+p+"px, 0)",L))}return Object.assign({},D,(e={},e[d]=y?p+"px":"",e[$]=x?l+"px":"",e.transform="",e))}function Nt(t){var e=t.state,n=t.options,r=n.gpuAcceleration,o=r===void 0?!0:r,i=n.adaptive,a=i===void 0?!0:i,s=n.roundOffsets,f=s===void 0?!0:s,c={placement:q(e.placement),variation:te(e.placement),popper:e.elements.popper,popperRect:e.rects.popper,gpuAcceleration:o,isFixed:e.options.strategy==="fixed"};e.modifiersData.popperOffsets!=null&&(e.styles.popper=Object.assign({},e.styles.popper,ut(Object.assign({},c,{offsets:e.modifiersData.popperOffsets,position:e.options.strategy,adaptive:a,roundOffsets:f})))),e.modifiersData.arrow!=null&&(e.styles.arrow=Object.assign({},e.styles.arrow,ut(Object.assign({},c,{offsets:e.modifiersData.arrow,position:"absolute",adaptive:!1,roundOffsets:f})))),e.attributes.popper=Object.assign({},e.attributes.popper,{"data-popper-placement":e.placement});}var Me={name:"computeStyles",enabled:!0,phase:"beforeWrite",fn:Nt,data:{}},ye={passive:!0};function It(t){var e=t.state,n=t.instance,r=t.options,o=r.scroll,i=o===void 0?!0:o,a=r.resize,s=a===void 0?!0:a,f=H(e.elements.popper),c=[].concat(e.scrollParents.reference,e.scrollParents.popper);return i&&c.forEach(function(u){u.addEventListener("scroll",n.update,ye);}),s&&f.addEventListener("resize",n.update,ye),function(){i&&c.forEach(function(u){u.removeEventListener("scroll",n.update,ye);}),s&&f.removeEventListener("resize",n.update,ye);}}var Re={name:"eventListeners",enabled:!0,phase:"write",fn:function(){},effect:It,data:{}},_t={left:"right",right:"left",bottom:"top",top:"bottom"};function be(t){return t.replace(/left|right|bottom|top/g,function(e){return _t[e]})}var zt={start:"end",end:"start"};function lt(t){return t.replace(/start|end/g,function(e){return zt[e]})}function We(t){var e=H(t),n=e.pageXOffset,r=e.pageYOffset;return {scrollLeft:n,scrollTop:r}}function Be(t){return ee(I$1(t)).left+We(t).scrollLeft}function Ft(t){var e=H(t),n=I$1(t),r=e.visualViewport,o=n.clientWidth,i=n.clientHeight,a=0,s=0;return r&&(o=r.width,i=r.height,/^((?!chrome|android).)*safari/i.test(navigator.userAgent)||(a=r.offsetLeft,s=r.offsetTop)),{width:o,height:i,x:a+Be(t),y:s}}function Ut(t){var e,n=I$1(t),r=We(t),o=(e=t.ownerDocument)==null?void 0:e.body,i=X$1(n.scrollWidth,n.clientWidth,o?o.scrollWidth:0,o?o.clientWidth:0),a=X$1(n.scrollHeight,n.clientHeight,o?o.scrollHeight:0,o?o.clientHeight:0),s=-r.scrollLeft+Be(t),f=-r.scrollTop;return N$1(o||n).direction==="rtl"&&(s+=X$1(n.clientWidth,o?o.clientWidth:0)-i),{width:i,height:a,x:s,y:f}}function Se(t){var e=N$1(t),n=e.overflow,r=e.overflowX,o=e.overflowY;return /auto|scroll|overlay|hidden/.test(n+o+r)}function dt(t){return ["html","body","#document"].indexOf(C(t))>=0?t.ownerDocument.body:B(t)&&Se(t)?t:dt(ge(t))}function ce(t,e){var n;e===void 0&&(e=[]);var r=dt(t),o=r===((n=t.ownerDocument)==null?void 0:n.body),i=H(r),a=o?[i].concat(i.visualViewport||[],Se(r)?r:[]):r,s=e.concat(a);return o?s:s.concat(ce(ge(a)))}function Te(t){return Object.assign({},t,{left:t.x,top:t.y,right:t.x+t.width,bottom:t.y+t.height})}function Xt(t){var e=ee(t);return e.top=e.top+t.clientTop,e.left=e.left+t.clientLeft,e.bottom=e.top+t.clientHeight,e.right=e.left+t.clientWidth,e.width=t.clientWidth,e.height=t.clientHeight,e.x=e.left,e.y=e.top,e}function ht(t,e){return e===je?Te(Ft(t)):Q(e)?Xt(e):Te(Ut(I$1(t)))}function Yt(t){var e=ce(ge(t)),n=["absolute","fixed"].indexOf(N$1(t).position)>=0,r=n&&B(t)?se(t):t;return Q(r)?e.filter(function(o){return Q(o)&&it(o,r)&&C(o)!=="body"}):[]}function Gt(t,e,n){var r=e==="clippingParents"?Yt(t):[].concat(e),o=[].concat(r,[n]),i=o[0],a=o.reduce(function(s,f){var c=ht(t,f);return s.top=X$1(c.top,s.top),s.right=ve(c.right,s.right),s.bottom=ve(c.bottom,s.bottom),s.left=X$1(c.left,s.left),s},ht(t,i));return a.width=a.right-a.left,a.height=a.bottom-a.top,a.x=a.left,a.y=a.top,a}function mt(t){var e=t.reference,n=t.element,r=t.placement,o=r?q(r):null,i=r?te(r):null,a=e.x+e.width/2-n.width/2,s=e.y+e.height/2-n.height/2,f;switch(o){case E$1:f={x:a,y:e.y-n.height};break;case R:f={x:a,y:e.y+e.height};break;case W:f={x:e.x+e.width,y:s};break;case P$1:f={x:e.x-n.width,y:s};break;default:f={x:e.x,y:e.y};}var c=o?Le(o):null;if(c!=null){var u=c==="y"?"height":"width";switch(i){case U$1:f[c]=f[c]-(e[u]/2-n[u]/2);break;case J:f[c]=f[c]+(e[u]/2-n[u]/2);break}}return f}function ne(t,e){e===void 0&&(e={});var n=e,r=n.placement,o=r===void 0?t.placement:r,i=n.boundary,a=i===void 0?Xe:i,s=n.rootBoundary,f=s===void 0?je:s,c=n.elementContext,u=c===void 0?K:c,m=n.altBoundary,v=m===void 0?!1:m,l=n.padding,h=l===void 0?0:l,p=ft(typeof h!="number"?h:ct(h,G)),g=u===K?Ye:K,x=t.rects.popper,y=t.elements[v?g:u],$=Gt(Q(y)?y:y.contextElement||I$1(t.elements.popper),a,f),d=ee(t.elements.reference),b=mt({reference:d,element:x,strategy:"absolute",placement:o}),w=Te(Object.assign({},x,b)),O=u===K?w:d,j={top:$.top-O.top+p.top,bottom:O.bottom-$.bottom+p.bottom,left:$.left-O.left+p.left,right:O.right-$.right+p.right},A=t.modifiersData.offset;if(u===K&&A){var k=A[o];Object.keys(j).forEach(function(D){var S=[W,R].indexOf(D)>=0?1:-1,L=[E$1,R].indexOf(D)>=0?"y":"x";j[D]+=k[L]*S;});}return j}function Jt(t,e){e===void 0&&(e={});var n=e,r=n.placement,o=n.boundary,i=n.rootBoundary,a=n.padding,s=n.flipVariations,f=n.allowedAutoPlacements,c=f===void 0?Ee:f,u=te(r),m=u?s?De:De.filter(function(h){return te(h)===u}):G,v=m.filter(function(h){return c.indexOf(h)>=0});v.length===0&&(v=m);var l=v.reduce(function(h,p){return h[p]=ne(t,{placement:p,boundary:o,rootBoundary:i,padding:a})[q(p)],h},{});return Object.keys(l).sort(function(h,p){return l[h]-l[p]})}function Kt(t){if(q(t)===me)return [];var e=be(t);return [lt(t),e,lt(e)]}function Qt(t){var e=t.state,n=t.options,r=t.name;if(!e.modifiersData[r]._skip){for(var o=n.mainAxis,i=o===void 0?!0:o,a=n.altAxis,s=a===void 0?!0:a,f=n.fallbackPlacements,c=n.padding,u=n.boundary,m=n.rootBoundary,v=n.altBoundary,l=n.flipVariations,h=l===void 0?!0:l,p=n.allowedAutoPlacements,g=e.options.placement,x=q(g),y=x===g,$=f||(y||!h?[be(g)]:Kt(g)),d=[g].concat($).reduce(function(z,V){return z.concat(q(V)===me?Jt(e,{placement:V,boundary:u,rootBoundary:m,padding:c,flipVariations:h,allowedAutoPlacements:p}):V)},[]),b=e.rects.reference,w=e.rects.popper,O=new Map,j=!0,A=d[0],k=0;k<d.length;k++){var D=d[k],S=q(D),L=te(D)===U$1,re=[E$1,R].indexOf(S)>=0,oe=re?"width":"height",M=ne(e,{placement:D,boundary:u,rootBoundary:m,altBoundary:v,padding:c}),T=re?L?W:P$1:L?R:E$1;b[oe]>w[oe]&&(T=be(T));var pe=be(T),_=[];if(i&&_.push(M[S]<=0),s&&_.push(M[T]<=0,M[pe]<=0),_.every(function(z){return z})){A=D,j=!1;break}O.set(D,_);}if(j)for(var ue=h?3:1,xe=function(z){var V=d.find(function(de){var ae=O.get(de);if(ae)return ae.slice(0,z).every(function(Y){return Y})});if(V)return A=V,"break"},ie=ue;ie>0;ie--){var le=xe(ie);if(le==="break")break}e.placement!==A&&(e.modifiersData[r]._skip=!0,e.placement=A,e.reset=!0);}}var vt={name:"flip",enabled:!0,phase:"main",fn:Qt,requiresIfExists:["offset"],data:{_skip:!1}};function gt(t,e,n){return n===void 0&&(n={x:0,y:0}),{top:t.top-e.height-n.y,right:t.right-e.width+n.x,bottom:t.bottom-e.height+n.y,left:t.left-e.width-n.x}}function yt(t){return [E$1,W,R,P$1].some(function(e){return t[e]>=0})}function Zt(t){var e=t.state,n=t.name,r=e.rects.reference,o=e.rects.popper,i=e.modifiersData.preventOverflow,a=ne(e,{elementContext:"reference"}),s=ne(e,{altBoundary:!0}),f=gt(a,r),c=gt(s,o,i),u=yt(f),m=yt(c);e.modifiersData[n]={referenceClippingOffsets:f,popperEscapeOffsets:c,isReferenceHidden:u,hasPopperEscaped:m},e.attributes.popper=Object.assign({},e.attributes.popper,{"data-popper-reference-hidden":u,"data-popper-escaped":m});}var bt={name:"hide",enabled:!0,phase:"main",requiresIfExists:["preventOverflow"],fn:Zt};function en(t,e,n){var r=q(t),o=[P$1,E$1].indexOf(r)>=0?-1:1,i=typeof n=="function"?n(Object.assign({},e,{placement:t})):n,a=i[0],s=i[1];return a=a||0,s=(s||0)*o,[P$1,W].indexOf(r)>=0?{x:s,y:a}:{x:a,y:s}}function tn(t){var e=t.state,n=t.options,r=t.name,o=n.offset,i=o===void 0?[0,0]:o,a=Ee.reduce(function(u,m){return u[m]=en(m,e.rects,i),u},{}),s=a[e.placement],f=s.x,c=s.y;e.modifiersData.popperOffsets!=null&&(e.modifiersData.popperOffsets.x+=f,e.modifiersData.popperOffsets.y+=c),e.modifiersData[r]=a;}var wt={name:"offset",enabled:!0,phase:"main",requires:["popperOffsets"],fn:tn};function nn(t){var e=t.state,n=t.name;e.modifiersData[n]=mt({reference:e.rects.reference,element:e.rects.popper,strategy:"absolute",placement:e.placement});}var He={name:"popperOffsets",enabled:!0,phase:"read",fn:nn,data:{}};function rn(t){return t==="x"?"y":"x"}function on(t){var e=t.state,n=t.options,r=t.name,o=n.mainAxis,i=o===void 0?!0:o,a=n.altAxis,s=a===void 0?!1:a,f=n.boundary,c=n.rootBoundary,u=n.altBoundary,m=n.padding,v=n.tether,l=v===void 0?!0:v,h=n.tetherOffset,p=h===void 0?0:h,g=ne(e,{boundary:f,rootBoundary:c,padding:m,altBoundary:u}),x=q(e.placement),y=te(e.placement),$=!y,d=Le(x),b=rn(d),w=e.modifiersData.popperOffsets,O=e.rects.reference,j=e.rects.popper,A=typeof p=="function"?p(Object.assign({},e.rects,{placement:e.placement})):p,k=typeof A=="number"?{mainAxis:A,altAxis:A}:Object.assign({mainAxis:0,altAxis:0},A),D=e.modifiersData.offset?e.modifiersData.offset[e.placement]:null,S={x:0,y:0};if(w){if(i){var L,re=d==="y"?E$1:P$1,oe=d==="y"?R:W,M=d==="y"?"height":"width",T=w[d],pe=T+g[re],_=T-g[oe],ue=l?-j[M]/2:0,xe=y===U$1?O[M]:j[M],ie=y===U$1?-j[M]:-O[M],le=e.elements.arrow,z=l&&le?ke(le):{width:0,height:0},V=e.modifiersData["arrow#persistent"]?e.modifiersData["arrow#persistent"].padding:st(),de=V[re],ae=V[oe],Y=fe(0,O[M],z[M]),jt=$?O[M]/2-ue-Y-de-k.mainAxis:xe-Y-de-k.mainAxis,Dt=$?-O[M]/2+ue+Y+ae+k.mainAxis:ie+Y+ae+k.mainAxis,Oe=e.elements.arrow&&se(e.elements.arrow),Et=Oe?d==="y"?Oe.clientTop||0:Oe.clientLeft||0:0,Ce=(L=D==null?void 0:D[d])!=null?L:0,Pt=T+jt-Ce-Et,At=T+Dt-Ce,qe=fe(l?ve(pe,Pt):pe,T,l?X$1(_,At):_);w[d]=qe,S[d]=qe-T;}if(s){var Ve,kt=d==="x"?E$1:P$1,Lt=d==="x"?R:W,F=w[b],he=b==="y"?"height":"width",Ne=F+g[kt],Ie=F-g[Lt],$e=[E$1,P$1].indexOf(x)!==-1,_e=(Ve=D==null?void 0:D[b])!=null?Ve:0,ze=$e?Ne:F-O[he]-j[he]-_e+k.altAxis,Fe=$e?F+O[he]+j[he]-_e-k.altAxis:Ie,Ue=l&&$e?St(ze,F,Fe):fe(l?ze:Ne,F,l?Fe:Ie);w[b]=Ue,S[b]=Ue-F;}e.modifiersData[r]=S;}}var xt={name:"preventOverflow",enabled:!0,phase:"main",fn:on,requiresIfExists:["offset"]};function an(t){return {scrollLeft:t.scrollLeft,scrollTop:t.scrollTop}}function sn(t){return t===H(t)||!B(t)?We(t):an(t)}function fn(t){var e=t.getBoundingClientRect(),n=Z(e.width)/t.offsetWidth||1,r=Z(e.height)/t.offsetHeight||1;return n!==1||r!==1}function cn(t,e,n){n===void 0&&(n=!1);var r=B(e),o=B(e)&&fn(e),i=I$1(e),a=ee(t,o),s={scrollLeft:0,scrollTop:0},f={x:0,y:0};return (r||!r&&!n)&&((C(e)!=="body"||Se(i))&&(s=sn(e)),B(e)?(f=ee(e,!0),f.x+=e.clientLeft,f.y+=e.clientTop):i&&(f.x=Be(i))),{x:a.left+s.scrollLeft-f.x,y:a.top+s.scrollTop-f.y,width:a.width,height:a.height}}function pn(t){var e=new Map,n=new Set,r=[];t.forEach(function(i){e.set(i.name,i);});function o(i){n.add(i.name);var a=[].concat(i.requires||[],i.requiresIfExists||[]);a.forEach(function(s){if(!n.has(s)){var f=e.get(s);f&&o(f);}}),r.push(i);}return t.forEach(function(i){n.has(i.name)||o(i);}),r}function un(t){var e=pn(t);return ot.reduce(function(n,r){return n.concat(e.filter(function(o){return o.phase===r}))},[])}function ln(t){var e;return function(){return e||(e=new Promise(function(n){Promise.resolve().then(function(){e=void 0,n(t());});})),e}}function dn(t){var e=t.reduce(function(n,r){var o=n[r.name];return n[r.name]=o?Object.assign({},o,r,{options:Object.assign({},o.options,r.options),data:Object.assign({},o.data,r.data)}):r,n},{});return Object.keys(e).map(function(n){return e[n]})}var Ot={placement:"bottom",modifiers:[],strategy:"absolute"};function $t(){for(var t=arguments.length,e=new Array(t),n=0;n<t;n++)e[n]=arguments[n];return !e.some(function(r){return !(r&&typeof r.getBoundingClientRect=="function")})}function we(t){t===void 0&&(t={});var e=t,n=e.defaultModifiers,r=n===void 0?[]:n,o=e.defaultOptions,i=o===void 0?Ot:o;return function(a,s,f){f===void 0&&(f=i);var c={placement:"bottom",orderedModifiers:[],options:Object.assign({},Ot,i),modifiersData:{},elements:{reference:a,popper:s},attributes:{},styles:{}},u=[],m=!1,v={state:c,setOptions:function(p){var g=typeof p=="function"?p(c.options):p;h(),c.options=Object.assign({},i,c.options,g),c.scrollParents={reference:Q(a)?ce(a):a.contextElement?ce(a.contextElement):[],popper:ce(s)};var x=un(dn([].concat(r,c.options.modifiers)));return c.orderedModifiers=x.filter(function(y){return y.enabled}),l(),v.update()},forceUpdate:function(){if(!m){var p=c.elements,g=p.reference,x=p.popper;if($t(g,x)){c.rects={reference:cn(g,se(x),c.options.strategy==="fixed"),popper:ke(x)},c.reset=!1,c.placement=c.options.placement,c.orderedModifiers.forEach(function(j){return c.modifiersData[j.name]=Object.assign({},j.data)});for(var y=0;y<c.orderedModifiers.length;y++){if(c.reset===!0){c.reset=!1,y=-1;continue}var $=c.orderedModifiers[y],d=$.fn,b=$.options,w=b===void 0?{}:b,O=$.name;typeof d=="function"&&(c=d({state:c,options:w,name:O,instance:v})||c);}}}},update:ln(function(){return new Promise(function(p){v.forceUpdate(),p(c);})}),destroy:function(){h(),m=!0;}};if(!$t(a,s))return v;v.setOptions(f).then(function(p){!m&&f.onFirstUpdate&&f.onFirstUpdate(p);});function l(){c.orderedModifiers.forEach(function(p){var g=p.name,x=p.options,y=x===void 0?{}:x,$=p.effect;if(typeof $=="function"){var d=$({state:c,name:g,instance:v,options:y}),b=function(){};u.push(d||b);}});}function h(){u.forEach(function(p){return p()}),u=[];}return v}}we();var mn=[Re,He,Me,Ae];we({defaultModifiers:mn});var gn=[Re,He,Me,Ae,wt,vt,xt,pt,bt],yn=we({defaultModifiers:gn});
  
    const FOCUS_AFTER_TRAPPED = "focus-trap.focus-after-trapped";
    const FOCUS_AFTER_RELEASED = "focus-trap.focus-after-released";
    const FOCUSOUT_PREVENTED = "focus-trap.focusout-prevented";
    const FOCUS_AFTER_TRAPPED_OPTS = {
      cancelable: true,
      bubbles: false
    };
    const FOCUSOUT_PREVENTED_OPTS = {
      cancelable: true,
      bubbles: false
    };
    const ON_TRAP_FOCUS_EVT = "focusAfterTrapped";
    const ON_RELEASE_FOCUS_EVT = "focusAfterReleased";
    const FOCUS_TRAP_INJECTION_KEY = Symbol("elFocusTrap");
  
    const focusReason = vue.ref();
    const lastUserFocusTimestamp = vue.ref(0);
    const lastAutomatedFocusTimestamp = vue.ref(0);
    let focusReasonUserCount = 0;
    const obtainAllFocusableElements = (element) => {
      const nodes = [];
      const walker = document.createTreeWalker(element, NodeFilter.SHOW_ELEMENT, {
        acceptNode: (node) => {
          const isHiddenInput = node.tagName === "INPUT" && node.type === "hidden";
          if (node.disabled || node.hidden || isHiddenInput)
            return NodeFilter.FILTER_SKIP;
          return node.tabIndex >= 0 || node === document.activeElement ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_SKIP;
        }
      });
      while (walker.nextNode())
        nodes.push(walker.currentNode);
      return nodes;
    };
    const getVisibleElement = (elements, container) => {
      for (const element of elements) {
        if (!isHidden(element, container))
          return element;
      }
    };
    const isHidden = (element, container) => {
      if (getComputedStyle(element).visibility === "hidden")
        return true;
      while (element) {
        if (container && element === container)
          return false;
        if (getComputedStyle(element).display === "none")
          return true;
        element = element.parentElement;
      }
      return false;
    };
    const getEdges = (container) => {
      const focusable = obtainAllFocusableElements(container);
      const first = getVisibleElement(focusable, container);
      const last = getVisibleElement(focusable.reverse(), container);
      return [first, last];
    };
    const isSelectable = (element) => {
      return element instanceof HTMLInputElement && "select" in element;
    };
    const tryFocus = (element, shouldSelect) => {
      if (element && element.focus) {
        const prevFocusedElement = document.activeElement;
        element.focus({ preventScroll: true });
        lastAutomatedFocusTimestamp.value = window.performance.now();
        if (element !== prevFocusedElement && isSelectable(element) && shouldSelect) {
          if (element.tagName === "INPUT") {
            element.setSelectionRange(element.value.length, element.value.length);
            return;
          }
          element.select();
        }
      }
    };
    function removeFromStack(list, item) {
      const copy = [...list];
      const idx = list.indexOf(item);
      if (idx !== -1) {
        copy.splice(idx, 1);
      }
      return copy;
    }
    const createFocusableStack = () => {
      let stack = [];
      const push = (layer) => {
        const currentLayer = stack[0];
        if (currentLayer && layer !== currentLayer) {
          currentLayer.pause();
        }
        stack = removeFromStack(stack, layer);
        stack.unshift(layer);
      };
      const remove = (layer) => {
        var _a, _b;
        stack = removeFromStack(stack, layer);
        (_b = (_a = stack[0]) == null ? void 0 : _a.resume) == null ? void 0 : _b.call(_a);
      };
      return {
        push,
        remove
      };
    };
    const focusFirstDescendant = (elements, shouldSelect = false) => {
      const prevFocusedElement = document.activeElement;
      for (const element of elements) {
        tryFocus(element, shouldSelect);
        if (document.activeElement !== prevFocusedElement)
          return;
      }
    };
    const focusableStack = createFocusableStack();
    const isFocusCausedByUserEvent = () => {
      return lastUserFocusTimestamp.value > lastAutomatedFocusTimestamp.value;
    };
    const notifyFocusReasonPointer = () => {
      focusReason.value = "pointer";
      lastUserFocusTimestamp.value = window.performance.now();
    };
    const notifyFocusReasonKeydown = () => {
      focusReason.value = "keyboard";
      lastUserFocusTimestamp.value = window.performance.now();
    };
    const useFocusReason = () => {
      vue.onMounted(() => {
        if (focusReasonUserCount === 0) {
          document.addEventListener("mousedown", notifyFocusReasonPointer);
          document.addEventListener("touchstart", notifyFocusReasonPointer);
          document.addEventListener("keydown", notifyFocusReasonKeydown);
        }
        focusReasonUserCount++;
      });
      vue.onBeforeUnmount(() => {
        focusReasonUserCount--;
        if (focusReasonUserCount <= 0) {
          document.removeEventListener("mousedown", notifyFocusReasonPointer);
          document.removeEventListener("touchstart", notifyFocusReasonPointer);
          document.removeEventListener("keydown", notifyFocusReasonKeydown);
        }
      });
      return {
        focusReason,
        lastUserFocusTimestamp,
        lastAutomatedFocusTimestamp
      };
    };
    const createFocusOutPreventedEvent = (detail) => {
      return new CustomEvent(FOCUSOUT_PREVENTED, {
        ...FOCUSOUT_PREVENTED_OPTS,
        detail
      });
    };
  
    const _sfc_main$25 = vue.defineComponent({
      name: "ElFocusTrap",
      inheritAttrs: false,
      props: {
        loop: Boolean,
        trapped: Boolean,
        focusTrapEl: Object,
        focusStartEl: {
          type: [Object, String],
          default: "first"
        }
      },
      emits: [
        ON_TRAP_FOCUS_EVT,
        ON_RELEASE_FOCUS_EVT,
        "focusin",
        "focusout",
        "focusout-prevented",
        "release-requested"
      ],
      setup(props, { emit }) {
        const forwardRef = vue.ref();
        let lastFocusBeforeTrapped;
        let lastFocusAfterTrapped;
        const { focusReason } = useFocusReason();
        useEscapeKeydown((event) => {
          if (props.trapped && !focusLayer.paused) {
            emit("release-requested", event);
          }
        });
        const focusLayer = {
          paused: false,
          pause() {
            this.paused = true;
          },
          resume() {
            this.paused = false;
          }
        };
        const onKeydown = (e) => {
          if (!props.loop && !props.trapped)
            return;
          if (focusLayer.paused)
            return;
          const { key, altKey, ctrlKey, metaKey, currentTarget, shiftKey } = e;
          const { loop } = props;
          const isTabbing = key === EVENT_CODE.tab && !altKey && !ctrlKey && !metaKey;
          const currentFocusingEl = document.activeElement;
          if (isTabbing && currentFocusingEl) {
            const container = currentTarget;
            const [first, last] = getEdges(container);
            const isTabbable = first && last;
            if (!isTabbable) {
              if (currentFocusingEl === container) {
                const focusoutPreventedEvent = createFocusOutPreventedEvent({
                  focusReason: focusReason.value
                });
                emit("focusout-prevented", focusoutPreventedEvent);
                if (!focusoutPreventedEvent.defaultPrevented) {
                  e.preventDefault();
                }
              }
            } else {
              if (!shiftKey && currentFocusingEl === last) {
                const focusoutPreventedEvent = createFocusOutPreventedEvent({
                  focusReason: focusReason.value
                });
                emit("focusout-prevented", focusoutPreventedEvent);
                if (!focusoutPreventedEvent.defaultPrevented) {
                  e.preventDefault();
                  if (loop)
                    tryFocus(first, true);
                }
              } else if (shiftKey && [first, container].includes(currentFocusingEl)) {
                const focusoutPreventedEvent = createFocusOutPreventedEvent({
                  focusReason: focusReason.value
                });
                emit("focusout-prevented", focusoutPreventedEvent);
                if (!focusoutPreventedEvent.defaultPrevented) {
                  e.preventDefault();
                  if (loop)
                    tryFocus(last, true);
                }
              }
            }
          }
        };
        vue.provide(FOCUS_TRAP_INJECTION_KEY, {
          focusTrapRef: forwardRef,
          onKeydown
        });
        vue.watch(() => props.focusTrapEl, (focusTrapEl) => {
          if (focusTrapEl) {
            forwardRef.value = focusTrapEl;
          }
        }, { immediate: true });
        vue.watch([forwardRef], ([forwardRef2], [oldForwardRef]) => {
          if (forwardRef2) {
            forwardRef2.addEventListener("keydown", onKeydown);
            forwardRef2.addEventListener("focusin", onFocusIn);
            forwardRef2.addEventListener("focusout", onFocusOut);
          }
          if (oldForwardRef) {
            oldForwardRef.removeEventListener("keydown", onKeydown);
            oldForwardRef.removeEventListener("focusin", onFocusIn);
            oldForwardRef.removeEventListener("focusout", onFocusOut);
          }
        });
        const trapOnFocus = (e) => {
          emit(ON_TRAP_FOCUS_EVT, e);
        };
        const releaseOnFocus = (e) => emit(ON_RELEASE_FOCUS_EVT, e);
        const onFocusIn = (e) => {
          const trapContainer = vue.unref(forwardRef);
          if (!trapContainer)
            return;
          const target = e.target;
          const relatedTarget = e.relatedTarget;
          const isFocusedInTrap = target && trapContainer.contains(target);
          if (!props.trapped) {
            const isPrevFocusedInTrap = relatedTarget && trapContainer.contains(relatedTarget);
            if (!isPrevFocusedInTrap) {
              lastFocusBeforeTrapped = relatedTarget;
            }
          }
          if (isFocusedInTrap)
            emit("focusin", e);
          if (focusLayer.paused)
            return;
          if (props.trapped) {
            if (isFocusedInTrap) {
              lastFocusAfterTrapped = target;
            } else {
              tryFocus(lastFocusAfterTrapped, true);
            }
          }
        };
        const onFocusOut = (e) => {
          const trapContainer = vue.unref(forwardRef);
          if (focusLayer.paused || !trapContainer)
            return;
          if (props.trapped) {
            const relatedTarget = e.relatedTarget;
            if (!isNil(relatedTarget) && !trapContainer.contains(relatedTarget)) {
              setTimeout(() => {
                if (!focusLayer.paused && props.trapped) {
                  const focusoutPreventedEvent = createFocusOutPreventedEvent({
                    focusReason: focusReason.value
                  });
                  emit("focusout-prevented", focusoutPreventedEvent);
                  if (!focusoutPreventedEvent.defaultPrevented) {
                    tryFocus(lastFocusAfterTrapped, true);
                  }
                }
              }, 0);
            }
          } else {
            const target = e.target;
            const isFocusedInTrap = target && trapContainer.contains(target);
            if (!isFocusedInTrap)
              emit("focusout", e);
          }
        };
        async function startTrap() {
          await vue.nextTick();
          const trapContainer = vue.unref(forwardRef);
          if (trapContainer) {
            focusableStack.push(focusLayer);
            const prevFocusedElement = trapContainer.contains(document.activeElement) ? lastFocusBeforeTrapped : document.activeElement;
            lastFocusBeforeTrapped = prevFocusedElement;
            const isPrevFocusContained = trapContainer.contains(prevFocusedElement);
            if (!isPrevFocusContained) {
              const focusEvent = new Event(FOCUS_AFTER_TRAPPED, FOCUS_AFTER_TRAPPED_OPTS);
              trapContainer.addEventListener(FOCUS_AFTER_TRAPPED, trapOnFocus);
              trapContainer.dispatchEvent(focusEvent);
              if (!focusEvent.defaultPrevented) {
                vue.nextTick(() => {
                  let focusStartEl = props.focusStartEl;
                  if (!isString(focusStartEl)) {
                    tryFocus(focusStartEl);
                    if (document.activeElement !== focusStartEl) {
                      focusStartEl = "first";
                    }
                  }
                  if (focusStartEl === "first") {
                    focusFirstDescendant(obtainAllFocusableElements(trapContainer), true);
                  }
                  if (document.activeElement === prevFocusedElement || focusStartEl === "container") {
                    tryFocus(trapContainer);
                  }
                });
              }
            }
          }
        }
        function stopTrap() {
          const trapContainer = vue.unref(forwardRef);
          if (trapContainer) {
            trapContainer.removeEventListener(FOCUS_AFTER_TRAPPED, trapOnFocus);
            const releasedEvent = new CustomEvent(FOCUS_AFTER_RELEASED, {
              ...FOCUS_AFTER_TRAPPED_OPTS,
              detail: {
                focusReason: focusReason.value
              }
            });
            trapContainer.addEventListener(FOCUS_AFTER_RELEASED, releaseOnFocus);
            trapContainer.dispatchEvent(releasedEvent);
            if (!releasedEvent.defaultPrevented && (focusReason.value == "keyboard" || !isFocusCausedByUserEvent())) {
              tryFocus(lastFocusBeforeTrapped != null ? lastFocusBeforeTrapped : document.body, true);
            }
            trapContainer.removeEventListener(FOCUS_AFTER_RELEASED, trapOnFocus);
            focusableStack.remove(focusLayer);
          }
        }
        vue.onMounted(() => {
          if (props.trapped) {
            startTrap();
          }
          vue.watch(() => props.trapped, (trapped) => {
            if (trapped) {
              startTrap();
            } else {
              stopTrap();
            }
          });
        });
        vue.onBeforeUnmount(() => {
          if (props.trapped) {
            stopTrap();
          }
        });
        return {
          onKeydown
        };
      }
    });
    function _sfc_render$y(_ctx, _cache, $props, $setup, $data, $options) {
      return vue.renderSlot(_ctx.$slots, "default", { handleKeydown: _ctx.onKeydown });
    }
    var ElFocusTrap = /* @__PURE__ */ _export_sfc(_sfc_main$25, [["render", _sfc_render$y], ["__file", "focus-trap.vue"]]);
  
    const POSITIONING_STRATEGIES = ["fixed", "absolute"];
    const popperCoreConfigProps = buildProps({
      boundariesPadding: {
        type: Number,
        default: 0
      },
      fallbackPlacements: {
        type: definePropType(Array),
        default: void 0
      },
      gpuAcceleration: {
        type: Boolean,
        default: true
      },
      offset: {
        type: Number,
        default: 12
      },
      placement: {
        type: String,
        values: Ee,
        default: "bottom"
      },
      popperOptions: {
        type: definePropType(Object),
        default: () => ({})
      },
      strategy: {
        type: String,
        values: POSITIONING_STRATEGIES,
        default: "absolute"
      }
    });
    const popperContentProps = buildProps({
      ...popperCoreConfigProps,
      id: String,
      style: {
        type: definePropType([String, Array, Object])
      },
      className: {
        type: definePropType([String, Array, Object])
      },
      effect: {
        type: String,
        default: "dark"
      },
      visible: Boolean,
      enterable: {
        type: Boolean,
        default: true
      },
      pure: Boolean,
      focusOnShow: {
        type: Boolean,
        default: false
      },
      trapping: {
        type: Boolean,
        default: false
      },
      popperClass: {
        type: definePropType([String, Array, Object])
      },
      popperStyle: {
        type: definePropType([String, Array, Object])
      },
      referenceEl: {
        type: definePropType(Object)
      },
      triggerTargetEl: {
        type: definePropType(Object)
      },
      stopPopperMouseEvent: {
        type: Boolean,
        default: true
      },
      ariaLabel: {
        type: String,
        default: void 0
      },
      virtualTriggering: Boolean,
      zIndex: Number
    });
    const popperContentEmits = {
      mouseenter: (evt) => evt instanceof MouseEvent,
      mouseleave: (evt) => evt instanceof MouseEvent,
      focus: () => true,
      blur: () => true,
      close: () => true
    };
    const usePopperCoreConfigProps = popperCoreConfigProps;
    const usePopperContentProps = popperContentProps;
    const usePopperContentEmits = popperContentEmits;
  
    const buildPopperOptions = (props, arrowProps) => {
      const { placement, strategy, popperOptions } = props;
      const options = {
        placement,
        strategy,
        ...popperOptions,
        modifiers: genModifiers(props)
      };
      attachArrow(options, arrowProps);
      deriveExtraModifiers(options, popperOptions == null ? void 0 : popperOptions.modifiers);
      return options;
    };
    const unwrapMeasurableEl = ($el) => {
      if (!isClient)
        return;
      return unrefElement($el);
    };
    function genModifiers(options) {
      const { offset, gpuAcceleration, fallbackPlacements } = options;
      return [
        {
          name: "offset",
          options: {
            offset: [0, offset != null ? offset : 12]
          }
        },
        {
          name: "preventOverflow",
          options: {
            padding: {
              top: 2,
              bottom: 2,
              left: 5,
              right: 5
            }
          }
        },
        {
          name: "flip",
          options: {
            padding: 5,
            fallbackPlacements
          }
        },
        {
          name: "computeStyles",
          options: {
            gpuAcceleration
          }
        }
      ];
    }
    function attachArrow(options, { arrowEl, arrowOffset }) {
      options.modifiers.push({
        name: "arrow",
        options: {
          element: arrowEl,
          padding: arrowOffset != null ? arrowOffset : 5
        }
      });
    }
    function deriveExtraModifiers(options, modifiers) {
      if (modifiers) {
        options.modifiers = [...options.modifiers, ...modifiers != null ? modifiers : []];
      }
    }
  
    const __default__$1o = vue.defineComponent({
      name: "ElPopperContent"
    });
    const _sfc_main$24 = /* @__PURE__ */ vue.defineComponent({
      ...__default__$1o,
      props: popperContentProps,
      emits: popperContentEmits,
      setup(__props, { expose, emit }) {
        const props = __props;
        const { popperInstanceRef, contentRef, triggerRef, role } = vue.inject(POPPER_INJECTION_KEY, void 0);
        const formItemContext = vue.inject(formItemContextKey, void 0);
        const { nextZIndex } = useZIndex();
        const ns = useNamespace("popper");
        const popperContentRef = vue.ref();
        const focusStartRef = vue.ref("first");
        const arrowRef = vue.ref();
        const arrowOffset = vue.ref();
        vue.provide(POPPER_CONTENT_INJECTION_KEY, {
          arrowRef,
          arrowOffset
        });
        if (formItemContext && (formItemContext.addInputId || formItemContext.removeInputId)) {
          vue.provide(formItemContextKey, {
            ...formItemContext,
            addInputId: NOOP,
            removeInputId: NOOP
          });
        }
        const contentZIndex = vue.ref(props.zIndex || nextZIndex());
        const trapped = vue.ref(false);
        let triggerTargetAriaStopWatch = void 0;
        const computedReference = vue.computed(() => unwrapMeasurableEl(props.referenceEl) || vue.unref(triggerRef));
        const contentStyle = vue.computed(() => [{ zIndex: vue.unref(contentZIndex) }, props.popperStyle]);
        const contentClass = vue.computed(() => [
          ns.b(),
          ns.is("pure", props.pure),
          ns.is(props.effect),
          props.popperClass
        ]);
        const ariaModal = vue.computed(() => {
          return role && role.value === "dialog" ? "false" : void 0;
        });
        const createPopperInstance = ({
          referenceEl,
          popperContentEl,
          arrowEl
        }) => {
          const options = buildPopperOptions(props, {
            arrowEl,
            arrowOffset: vue.unref(arrowOffset)
          });
          return yn(referenceEl, popperContentEl, options);
        };
        const updatePopper = (shouldUpdateZIndex = true) => {
          var _a;
          (_a = vue.unref(popperInstanceRef)) == null ? void 0 : _a.update();
          shouldUpdateZIndex && (contentZIndex.value = props.zIndex || nextZIndex());
        };
        const togglePopperAlive = () => {
          var _a, _b;
          const monitorable = { name: "eventListeners", enabled: props.visible };
          (_b = (_a = vue.unref(popperInstanceRef)) == null ? void 0 : _a.setOptions) == null ? void 0 : _b.call(_a, (options) => ({
            ...options,
            modifiers: [...options.modifiers || [], monitorable]
          }));
          updatePopper(false);
          if (props.visible && props.focusOnShow) {
            trapped.value = true;
          } else if (props.visible === false) {
            trapped.value = false;
          }
        };
        const onFocusAfterTrapped = () => {
          emit("focus");
        };
        const onFocusAfterReleased = (event) => {
          var _a;
          if (((_a = event.detail) == null ? void 0 : _a.focusReason) !== "pointer") {
            focusStartRef.value = "first";
            emit("blur");
          }
        };
        const onFocusInTrap = (event) => {
          if (props.visible && !trapped.value) {
            if (event.target) {
              focusStartRef.value = event.target;
            }
            trapped.value = true;
          }
        };
        const onFocusoutPrevented = (event) => {
          if (!props.trapping) {
            if (event.detail.focusReason === "pointer") {
              event.preventDefault();
            }
            trapped.value = false;
          }
        };
        const onReleaseRequested = () => {
          trapped.value = false;
          emit("close");
        };
        vue.onMounted(() => {
          let updateHandle;
          vue.watch(computedReference, (referenceEl) => {
            var _a;
            updateHandle == null ? void 0 : updateHandle();
            const popperInstance = vue.unref(popperInstanceRef);
            (_a = popperInstance == null ? void 0 : popperInstance.destroy) == null ? void 0 : _a.call(popperInstance);
            if (referenceEl) {
              const popperContentEl = vue.unref(popperContentRef);
              contentRef.value = popperContentEl;
              popperInstanceRef.value = createPopperInstance({
                referenceEl,
                popperContentEl,
                arrowEl: vue.unref(arrowRef)
              });
              updateHandle = vue.watch(() => referenceEl.getBoundingClientRect(), () => updatePopper(), {
                immediate: true
              });
            } else {
              popperInstanceRef.value = void 0;
            }
          }, {
            immediate: true
          });
          vue.watch(() => props.triggerTargetEl, (triggerTargetEl, prevTriggerTargetEl) => {
            triggerTargetAriaStopWatch == null ? void 0 : triggerTargetAriaStopWatch();
            triggerTargetAriaStopWatch = void 0;
            const el = vue.unref(triggerTargetEl || popperContentRef.value);
            const prevEl = vue.unref(prevTriggerTargetEl || popperContentRef.value);
            if (isElement$1(el)) {
              triggerTargetAriaStopWatch = vue.watch([role, () => props.ariaLabel, ariaModal, () => props.id], (watches) => {
                ["role", "aria-label", "aria-modal", "id"].forEach((key, idx) => {
                  isNil(watches[idx]) ? el.removeAttribute(key) : el.setAttribute(key, watches[idx]);
                });
              }, { immediate: true });
            }
            if (prevEl !== el && isElement$1(prevEl)) {
              ["role", "aria-label", "aria-modal", "id"].forEach((key) => {
                prevEl.removeAttribute(key);
              });
            }
          }, { immediate: true });
          vue.watch(() => props.visible, togglePopperAlive, { immediate: true });
          vue.watch(() => buildPopperOptions(props, {
            arrowEl: vue.unref(arrowRef),
            arrowOffset: vue.unref(arrowOffset)
          }), (option) => {
            var _a;
            return (_a = popperInstanceRef.value) == null ? void 0 : _a.setOptions(option);
          });
        });
        vue.onBeforeUnmount(() => {
          triggerTargetAriaStopWatch == null ? void 0 : triggerTargetAriaStopWatch();
          triggerTargetAriaStopWatch = void 0;
        });
        expose({
          popperContentRef,
          popperInstanceRef,
          updatePopper,
          contentStyle
        });
        return (_ctx, _cache) => {
          return vue.openBlock(), vue.createElementBlock("div", {
            ref_key: "popperContentRef",
            ref: popperContentRef,
            style: vue.normalizeStyle(vue.unref(contentStyle)),
            class: vue.normalizeClass(vue.unref(contentClass)),
            tabindex: "-1",
            onMouseenter: _cache[0] || (_cache[0] = (e) => _ctx.$emit("mouseenter", e)),
            onMouseleave: _cache[1] || (_cache[1] = (e) => _ctx.$emit("mouseleave", e))
          }, [
            vue.createVNode(vue.unref(ElFocusTrap), {
              trapped: trapped.value,
              "trap-on-focus-in": true,
              "focus-trap-el": popperContentRef.value,
              "focus-start-el": focusStartRef.value,
              onFocusAfterTrapped,
              onFocusAfterReleased,
              onFocusin: onFocusInTrap,
              onFocusoutPrevented,
              onReleaseRequested
            }, {
              default: vue.withCtx(() => [
                vue.renderSlot(_ctx.$slots, "default")
              ]),
              _: 3
            }, 8, ["trapped", "focus-trap-el", "focus-start-el"])
          ], 38);
        };
      }
    });
    var ElPopperContent = /* @__PURE__ */ _export_sfc(_sfc_main$24, [["__file", "content.vue"]]);
  
    const ElPopper = withInstall(Popper);
  
    const ns = useNamespace("tooltip");
    const useTooltipContentProps = buildProps({
      ...useDelayedToggleProps,
      ...popperContentProps,
      appendTo: {
        type: definePropType([String, Object]),
        default: POPPER_CONTAINER_SELECTOR
      },
      content: {
        type: String,
        default: ""
      },
      rawContent: {
        type: Boolean,
        default: false
      },
      persistent: Boolean,
      ariaLabel: String,
      visible: {
        type: definePropType(Boolean),
        default: null
      },
      transition: {
        type: String,
        default: `${ns.namespace.value}-fade-in-linear`
      },
      teleported: {
        type: Boolean,
        default: true
      },
      disabled: {
        type: Boolean
      }
    });
  
    const useTooltipTriggerProps = buildProps({
      ...popperTriggerProps,
      disabled: Boolean,
      trigger: {
        type: definePropType([String, Array]),
        default: "hover"
      },
      triggerKeys: {
        type: definePropType(Array),
        default: () => [EVENT_CODE.enter, EVENT_CODE.space]
      }
    });
  
    const {
      useModelToggleProps: useTooltipModelToggleProps,
      useModelToggleEmits: useTooltipModelToggleEmits,
      useModelToggle: useTooltipModelToggle
    } = createModelToggleComposable("visible");
    const useTooltipProps = buildProps({
      ...popperProps,
      ...useTooltipModelToggleProps,
      ...useTooltipContentProps,
      ...useTooltipTriggerProps,
      ...popperArrowProps,
      showArrow: {
        type: Boolean,
        default: true
      }
    });
    const tooltipEmits = [
      ...useTooltipModelToggleEmits,
      "before-show",
      "before-hide",
      "show",
      "hide",
      "open",
      "close"
    ];
  
    const isTriggerType = (trigger, type) => {
      if (isArray(trigger)) {
        return trigger.includes(type);
      }
      return trigger === type;
    };
    const whenTrigger = (trigger, type, handler) => {
      return (e) => {
        isTriggerType(vue.unref(trigger), type) && handler(e);
      };
    };
  
    const __default__$1n = vue.defineComponent({
      name: "ElTooltipTrigger"
    });
    const _sfc_main$23 = /* @__PURE__ */ vue.defineComponent({
      ...__default__$1n,
      props: useTooltipTriggerProps,
      setup(__props, { expose }) {
        const props = __props;
        const ns = useNamespace("tooltip");
        const { controlled, id, open, onOpen, onClose, onToggle } = vue.inject(TOOLTIP_INJECTION_KEY, void 0);
        const triggerRef = vue.ref(null);
        const stopWhenControlledOrDisabled = () => {
          if (vue.unref(controlled) || props.disabled) {
            return true;
          }
        };
        const trigger = vue.toRef(props, "trigger");
        const onMouseenter = composeEventHandlers(stopWhenControlledOrDisabled, whenTrigger(trigger, "hover", onOpen));
        const onMouseleave = composeEventHandlers(stopWhenControlledOrDisabled, whenTrigger(trigger, "hover", onClose));
        const onClick = composeEventHandlers(stopWhenControlledOrDisabled, whenTrigger(trigger, "click", (e) => {
          if (e.button === 0) {
            onToggle(e);
          }
        }));
        const onFocus = composeEventHandlers(stopWhenControlledOrDisabled, whenTrigger(trigger, "focus", onOpen));
        const onBlur = composeEventHandlers(stopWhenControlledOrDisabled, whenTrigger(trigger, "focus", onClose));
        const onContextMenu = composeEventHandlers(stopWhenControlledOrDisabled, whenTrigger(trigger, "contextmenu", (e) => {
          e.preventDefault();
          onToggle(e);
        }));
        const onKeydown = composeEventHandlers(stopWhenControlledOrDisabled, (e) => {
          const { code } = e;
          if (props.triggerKeys.includes(code)) {
            e.preventDefault();
            onToggle(e);
          }
        });
        expose({
          triggerRef
        });
        return (_ctx, _cache) => {
          return vue.openBlock(), vue.createBlock(vue.unref(ElPopperTrigger), {
            id: vue.unref(id),
            "virtual-ref": _ctx.virtualRef,
            open: vue.unref(open),
            "virtual-triggering": _ctx.virtualTriggering,
            class: vue.normalizeClass(vue.unref(ns).e("trigger")),
            onBlur: vue.unref(onBlur),
            onClick: vue.unref(onClick),
            onContextmenu: vue.unref(onContextMenu),
            onFocus: vue.unref(onFocus),
            onMouseenter: vue.unref(onMouseenter),
            onMouseleave: vue.unref(onMouseleave),
            onKeydown: vue.unref(onKeydown)
          }, {
            default: vue.withCtx(() => [
              vue.renderSlot(_ctx.$slots, "default")
            ]),
            _: 3
          }, 8, ["id", "virtual-ref", "open", "virtual-triggering", "class", "onBlur", "onClick", "onContextmenu", "onFocus", "onMouseenter", "onMouseleave", "onKeydown"]);
        };
      }
    });
    var ElTooltipTrigger = /* @__PURE__ */ _export_sfc(_sfc_main$23, [["__file", "trigger.vue"]]);
  
    const __default__$1m = vue.defineComponent({
      name: "ElTooltipContent",
      inheritAttrs: false
    });
    const _sfc_main$22 = /* @__PURE__ */ vue.defineComponent({
      ...__default__$1m,
      props: useTooltipContentProps,
      setup(__props, { expose }) {
        const props = __props;
        const contentRef = vue.ref(null);
        const destroyed = vue.ref(false);
        const {
          controlled,
          id,
          open,
          trigger,
          onClose,
          onOpen,
          onShow,
          onHide,
          onBeforeShow,
          onBeforeHide
        } = vue.inject(TOOLTIP_INJECTION_KEY, void 0);
        const persistentRef = vue.computed(() => {
          return props.persistent;
        });
        vue.onBeforeUnmount(() => {
          destroyed.value = true;
        });
        const shouldRender = vue.computed(() => {
          return vue.unref(persistentRef) ? true : vue.unref(open);
        });
        const shouldShow = vue.computed(() => {
          return props.disabled ? false : vue.unref(open);
        });
        const contentStyle = vue.computed(() => {
          var _a;
          return (_a = props.style) != null ? _a : {};
        });
        const ariaHidden = vue.computed(() => !vue.unref(open));
        const onTransitionLeave = () => {
          onHide();
        };
        const stopWhenControlled = () => {
          if (vue.unref(controlled))
            return true;
        };
        const onContentEnter = composeEventHandlers(stopWhenControlled, () => {
          if (props.enterable && vue.unref(trigger) === "hover") {
            onOpen();
          }
        });
        const onContentLeave = composeEventHandlers(stopWhenControlled, () => {
          if (vue.unref(trigger) === "hover") {
            onClose();
          }
        });
        const onBeforeEnter = () => {
          var _a, _b;
          (_b = (_a = contentRef.value) == null ? void 0 : _a.updatePopper) == null ? void 0 : _b.call(_a);
          onBeforeShow == null ? void 0 : onBeforeShow();
        };
        const onBeforeLeave = () => {
          onBeforeHide == null ? void 0 : onBeforeHide();
        };
        const onAfterShow = () => {
          onShow();
          stopHandle = onClickOutside(vue.computed(() => {
            var _a;
            return (_a = contentRef.value) == null ? void 0 : _a.popperContentRef;
          }), () => {
            if (vue.unref(controlled))
              return;
            const $trigger = vue.unref(trigger);
            if ($trigger !== "hover") {
              onClose();
            }
          });
        };
        const onBlur = () => {
          if (!props.virtualTriggering) {
            onClose();
          }
        };
        let stopHandle;
        vue.watch(() => vue.unref(open), (val) => {
          if (!val) {
            stopHandle == null ? void 0 : stopHandle();
          }
        }, {
          flush: "post"
        });
        vue.watch(() => props.content, () => {
          var _a, _b;
          (_b = (_a = contentRef.value) == null ? void 0 : _a.updatePopper) == null ? void 0 : _b.call(_a);
        });
        expose({
          contentRef
        });
        return (_ctx, _cache) => {
          return vue.openBlock(), vue.createBlock(vue.Teleport, {
            disabled: !_ctx.teleported,
            to: _ctx.appendTo
          }, [
            vue.createVNode(vue.Transition, {
              name: _ctx.transition,
              onAfterLeave: onTransitionLeave,
              onBeforeEnter,
              onAfterEnter: onAfterShow,
              onBeforeLeave
            }, {
              default: vue.withCtx(() => [
                vue.unref(shouldRender) ? vue.withDirectives((vue.openBlock(), vue.createBlock(vue.unref(ElPopperContent), vue.mergeProps({
                  key: 0,
                  id: vue.unref(id),
                  ref_key: "contentRef",
                  ref: contentRef
                }, _ctx.$attrs, {
                  "aria-label": _ctx.ariaLabel,
                  "aria-hidden": vue.unref(ariaHidden),
                  "boundaries-padding": _ctx.boundariesPadding,
                  "fallback-placements": _ctx.fallbackPlacements,
                  "gpu-acceleration": _ctx.gpuAcceleration,
                  offset: _ctx.offset,
                  placement: _ctx.placement,
                  "popper-options": _ctx.popperOptions,
                  strategy: _ctx.strategy,
                  effect: _ctx.effect,
                  enterable: _ctx.enterable,
                  pure: _ctx.pure,
                  "popper-class": _ctx.popperClass,
                  "popper-style": [_ctx.popperStyle, vue.unref(contentStyle)],
                  "reference-el": _ctx.referenceEl,
                  "trigger-target-el": _ctx.triggerTargetEl,
                  visible: vue.unref(shouldShow),
                  "z-index": _ctx.zIndex,
                  onMouseenter: vue.unref(onContentEnter),
                  onMouseleave: vue.unref(onContentLeave),
                  onBlur,
                  onClose: vue.unref(onClose)
                }), {
                  default: vue.withCtx(() => [
                    vue.createCommentVNode(" Workaround bug #6378 "),
                    !destroyed.value ? vue.renderSlot(_ctx.$slots, "default", { key: 0 }) : vue.createCommentVNode("v-if", true)
                  ]),
                  _: 3
                }, 16, ["id", "aria-label", "aria-hidden", "boundaries-padding", "fallback-placements", "gpu-acceleration", "offset", "placement", "popper-options", "strategy", "effect", "enterable", "pure", "popper-class", "popper-style", "reference-el", "trigger-target-el", "visible", "z-index", "onMouseenter", "onMouseleave", "onClose"])), [
                  [vue.vShow, vue.unref(shouldShow)]
                ]) : vue.createCommentVNode("v-if", true)
              ]),
              _: 3
            }, 8, ["name"])
          ], 8, ["disabled", "to"]);
        };
      }
    });
    var ElTooltipContent = /* @__PURE__ */ _export_sfc(_sfc_main$22, [["__file", "content.vue"]]);
  
    const _hoisted_1$12 = ["innerHTML"];
    const _hoisted_2$F = { key: 1 };
    const __default__$1l = vue.defineComponent({
      name: "ElTooltip"
    });
    const _sfc_main$21 = /* @__PURE__ */ vue.defineComponent({
      ...__default__$1l,
      props: useTooltipProps,
      emits: tooltipEmits,
      setup(__props, { expose, emit }) {
        const props = __props;
        usePopperContainer();
        const id = useId();
        const popperRef = vue.ref();
        const contentRef = vue.ref();
        const updatePopper = () => {
          var _a;
          const popperComponent = vue.unref(popperRef);
          if (popperComponent) {
            (_a = popperComponent.popperInstanceRef) == null ? void 0 : _a.update();
          }
        };
        const open = vue.ref(false);
        const toggleReason = vue.ref();
        const { show, hide, hasUpdateHandler } = useTooltipModelToggle({
          indicator: open,
          toggleReason
        });
        const { onOpen, onClose } = useDelayedToggle({
          showAfter: vue.toRef(props, "showAfter"),
          hideAfter: vue.toRef(props, "hideAfter"),
          open: show,
          close: hide
        });
        const controlled = vue.computed(() => isBoolean(props.visible) && !hasUpdateHandler.value);
        vue.provide(TOOLTIP_INJECTION_KEY, {
          controlled,
          id,
          open: vue.readonly(open),
          trigger: vue.toRef(props, "trigger"),
          onOpen: (event) => {
            onOpen(event);
          },
          onClose: (event) => {
            onClose(event);
          },
          onToggle: (event) => {
            if (vue.unref(open)) {
              onClose(event);
            } else {
              onOpen(event);
            }
          },
          onShow: () => {
            emit("show", toggleReason.value);
          },
          onHide: () => {
            emit("hide", toggleReason.value);
          },
          onBeforeShow: () => {
            emit("before-show", toggleReason.value);
          },
          onBeforeHide: () => {
            emit("before-hide", toggleReason.value);
          },
          updatePopper
        });
        vue.watch(() => props.disabled, (disabled) => {
          if (disabled && open.value) {
            open.value = false;
          }
        });
        const isFocusInsideContent = () => {
          var _a, _b;
          const popperContent = (_b = (_a = contentRef.value) == null ? void 0 : _a.contentRef) == null ? void 0 : _b.popperContentRef;
          return popperContent && popperContent.contains(document.activeElement);
        };
        vue.onDeactivated(() => open.value && hide());
        expose({
          popperRef,
          contentRef,
          isFocusInsideContent,
          updatePopper,
          onOpen,
          onClose,
          hide
        });
        return (_ctx, _cache) => {
          return vue.openBlock(), vue.createBlock(vue.unref(ElPopper), {
            ref_key: "popperRef",
            ref: popperRef,
            role: _ctx.role
          }, {
            default: vue.withCtx(() => [
              vue.createVNode(ElTooltipTrigger, {
                disabled: _ctx.disabled,
                trigger: _ctx.trigger,
                "trigger-keys": _ctx.triggerKeys,
                "virtual-ref": _ctx.virtualRef,
                "virtual-triggering": _ctx.virtualTriggering
              }, {
                default: vue.withCtx(() => [
                  _ctx.$slots.default ? vue.renderSlot(_ctx.$slots, "default", { key: 0 }) : vue.createCommentVNode("v-if", true)
                ]),
                _: 3
              }, 8, ["disabled", "trigger", "trigger-keys", "virtual-ref", "virtual-triggering"]),
              vue.createVNode(ElTooltipContent, {
                ref_key: "contentRef",
                ref: contentRef,
                "aria-label": _ctx.ariaLabel,
                "boundaries-padding": _ctx.boundariesPadding,
                content: _ctx.content,
                disabled: _ctx.disabled,
                effect: _ctx.effect,
                enterable: _ctx.enterable,
                "fallback-placements": _ctx.fallbackPlacements,
                "hide-after": _ctx.hideAfter,
                "gpu-acceleration": _ctx.gpuAcceleration,
                offset: _ctx.offset,
                persistent: _ctx.persistent,
                "popper-class": _ctx.popperClass,
                "popper-style": _ctx.popperStyle,
                placement: _ctx.placement,
                "popper-options": _ctx.popperOptions,
                pure: _ctx.pure,
                "raw-content": _ctx.rawContent,
                "reference-el": _ctx.referenceEl,
                "trigger-target-el": _ctx.triggerTargetEl,
                "show-after": _ctx.showAfter,
                strategy: _ctx.strategy,
                teleported: _ctx.teleported,
                transition: _ctx.transition,
                "virtual-triggering": _ctx.virtualTriggering,
                "z-index": _ctx.zIndex,
                "append-to": _ctx.appendTo
              }, {
                default: vue.withCtx(() => [
                  vue.renderSlot(_ctx.$slots, "content", {}, () => [
                    _ctx.rawContent ? (vue.openBlock(), vue.createElementBlock("span", {
                      key: 0,
                      innerHTML: _ctx.content
                    }, null, 8, _hoisted_1$12)) : (vue.openBlock(), vue.createElementBlock("span", _hoisted_2$F, vue.toDisplayString(_ctx.content), 1))
                  ]),
                  _ctx.showArrow ? (vue.openBlock(), vue.createBlock(vue.unref(ElPopperArrow), {
                    key: 0,
                    "arrow-offset": _ctx.arrowOffset
                  }, null, 8, ["arrow-offset"])) : vue.createCommentVNode("v-if", true)
                ]),
                _: 3
              }, 8, ["aria-label", "boundaries-padding", "content", "disabled", "effect", "enterable", "fallback-placements", "hide-after", "gpu-acceleration", "offset", "persistent", "popper-class", "popper-style", "placement", "popper-options", "pure", "raw-content", "reference-el", "trigger-target-el", "show-after", "strategy", "teleported", "transition", "virtual-triggering", "z-index", "append-to"])
            ]),
            _: 3
          }, 8, ["role"]);
        };
      }
    });
    var Tooltip = /* @__PURE__ */ _export_sfc(_sfc_main$21, [["__file", "tooltip.vue"]]);
  
    const ElTooltip = withInstall(Tooltip);
  
    const autocompleteProps = buildProps({
      valueKey: {
        type: String,
        default: "value"
      },
      modelValue: {
        type: [String, Number],
        default: ""
      },
      debounce: {
        type: Number,
        default: 300
      },
      placement: {
        type: definePropType(String),
        values: [
          "top",
          "top-start",
          "top-end",
          "bottom",
          "bottom-start",
          "bottom-end"
        ],
        default: "bottom-start"
      },
      fetchSuggestions: {
        type: definePropType([Function, Array]),
        default: NOOP
      },
      popperClass: {
        type: String,
        default: ""
      },
      triggerOnFocus: {
        type: Boolean,
        default: true
      },
      selectWhenUnmatched: {
        type: Boolean,
        default: false
      },
      hideLoading: {
        type: Boolean,
        default: false
      },
      label: {
        type: String
      },
      teleported: useTooltipContentProps.teleported,
      highlightFirstItem: {
        type: Boolean,
        default: false
      },
      fitInputWidth: {
        type: Boolean,
        default: false
      }
    });
    const autocompleteEmits = {
      [UPDATE_MODEL_EVENT]: (value) => isString(value),
      [INPUT_EVENT]: (value) => isString(value),
      [CHANGE_EVENT]: (value) => isString(value),
      focus: (evt) => evt instanceof FocusEvent,
      blur: (evt) => evt instanceof FocusEvent,
      clear: () => true,
      select: (item) => isObject$1(item)
    };
  
    const _hoisted_1$11 = ["aria-expanded", "aria-owns"];
    const _hoisted_2$E = { key: 0 };
    const _hoisted_3$j = ["id", "aria-selected", "onClick"];
    const COMPONENT_NAME$j = "ElAutocomplete";
    const __default__$1k = vue.defineComponent({
      name: COMPONENT_NAME$j,
      inheritAttrs: false
    });
    const _sfc_main$20 = /* @__PURE__ */ vue.defineComponent({
      ...__default__$1k,
      props: autocompleteProps,
      emits: autocompleteEmits,
      setup(__props, { expose, emit }) {
        const props = __props;
        const attrs = useAttrs();
        const rawAttrs = vue.useAttrs();
        const disabled = useDisabled();
        const ns = useNamespace("autocomplete");
        const inputRef = vue.ref();
        const regionRef = vue.ref();
        const popperRef = vue.ref();
        const listboxRef = vue.ref();
        let readonly = false;
        let ignoreFocusEvent = false;
        const suggestions = vue.ref([]);
        const highlightedIndex = vue.ref(-1);
        const dropdownWidth = vue.ref("");
        const activated = vue.ref(false);
        const suggestionDisabled = vue.ref(false);
        const loading = vue.ref(false);
        const listboxId = vue.computed(() => ns.b(String(generateId())));
        const styles = vue.computed(() => rawAttrs.style);
        const suggestionVisible = vue.computed(() => {
          const isValidData = suggestions.value.length > 0;
          return (isValidData || loading.value) && activated.value;
        });
        const suggestionLoading = vue.computed(() => !props.hideLoading && loading.value);
        const refInput = vue.computed(() => {
          if (inputRef.value) {
            return Array.from(inputRef.value.$el.querySelectorAll("input"));
          }
          return [];
        });
        const onSuggestionShow = async () => {
          await vue.nextTick();
          if (suggestionVisible.value) {
            dropdownWidth.value = `${inputRef.value.$el.offsetWidth}px`;
          }
        };
        const onShow = () => {
          ignoreFocusEvent = true;
        };
        const onHide = () => {
          ignoreFocusEvent = false;
          highlightedIndex.value = -1;
        };
        const getData = async (queryString) => {
          if (suggestionDisabled.value)
            return;
          const cb = (suggestionList) => {
            loading.value = false;
            if (suggestionDisabled.value)
              return;
            if (isArray(suggestionList)) {
              suggestions.value = suggestionList;
              highlightedIndex.value = props.highlightFirstItem ? 0 : -1;
            } else {
              throwError(COMPONENT_NAME$j, "autocomplete suggestions must be an array");
            }
          };
          loading.value = true;
          if (isArray(props.fetchSuggestions)) {
            cb(props.fetchSuggestions);
          } else {
            const result = await props.fetchSuggestions(queryString, cb);
            if (isArray(result))
              cb(result);
          }
        };
        const debouncedGetData = debounce(getData, props.debounce);
        const handleInput = (value) => {
          const valuePresented = !!value;
          emit(INPUT_EVENT, value);
          emit(UPDATE_MODEL_EVENT, value);
          suggestionDisabled.value = false;
          activated.value || (activated.value = valuePresented);
          if (!props.triggerOnFocus && !value) {
            suggestionDisabled.value = true;
            suggestions.value = [];
            return;
          }
          debouncedGetData(value);
        };
        const handleMouseDown = (event) => {
          var _a;
          if (disabled.value)
            return;
          if (((_a = event.target) == null ? void 0 : _a.tagName) !== "INPUT" || refInput.value.includes(document.activeElement)) {
            activated.value = true;
          }
        };
        const handleChange = (value) => {
          emit(CHANGE_EVENT, value);
        };
        const handleFocus = (evt) => {
          if (ignoreFocusEvent)
            return;
          activated.value = true;
          emit("focus", evt);
          if (props.triggerOnFocus && !readonly) {
            debouncedGetData(String(props.modelValue));
          }
        };
        const handleBlur = (evt) => {
          if (ignoreFocusEvent)
            return;
          emit("blur", evt);
        };
        const handleClear = () => {
          activated.value = false;
          emit(UPDATE_MODEL_EVENT, "");
          emit("clear");
        };
        const handleKeyEnter = async () => {
          if (suggestionVisible.value && highlightedIndex.value >= 0 && highlightedIndex.value < suggestions.value.length) {
            handleSelect(suggestions.value[highlightedIndex.value]);
          } else if (props.selectWhenUnmatched) {
            emit("select", { value: props.modelValue });
            suggestions.value = [];
            highlightedIndex.value = -1;
          }
        };
        const handleKeyEscape = (evt) => {
          if (suggestionVisible.value) {
            evt.preventDefault();
            evt.stopPropagation();
            close();
          }
        };
        const close = () => {
          activated.value = false;
        };
        const focus = () => {
          var _a;
          (_a = inputRef.value) == null ? void 0 : _a.focus();
        };
        const blur = () => {
          var _a;
          (_a = inputRef.value) == null ? void 0 : _a.blur();
        };
        const handleSelect = async (item) => {
          emit(INPUT_EVENT, item[props.valueKey]);
          emit(UPDATE_MODEL_EVENT, item[props.valueKey]);
          emit("select", item);
          suggestions.value = [];
          highlightedIndex.value = -1;
        };
        const highlight = (index) => {
          if (!suggestionVisible.value || loading.value)
            return;
          if (index < 0) {
            highlightedIndex.value = -1;
            return;
          }
          if (index >= suggestions.value.length) {
            index = suggestions.value.length - 1;
          }
          const suggestion = regionRef.value.querySelector(`.${ns.be("suggestion", "wrap")}`);
          const suggestionList = suggestion.querySelectorAll(`.${ns.be("suggestion", "list")} li`);
          const highlightItem = suggestionList[index];
          const scrollTop = suggestion.scrollTop;
          const { offsetTop, scrollHeight } = highlightItem;
          if (offsetTop + scrollHeight > scrollTop + suggestion.clientHeight) {
            suggestion.scrollTop += scrollHeight;
          }
          if (offsetTop < scrollTop) {
            suggestion.scrollTop -= scrollHeight;
          }
          highlightedIndex.value = index;
          inputRef.value.ref.setAttribute("aria-activedescendant", `${listboxId.value}-item-${highlightedIndex.value}`);
        };
        onClickOutside(listboxRef, () => {
          suggestionVisible.value && close();
        });
        vue.onMounted(() => {
          inputRef.value.ref.setAttribute("role", "textbox");
          inputRef.value.ref.setAttribute("aria-autocomplete", "list");
          inputRef.value.ref.setAttribute("aria-controls", "id");
          inputRef.value.ref.setAttribute("aria-activedescendant", `${listboxId.value}-item-${highlightedIndex.value}`);
          readonly = inputRef.value.ref.hasAttribute("readonly");
        });
        expose({
          highlightedIndex,
          activated,
          loading,
          inputRef,
          popperRef,
          suggestions,
          handleSelect,
          handleKeyEnter,
          focus,
          blur,
          close,
          highlight
        });
        return (_ctx, _cache) => {
          return vue.openBlock(), vue.createBlock(vue.unref(ElTooltip), {
            ref_key: "popperRef",
            ref: popperRef,
            visible: vue.unref(suggestionVisible),
            placement: _ctx.placement,
            "fallback-placements": ["bottom-start", "top-start"],
            "popper-class": [vue.unref(ns).e("popper"), _ctx.popperClass],
            teleported: _ctx.teleported,
            "gpu-acceleration": false,
            pure: "",
            "manual-mode": "",
            effect: "light",
            trigger: "click",
            transition: `${vue.unref(ns).namespace.value}-zoom-in-top`,
            persistent: "",
            onBeforeShow: onSuggestionShow,
            onShow,
            onHide
          }, {
            content: vue.withCtx(() => [
              vue.createElementVNode("div", {
                ref_key: "regionRef",
                ref: regionRef,
                class: vue.normalizeClass([vue.unref(ns).b("suggestion"), vue.unref(ns).is("loading", vue.unref(suggestionLoading))]),
                style: vue.normalizeStyle({
                  [_ctx.fitInputWidth ? "width" : "minWidth"]: dropdownWidth.value,
                  outline: "none"
                }),
                role: "region"
              }, [
                vue.createVNode(vue.unref(ElScrollbar), {
                  id: vue.unref(listboxId),
                  tag: "ul",
                  "wrap-class": vue.unref(ns).be("suggestion", "wrap"),
                  "view-class": vue.unref(ns).be("suggestion", "list"),
                  role: "listbox"
                }, {
                  default: vue.withCtx(() => [
                    vue.unref(suggestionLoading) ? (vue.openBlock(), vue.createElementBlock("li", _hoisted_2$E, [
                      vue.createVNode(vue.unref(ElIcon), {
                        class: vue.normalizeClass(vue.unref(ns).is("loading"))
                      }, {
                        default: vue.withCtx(() => [
                          vue.createVNode(vue.unref(loading_default))
                        ]),
                        _: 1
                      }, 8, ["class"])
                    ])) : (vue.openBlock(true), vue.createElementBlock(vue.Fragment, { key: 1 }, vue.renderList(suggestions.value, (item, index) => {
                      return vue.openBlock(), vue.createElementBlock("li", {
                        id: `${vue.unref(listboxId)}-item-${index}`,
                        key: index,
                        class: vue.normalizeClass({ highlighted: highlightedIndex.value === index }),
                        role: "option",
                        "aria-selected": highlightedIndex.value === index,
                        onClick: ($event) => handleSelect(item)
                      }, [
                        vue.renderSlot(_ctx.$slots, "default", { item }, () => [
                          vue.createTextVNode(vue.toDisplayString(item[_ctx.valueKey]), 1)
                        ])
                      ], 10, _hoisted_3$j);
                    }), 128))
                  ]),
                  _: 3
                }, 8, ["id", "wrap-class", "view-class"])
              ], 6)
            ]),
            default: vue.withCtx(() => [
              vue.createElementVNode("div", {
                ref_key: "listboxRef",
                ref: listboxRef,
                class: vue.normalizeClass([vue.unref(ns).b(), _ctx.$attrs.class]),
                style: vue.normalizeStyle(vue.unref(styles)),
                role: "combobox",
                "aria-haspopup": "listbox",
                "aria-expanded": vue.unref(suggestionVisible),
                "aria-owns": vue.unref(listboxId)
              }, [
                vue.createVNode(vue.unref(ElInput), vue.mergeProps({
                  ref_key: "inputRef",
                  ref: inputRef
                }, vue.unref(attrs), {
                  "model-value": _ctx.modelValue,
                  onInput: handleInput,
                  onChange: handleChange,
                  onFocus: handleFocus,
                  onBlur: handleBlur,
                  onClear: handleClear,
                  onKeydown: [
                    _cache[0] || (_cache[0] = vue.withKeys(vue.withModifiers(($event) => highlight(highlightedIndex.value - 1), ["prevent"]), ["up"])),
                    _cache[1] || (_cache[1] = vue.withKeys(vue.withModifiers(($event) => highlight(highlightedIndex.value + 1), ["prevent"]), ["down"])),
                    vue.withKeys(handleKeyEnter, ["enter"]),
                    vue.withKeys(close, ["tab"]),
                    vue.withKeys(handleKeyEscape, ["esc"])
                  ],
                  onMousedown: handleMouseDown
                }), vue.createSlots({ _: 2 }, [
                  _ctx.$slots.prepend ? {
                    name: "prepend",
                    fn: vue.withCtx(() => [
                      vue.renderSlot(_ctx.$slots, "prepend")
                    ])
                  } : void 0,
                  _ctx.$slots.append ? {
                    name: "append",
                    fn: vue.withCtx(() => [
                      vue.renderSlot(_ctx.$slots, "append")
                    ])
                  } : void 0,
                  _ctx.$slots.prefix ? {
                    name: "prefix",
                    fn: vue.withCtx(() => [
                      vue.renderSlot(_ctx.$slots, "prefix")
                    ])
                  } : void 0,
                  _ctx.$slots.suffix ? {
                    name: "suffix",
                    fn: vue.withCtx(() => [
                      vue.renderSlot(_ctx.$slots, "suffix")
                    ])
                  } : void 0
                ]), 1040, ["model-value", "onKeydown"])
              ], 14, _hoisted_1$11)
            ]),
            _: 3
          }, 8, ["visible", "placement", "popper-class", "teleported", "transition"]);
        };
      }
    });
    var Autocomplete = /* @__PURE__ */ _export_sfc(_sfc_main$20, [["__file", "autocomplete.vue"]]);
  
    const ElAutocomplete = withInstall(Autocomplete);
  
    const avatarProps = buildProps({
      size: {
        type: [Number, String],
        values: componentSizes,
        default: "",
        validator: (val) => isNumber(val)
      },
      shape: {
        type: String,
        values: ["circle", "square"],
        default: "circle"
      },
      icon: {
        type: iconPropType
      },
      src: {
        type: String,
        default: ""
      },
      alt: String,
      srcSet: String,
      fit: {
        type: definePropType(String),
        default: "cover"
      }
    });
    const avatarEmits = {
      error: (evt) => evt instanceof Event
    };
  
    const _hoisted_1$10 = ["src", "alt", "srcset"];
    const __default__$1j = vue.defineComponent({
      name: "ElAvatar"
    });
    const _sfc_main$1$ = /* @__PURE__ */ vue.defineComponent({
      ...__default__$1j,
      props: avatarProps,
      emits: avatarEmits,
      setup(__props, { emit }) {
        const props = __props;
        const ns = useNamespace("avatar");
        const hasLoadError = vue.ref(false);
        const avatarClass = vue.computed(() => {
          const { size, icon, shape } = props;
          const classList = [ns.b()];
          if (isString(size))
            classList.push(ns.m(size));
          if (icon)
            classList.push(ns.m("icon"));
          if (shape)
            classList.push(ns.m(shape));
          return classList;
        });
        const sizeStyle = vue.computed(() => {
          const { size } = props;
          return isNumber(size) ? ns.cssVarBlock({
            size: addUnit(size) || ""
          }) : void 0;
        });
        const fitStyle = vue.computed(() => ({
          objectFit: props.fit
        }));
        vue.watch(() => props.src, () => hasLoadError.value = false);
        function handleError(e) {
          hasLoadError.value = true;
          emit("error", e);
        }
        return (_ctx, _cache) => {
          return vue.openBlock(), vue.createElementBlock("span", {
            class: vue.normalizeClass(vue.unref(avatarClass)),
            style: vue.normalizeStyle(vue.unref(sizeStyle))
          }, [
            (_ctx.src || _ctx.srcSet) && !hasLoadError.value ? (vue.openBlock(), vue.createElementBlock("img", {
              key: 0,
              src: _ctx.src,
              alt: _ctx.alt,
              srcset: _ctx.srcSet,
              style: vue.normalizeStyle(vue.unref(fitStyle)),
              onError: handleError
            }, null, 44, _hoisted_1$10)) : _ctx.icon ? (vue.openBlock(), vue.createBlock(vue.unref(ElIcon), { key: 1 }, {
              default: vue.withCtx(() => [
                (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(_ctx.icon)))
              ]),
              _: 1
            })) : vue.renderSlot(_ctx.$slots, "default", { key: 2 })
          ], 6);
        };
      }
    });
    var Avatar = /* @__PURE__ */ _export_sfc(_sfc_main$1$, [["__file", "avatar.vue"]]);
  
    const ElAvatar = withInstall(Avatar);
  
    const backtopProps = {
      visibilityHeight: {
        type: Number,
        default: 200
      },
      target: {
        type: String,
        default: ""
      },
      right: {
        type: Number,
        default: 40
      },
      bottom: {
        type: Number,
        default: 40
      }
    };
    const backtopEmits = {
      click: (evt) => evt instanceof MouseEvent
    };
  
    const useBackTop = (props, emit, componentName) => {
      const el = vue.shallowRef();
      const container = vue.shallowRef();
      const visible = vue.ref(false);
      const scrollToTop = () => {
        if (!el.value)
          return;
        const beginTime = Date.now();
        const beginValue = el.value.scrollTop;
        const frameFunc = () => {
          if (!el.value)
            return;
          const progress = (Date.now() - beginTime) / 500;
          if (progress < 1) {
            el.value.scrollTop = beginValue * (1 - easeInOutCubic(progress));
            requestAnimationFrame(frameFunc);
          } else {
            el.value.scrollTop = 0;
          }
        };
        requestAnimationFrame(frameFunc);
      };
      const handleScroll = () => {
        if (el.value)
          visible.value = el.value.scrollTop >= props.visibilityHeight;
      };
      const handleClick = (event) => {
        scrollToTop();
        emit("click", event);
      };
      const handleScrollThrottled = useThrottleFn(handleScroll, 300, true);
      useEventListener(container, "scroll", handleScrollThrottled);
      vue.onMounted(() => {
        var _a;
        container.value = document;
        el.value = document.documentElement;
        if (props.target) {
          el.value = (_a = document.querySelector(props.target)) != null ? _a : void 0;
          if (!el.value) {
            throwError(componentName, `target does not exist: ${props.target}`);
          }
          container.value = el.value;
        }
      });
      return {
        visible,
        handleClick
      };
    };
  
    const COMPONENT_NAME$i = "ElBacktop";
    const __default__$1i = vue.defineComponent({
      name: COMPONENT_NAME$i
    });
    const _sfc_main$1_ = /* @__PURE__ */ vue.defineComponent({
      ...__default__$1i,
      props: backtopProps,
      emits: backtopEmits,
      setup(__props, { emit }) {
        const props = __props;
        const ns = useNamespace("backtop");
        const { handleClick, visible } = useBackTop(props, emit, COMPONENT_NAME$i);
        const backTopStyle = vue.computed(() => ({
          right: `${props.right}px`,
          bottom: `${props.bottom}px`
        }));
        return (_ctx, _cache) => {
          return vue.openBlock(), vue.createBlock(vue.Transition, {
            name: `${vue.unref(ns).namespace.value}-fade-in`
          }, {
            default: vue.withCtx(() => [
              vue.unref(visible) ? (vue.openBlock(), vue.createElementBlock("div", {
                key: 0,
                style: vue.normalizeStyle(vue.unref(backTopStyle)),
                class: vue.normalizeClass(vue.unref(ns).b()),
                onClick: _cache[0] || (_cache[0] = vue.withModifiers((...args) => vue.unref(handleClick) && vue.unref(handleClick)(...args), ["stop"]))
              }, [
                vue.renderSlot(_ctx.$slots, "default", {}, () => [
                  vue.createVNode(vue.unref(ElIcon), {
                    class: vue.normalizeClass(vue.unref(ns).e("icon"))
                  }, {
                    default: vue.withCtx(() => [
                      vue.createVNode(vue.unref(caret_top_default))
                    ]),
                    _: 1
                  }, 8, ["class"])
                ])
              ], 6)) : vue.createCommentVNode("v-if", true)
            ]),
            _: 3
          }, 8, ["name"]);
        };
      }
    });
    var Backtop = /* @__PURE__ */ _export_sfc(_sfc_main$1_, [["__file", "backtop.vue"]]);
  
    const ElBacktop = withInstall(Backtop);
  
    const badgeProps = buildProps({
      value: {
        type: [String, Number],
        default: ""
      },
      max: {
        type: Number,
        default: 99
      },
      isDot: Boolean,
      hidden: Boolean,
      type: {
        type: String,
        values: ["primary", "success", "warning", "info", "danger"],
        default: "danger"
      }
    });
  
    const _hoisted_1$$ = ["textContent"];
    const __default__$1h = vue.defineComponent({
      name: "ElBadge"
    });
    const _sfc_main$1Z = /* @__PURE__ */ vue.defineComponent({
      ...__default__$1h,
      props: badgeProps,
      setup(__props, { expose }) {
        const props = __props;
        const ns = useNamespace("badge");
        const content = vue.computed(() => {
          if (props.isDot)
            return "";
          if (isNumber(props.value) && isNumber(props.max)) {
            return props.max < props.value ? `${props.max}+` : `${props.value}`;
          }
          return `${props.value}`;
        });
        expose({
          content
        });
        return (_ctx, _cache) => {
          return vue.openBlock(), vue.createElementBlock("div", {
            class: vue.normalizeClass(vue.unref(ns).b())
          }, [
            vue.renderSlot(_ctx.$slots, "default"),
            vue.createVNode(vue.Transition, {
              name: `${vue.unref(ns).namespace.value}-zoom-in-center`,
              persisted: ""
            }, {
              default: vue.withCtx(() => [
                vue.withDirectives(vue.createElementVNode("sup", {
                  class: vue.normalizeClass([
                    vue.unref(ns).e("content"),
                    vue.unref(ns).em("content", _ctx.type),
                    vue.unref(ns).is("fixed", !!_ctx.$slots.default),
                    vue.unref(ns).is("dot", _ctx.isDot)
                  ]),
                  textContent: vue.toDisplayString(vue.unref(content))
                }, null, 10, _hoisted_1$$), [
                  [vue.vShow, !_ctx.hidden && (vue.unref(content) || _ctx.isDot)]
                ])
              ]),
              _: 1
            }, 8, ["name"])
          ], 2);
        };
      }
    });
    var Badge = /* @__PURE__ */ _export_sfc(_sfc_main$1Z, [["__file", "badge.vue"]]);
  
    const ElBadge = withInstall(Badge);
  
    const breadcrumbProps = buildProps({
      separator: {
        type: String,
        default: "/"
      },
      separatorIcon: {
        type: iconPropType
      }
    });
  
    const __default__$1g = vue.defineComponent({
      name: "ElBreadcrumb"
    });
    const _sfc_main$1Y = /* @__PURE__ */ vue.defineComponent({
      ...__default__$1g,
      props: breadcrumbProps,
      setup(__props) {
        const props = __props;
        const ns = useNamespace("breadcrumb");
        const breadcrumb = vue.ref();
        vue.provide(breadcrumbKey, props);
        vue.onMounted(() => {
          const items = breadcrumb.value.querySelectorAll(`.${ns.e("item")}`);
          if (items.length) {
            items[items.length - 1].setAttribute("aria-current", "page");
          }
        });
        return (_ctx, _cache) => {
          return vue.openBlock(), vue.createElementBlock("div", {
            ref_key: "breadcrumb",
            ref: breadcrumb,
            class: vue.normalizeClass(vue.unref(ns).b()),
            "aria-label": "Breadcrumb",
            role: "navigation"
          }, [
            vue.renderSlot(_ctx.$slots, "default")
          ], 2);
        };
      }
    });
    var Breadcrumb = /* @__PURE__ */ _export_sfc(_sfc_main$1Y, [["__file", "breadcrumb.vue"]]);
  
    const breadcrumbItemProps = buildProps({
      to: {
        type: definePropType([String, Object]),
        default: ""
      },
      replace: {
        type: Boolean,
        default: false
      }
    });
  
    const __default__$1f = vue.defineComponent({
      name: "ElBreadcrumbItem"
    });
    const _sfc_main$1X = /* @__PURE__ */ vue.defineComponent({
      ...__default__$1f,
      props: breadcrumbItemProps,
      setup(__props) {
        const props = __props;
        const instance = vue.getCurrentInstance();
        const breadcrumbContext = vue.inject(breadcrumbKey, void 0);
        const ns = useNamespace("breadcrumb");
        const { separator, separatorIcon } = vue.toRefs(breadcrumbContext);
        const router = instance.appContext.config.globalProperties.$router;
        const link = vue.ref();
        const onClick = () => {
          if (!props.to || !router)
            return;
          props.replace ? router.replace(props.to) : router.push(props.to);
        };
        return (_ctx, _cache) => {
          return vue.openBlock(), vue.createElementBlock("span", {
            class: vue.normalizeClass(vue.unref(ns).e("item"))
          }, [
            vue.createElementVNode("span", {
              ref_key: "link",
              ref: link,
              class: vue.normalizeClass([vue.unref(ns).e("inner"), vue.unref(ns).is("link", !!_ctx.to)]),
              role: "link",
              onClick
            }, [
              vue.renderSlot(_ctx.$slots, "default")
            ], 2),
            vue.unref(separatorIcon) ? (vue.openBlock(), vue.createBlock(vue.unref(ElIcon), {
              key: 0,
              class: vue.normalizeClass(vue.unref(ns).e("separator"))
            }, {
              default: vue.withCtx(() => [
                (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(vue.unref(separatorIcon))))
              ]),
              _: 1
            }, 8, ["class"])) : (vue.openBlock(), vue.createElementBlock("span", {
              key: 1,
              class: vue.normalizeClass(vue.unref(ns).e("separator")),
              role: "presentation"
            }, vue.toDisplayString(vue.unref(separator)), 3))
          ], 2);
        };
      }
    });
    var BreadcrumbItem = /* @__PURE__ */ _export_sfc(_sfc_main$1X, [["__file", "breadcrumb-item.vue"]]);
  
    const ElBreadcrumb = withInstall(Breadcrumb, {
      BreadcrumbItem
    });
    const ElBreadcrumbItem = withNoopInstall(BreadcrumbItem);
  
    const useButton = (props, emit) => {
      useDeprecated({
        from: "type.text",
        replacement: "link",
        version: "3.0.0",
        scope: "props",
        ref: "https://element-plus.org/en-US/component/button.html#button-attributes"
      }, vue.computed(() => props.type === "text"));
      const buttonGroupContext = vue.inject(buttonGroupContextKey, void 0);
      const globalConfig = useGlobalConfig("button");
      const { form } = useFormItem();
      const _size = useSize(vue.computed(() => buttonGroupContext == null ? void 0 : buttonGroupContext.size));
      const _disabled = useDisabled();
      const _ref = vue.ref();
      const slots = vue.useSlots();
      const _type = vue.computed(() => props.type || (buttonGroupContext == null ? void 0 : buttonGroupContext.type) || "");
      const autoInsertSpace = vue.computed(() => {
        var _a, _b, _c;
        return (_c = (_b = props.autoInsertSpace) != null ? _b : (_a = globalConfig.value) == null ? void 0 : _a.autoInsertSpace) != null ? _c : false;
      });
      const shouldAddSpace = vue.computed(() => {
        var _a;
        const defaultSlot = (_a = slots.default) == null ? void 0 : _a.call(slots);
        if (autoInsertSpace.value && (defaultSlot == null ? void 0 : defaultSlot.length) === 1) {
          const slot = defaultSlot[0];
          if ((slot == null ? void 0 : slot.type) === vue.Text) {
            const text = slot.children;
            return /^\p{Unified_Ideograph}{2}$/u.test(text.trim());
          }
        }
        return false;
      });
      const handleClick = (evt) => {
        if (props.nativeType === "reset") {
          form == null ? void 0 : form.resetFields();
        }
        emit("click", evt);
      };
      return {
        _disabled,
        _size,
        _type,
        _ref,
        shouldAddSpace,
        handleClick
      };
    };
  
    const buttonTypes = [
      "default",
      "primary",
      "success",
      "warning",
      "info",
      "danger",
      "text",
      ""
    ];
    const buttonNativeTypes = ["button", "submit", "reset"];
    const buttonProps = buildProps({
      size: useSizeProp,
      disabled: Boolean,
      type: {
        type: String,
        values: buttonTypes,
        default: ""
      },
      icon: {
        type: iconPropType
      },
      nativeType: {
        type: String,
        values: buttonNativeTypes,
        default: "button"
      },
      loading: Boolean,
      loadingIcon: {
        type: iconPropType,
        default: () => loading_default
      },
      plain: Boolean,
      text: Boolean,
      link: Boolean,
      bg: Boolean,
      autofocus: Boolean,
      round: Boolean,
      circle: Boolean,
      color: String,
      dark: Boolean,
      autoInsertSpace: {
        type: Boolean,
        default: void 0
      }
    });
    const buttonEmits = {
      click: (evt) => evt instanceof MouseEvent
    };
  
    function bound01$1(n, max) {
      if (isOnePointZero$1(n)) {
        n = "100%";
      }
      var isPercent = isPercentage$1(n);
      n = max === 360 ? n : Math.min(max, Math.max(0, parseFloat(n)));
      if (isPercent) {
        n = parseInt(String(n * max), 10) / 100;
      }
      if (Math.abs(n - max) < 1e-6) {
        return 1;
      }
      if (max === 360) {
        n = (n < 0 ? n % max + max : n % max) / parseFloat(String(max));
      } else {
        n = n % max / parseFloat(String(max));
      }
      return n;
    }
    function clamp01(val) {
      return Math.min(1, Math.max(0, val));
    }
    function isOnePointZero$1(n) {
      return typeof n === "string" && n.indexOf(".") !== -1 && parseFloat(n) === 1;
    }
    function isPercentage$1(n) {
      return typeof n === "string" && n.indexOf("%") !== -1;
    }
    function boundAlpha(a) {
      a = parseFloat(a);
      if (isNaN(a) || a < 0 || a > 1) {
        a = 1;
      }
      return a;
    }
    function convertToPercentage(n) {
      if (n <= 1) {
        return "".concat(Number(n) * 100, "%");
      }
      return n;
    }
    function pad2(c) {
      return c.length === 1 ? "0" + c : String(c);
    }
  
    function rgbToRgb(r, g, b) {
      return {
        r: bound01$1(r, 255) * 255,
        g: bound01$1(g, 255) * 255,
        b: bound01$1(b, 255) * 255
      };
    }
    function rgbToHsl(r, g, b) {
      r = bound01$1(r, 255);
      g = bound01$1(g, 255);
      b = bound01$1(b, 255);
      var max = Math.max(r, g, b);
      var min = Math.min(r, g, b);
      var h = 0;
      var s = 0;
      var l = (max + min) / 2;
      if (max === min) {
        s = 0;
        h = 0;
      } else {
        var d = max - min;
        s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
        switch (max) {
          case r:
            h = (g - b) / d + (g < b ? 6 : 0);
            break;
          case g:
            h = (b - r) / d + 2;
            break;
          case b:
            h = (r - g) / d + 4;
            break;
        }
        h /= 6;
      }
      return { h, s, l };
    }
    function hue2rgb(p, q, t) {
      if (t < 0) {
        t += 1;
      }
      if (t > 1) {
        t -= 1;
      }
      if (t < 1 / 6) {
        return p + (q - p) * (6 * t);
      }
      if (t < 1 / 2) {
        return q;
      }
      if (t < 2 / 3) {
        return p + (q - p) * (2 / 3 - t) * 6;
      }
      return p;
    }
    function hslToRgb(h, s, l) {
      var r;
      var g;
      var b;
      h = bound01$1(h, 360);
      s = bound01$1(s, 100);
      l = bound01$1(l, 100);
      if (s === 0) {
        g = l;
        b = l;
        r = l;
      } else {
        var q = l < 0.5 ? l * (1 + s) : l + s - l * s;
        var p = 2 * l - q;
        r = hue2rgb(p, q, h + 1 / 3);
        g = hue2rgb(p, q, h);
        b = hue2rgb(p, q, h - 1 / 3);
      }
      return { r: r * 255, g: g * 255, b: b * 255 };
    }
    function rgbToHsv(r, g, b) {
      r = bound01$1(r, 255);
      g = bound01$1(g, 255);
      b = bound01$1(b, 255);
      var max = Math.max(r, g, b);
      var min = Math.min(r, g, b);
      var h = 0;
      var v = max;
      var d = max - min;
      var s = max === 0 ? 0 : d / max;
      if (max === min) {
        h = 0;
      } else {
        switch (max) {
          case r:
            h = (g - b) / d + (g < b ? 6 : 0);
            break;
          case g:
            h = (b - r) / d + 2;
            break;
          case b:
            h = (r - g) / d + 4;
            break;
        }
        h /= 6;
      }
      return { h, s, v };
    }
    function hsvToRgb(h, s, v) {
      h = bound01$1(h, 360) * 6;
      s = bound01$1(s, 100);
      v = bound01$1(v, 100);
      var i = Math.floor(h);
      var f = h - i;
      var p = v * (1 - s);
      var q = v * (1 - f * s);
      var t = v * (1 - (1 - f) * s);
      var mod = i % 6;
      var r = [v, q, p, p, t, v][mod];
      var g = [t, v, v, q, p, p][mod];
      var b = [p, p, t, v, v, q][mod];
      return { r: r * 255, g: g * 255, b: b * 255 };
    }
    function rgbToHex(r, g, b, allow3Char) {
      var hex = [
        pad2(Math.round(r).toString(16)),
        pad2(Math.round(g).toString(16)),
        pad2(Math.round(b).toString(16))
      ];
      if (allow3Char && hex[0].startsWith(hex[0].charAt(1)) && hex[1].startsWith(hex[1].charAt(1)) && hex[2].startsWith(hex[2].charAt(1))) {
        return hex[0].charAt(0) + hex[1].charAt(0) + hex[2].charAt(0);
      }
      return hex.join("");
    }
    function rgbaToHex(r, g, b, a, allow4Char) {
      var hex = [
        pad2(Math.round(r).toString(16)),
        pad2(Math.round(g).toString(16)),
        pad2(Math.round(b).toString(16)),
        pad2(convertDecimalToHex(a))
      ];
      if (allow4Char && hex[0].startsWith(hex[0].charAt(1)) && hex[1].startsWith(hex[1].charAt(1)) && hex[2].startsWith(hex[2].charAt(1)) && hex[3].startsWith(hex[3].charAt(1))) {
        return hex[0].charAt(0) + hex[1].charAt(0) + hex[2].charAt(0) + hex[3].charAt(0);
      }
      return hex.join("");
    }
    function convertDecimalToHex(d) {
      return Math.round(parseFloat(d) * 255).toString(16);
    }
    function convertHexToDecimal(h) {
      return parseIntFromHex(h) / 255;
    }
    function parseIntFromHex(val) {
      return parseInt(val, 16);
    }
    function numberInputToObject(color) {
      return {
        r: color >> 16,
        g: (color & 65280) >> 8,
        b: color & 255
      };
    }
  
    var names = {
      aliceblue: "#f0f8ff",
      antiquewhite: "#faebd7",
      aqua: "#00ffff",
      aquamarine: "#7fffd4",
      azure: "#f0ffff",
      beige: "#f5f5dc",
      bisque: "#ffe4c4",
      black: "#000000",
      blanchedalmond: "#ffebcd",
      blue: "#0000ff",
      blueviolet: "#8a2be2",
      brown: "#a52a2a",
      burlywood: "#deb887",
      cadetblue: "#5f9ea0",
      chartreuse: "#7fff00",
      chocolate: "#d2691e",
      coral: "#ff7f50",
      cornflowerblue: "#6495ed",
      cornsilk: "#fff8dc",
      crimson: "#dc143c",
      cyan: "#00ffff",
      darkblue: "#00008b",
      darkcyan: "#008b8b",
      darkgoldenrod: "#b8860b",
      darkgray: "#a9a9a9",
      darkgreen: "#006400",
      darkgrey: "#a9a9a9",
      darkkhaki: "#bdb76b",
      darkmagenta: "#8b008b",
      darkolivegreen: "#556b2f",
      darkorange: "#ff8c00",
      darkorchid: "#9932cc",
      darkred: "#8b0000",
      darksalmon: "#e9967a",
      darkseagreen: "#8fbc8f",
      darkslateblue: "#483d8b",
      darkslategray: "#2f4f4f",
      darkslategrey: "#2f4f4f",
      darkturquoise: "#00ced1",
      darkviolet: "#9400d3",
      deeppink: "#ff1493",
      deepskyblue: "#00bfff",
      dimgray: "#696969",
      dimgrey: "#696969",
      dodgerblue: "#1e90ff",
      firebrick: "#b22222",
      floralwhite: "#fffaf0",
      forestgreen: "#228b22",
      fuchsia: "#ff00ff",
      gainsboro: "#dcdcdc",
      ghostwhite: "#f8f8ff",
      goldenrod: "#daa520",
      gold: "#ffd700",
      gray: "#808080",
      green: "#008000",
      greenyellow: "#adff2f",
      grey: "#808080",
      honeydew: "#f0fff0",
      hotpink: "#ff69b4",
      indianred: "#cd5c5c",
      indigo: "#4b0082",
      ivory: "#fffff0",
      khaki: "#f0e68c",
      lavenderblush: "#fff0f5",
      lavender: "#e6e6fa",
      lawngreen: "#7cfc00",
      lemonchiffon: "#fffacd",
      lightblue: "#add8e6",
      lightcoral: "#f08080",
      lightcyan: "#e0ffff",
      lightgoldenrodyellow: "#fafad2",
      lightgray: "#d3d3d3",
      lightgreen: "#90ee90",
      lightgrey: "#d3d3d3",
      lightpink: "#ffb6c1",
      lightsalmon: "#ffa07a",
      lightseagreen: "#20b2aa",
      lightskyblue: "#87cefa",
      lightslategray: "#778899",
      lightslategrey: "#778899",
      lightsteelblue: "#b0c4de",
      lightyellow: "#ffffe0",
      lime: "#00ff00",
      limegreen: "#32cd32",
      linen: "#faf0e6",
      magenta: "#ff00ff",
      maroon: "#800000",
      mediumaquamarine: "#66cdaa",
      mediumblue: "#0000cd",
      mediumorchid: "#ba55d3",
      mediumpurple: "#9370db",
      mediumseagreen: "#3cb371",
      mediumslateblue: "#7b68ee",
      mediumspringgreen: "#00fa9a",
      mediumturquoise: "#48d1cc",
      mediumvioletred: "#c71585",
      midnightblue: "#191970",
      mintcream: "#f5fffa",
      mistyrose: "#ffe4e1",
      moccasin: "#ffe4b5",
      navajowhite: "#ffdead",
      navy: "#000080",
      oldlace: "#fdf5e6",
      olive: "#808000",
      olivedrab: "#6b8e23",
      orange: "#ffa500",
      orangered: "#ff4500",
      orchid: "#da70d6",
      palegoldenrod: "#eee8aa",
      palegreen: "#98fb98",
      paleturquoise: "#afeeee",
      palevioletred: "#db7093",
      papayawhip: "#ffefd5",
      peachpuff: "#ffdab9",
      peru: "#cd853f",
      pink: "#ffc0cb",
      plum: "#dda0dd",
      powderblue: "#b0e0e6",
      purple: "#800080",
      rebeccapurple: "#663399",
      red: "#ff0000",
      rosybrown: "#bc8f8f",
      royalblue: "#4169e1",
      saddlebrown: "#8b4513",
      salmon: "#fa8072",
      sandybrown: "#f4a460",
      seagreen: "#2e8b57",
      seashell: "#fff5ee",
      sienna: "#a0522d",
      silver: "#c0c0c0",
      skyblue: "#87ceeb",
      slateblue: "#6a5acd",
      slategray: "#708090",
      slategrey: "#708090",
      snow: "#fffafa",
      springgreen: "#00ff7f",
      steelblue: "#4682b4",
      tan: "#d2b48c",
      teal: "#008080",
      thistle: "#d8bfd8",
      tomato: "#ff6347",
      turquoise: "#40e0d0",
      violet: "#ee82ee",
      wheat: "#f5deb3",
      white: "#ffffff",
      whitesmoke: "#f5f5f5",
      yellow: "#ffff00",
      yellowgreen: "#9acd32"
    };
  
    function inputToRGB(color) {
      var rgb = { r: 0, g: 0, b: 0 };
      var a = 1;
      var s = null;
      var v = null;
      var l = null;
      var ok = false;
      var format = false;
      if (typeof color === "string") {
        color = stringInputToObject(color);
      }
      if (typeof color === "object") {
        if (isValidCSSUnit(color.r) && isValidCSSUnit(color.g) && isValidCSSUnit(color.b)) {
          rgb = rgbToRgb(color.r, color.g, color.b);
          ok = true;
          format = String(color.r).substr(-1) === "%" ? "prgb" : "rgb";
        } else if (isValidCSSUnit(color.h) && isValidCSSUnit(color.s) && isValidCSSUnit(color.v)) {
          s = convertToPercentage(color.s);
          v = convertToPercentage(color.v);
          rgb = hsvToRgb(color.h, s, v);
          ok = true;
          format = "hsv";
        } else if (isValidCSSUnit(color.h) && isValidCSSUnit(color.s) && isValidCSSUnit(color.l)) {
          s = convertToPercentage(color.s);
          l = convertToPercentage(color.l);
          rgb = hslToRgb(color.h, s, l);
          ok = true;
          format = "hsl";
        }
        if (Object.prototype.hasOwnProperty.call(color, "a")) {
          a = color.a;
        }
      }
      a = boundAlpha(a);
      return {
        ok,
        format: color.format || format,
        r: Math.min(255, Math.max(rgb.r, 0)),
        g: Math.min(255, Math.max(rgb.g, 0)),
        b: Math.min(255, Math.max(rgb.b, 0)),
        a
      };
    }
    var CSS_INTEGER = "[-\\+]?\\d+%?";
    var CSS_NUMBER = "[-\\+]?\\d*\\.\\d+%?";
    var CSS_UNIT = "(?:".concat(CSS_NUMBER, ")|(?:").concat(CSS_INTEGER, ")");
    var PERMISSIVE_MATCH3 = "[\\s|\\(]+(".concat(CSS_UNIT, ")[,|\\s]+(").concat(CSS_UNIT, ")[,|\\s]+(").concat(CSS_UNIT, ")\\s*\\)?");
    var PERMISSIVE_MATCH4 = "[\\s|\\(]+(".concat(CSS_UNIT, ")[,|\\s]+(").concat(CSS_UNIT, ")[,|\\s]+(").concat(CSS_UNIT, ")[,|\\s]+(").concat(CSS_UNIT, ")\\s*\\)?");
    var matchers = {
      CSS_UNIT: new RegExp(CSS_UNIT),
      rgb: new RegExp("rgb" + PERMISSIVE_MATCH3),
      rgba: new RegExp("rgba" + PERMISSIVE_MATCH4),
      hsl: new RegExp("hsl" + PERMISSIVE_MATCH3),
      hsla: new RegExp("hsla" + PERMISSIVE_MATCH4),
      hsv: new RegExp("hsv" + PERMISSIVE_MATCH3),
      hsva: new RegExp("hsva" + PERMISSIVE_MATCH4),
      hex3: /^#?([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/,
      hex6: /^#?([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})$/,
      hex4: /^#?([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})([0-9a-fA-F]{1})$/,
      hex8: /^#?([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})$/
    };
    function stringInputToObject(color) {
      color = color.trim().toLowerCase();
      if (color.length === 0) {
        return false;
      }
      var named = false;
      if (names[color]) {
        color = names[color];
        named = true;
      } else if (color === "transparent") {
        return { r: 0, g: 0, b: 0, a: 0, format: "name" };
      }
      var match = matchers.rgb.exec(color);
      if (match) {
        return { r: match[1], g: match[2], b: match[3] };
      }
      match = matchers.rgba.exec(color);
      if (match) {
        return { r: match[1], g: match[2], b: match[3], a: match[4] };
      }
      match = matchers.hsl.exec(color);
      if (match) {
        return { h: match[1], s: match[2], l: match[3] };
      }
      match = matchers.hsla.exec(color);
      if (match) {
        return { h: match[1], s: match[2], l: match[3], a: match[4] };
      }
      match = matchers.hsv.exec(color);
      if (match) {
        return { h: match[1], s: match[2], v: match[3] };
      }
      match = matchers.hsva.exec(color);
      if (match) {
        return { h: match[1], s: match[2], v: match[3], a: match[4] };
      }
      match = matchers.hex8.exec(color);
      if (match) {
        return {
          r: parseIntFromHex(match[1]),
          g: parseIntFromHex(match[2]),
          b: parseIntFromHex(match[3]),
          a: convertHexToDecimal(match[4]),
          format: named ? "name" : "hex8"
        };
      }
      match = matchers.hex6.exec(color);
      if (match) {
        return {
          r: parseIntFromHex(match[1]),
          g: parseIntFromHex(match[2]),
          b: parseIntFromHex(match[3]),
          format: named ? "name" : "hex"
        };
      }
      match = matchers.hex4.exec(color);
      if (match) {
        return {
          r: parseIntFromHex(match[1] + match[1]),
          g: parseIntFromHex(match[2] + match[2]),
          b: parseIntFromHex(match[3] + match[3]),
          a: convertHexToDecimal(match[4] + match[4]),
          format: named ? "name" : "hex8"
        };
      }
      match = matchers.hex3.exec(color);
      if (match) {
        return {
          r: parseIntFromHex(match[1] + match[1]),
          g: parseIntFromHex(match[2] + match[2]),
          b: parseIntFromHex(match[3] + match[3]),
          format: named ? "name" : "hex"
        };
      }
      return false;
    }
    function isValidCSSUnit(color) {
      return Boolean(matchers.CSS_UNIT.exec(String(color)));
    }
  
    var TinyColor = function() {
      function TinyColor2(color, opts) {
        if (color === void 0) {
          color = "";
        }
        if (opts === void 0) {
          opts = {};
        }
        var _a;
        if (color instanceof TinyColor2) {
          return color;
        }
        if (typeof color === "number") {
          color = numberInputToObject(color);
        }
        this.originalInput = color;
        var rgb = inputToRGB(color);
        this.originalInput = color;
        this.r = rgb.r;
        this.g = rgb.g;
        this.b = rgb.b;
        this.a = rgb.a;
        this.roundA = Math.round(100 * this.a) / 100;
        this.format = (_a = opts.format) !== null && _a !== void 0 ? _a : rgb.format;
        this.gradientType = opts.gradientType;
        if (this.r < 1) {
          this.r = Math.round(this.r);
        }
        if (this.g < 1) {
          this.g = Math.round(this.g);
        }
        if (this.b < 1) {
          this.b = Math.round(this.b);
        }
        this.isValid = rgb.ok;
      }
      TinyColor2.prototype.isDark = function() {
        return this.getBrightness() < 128;
      };
      TinyColor2.prototype.isLight = function() {
        return !this.isDark();
      };
      TinyColor2.prototype.getBrightness = function() {
        var rgb = this.toRgb();
        return (rgb.r * 299 + rgb.g * 587 + rgb.b * 114) / 1e3;
      };
      TinyColor2.prototype.getLuminance = function() {
        var rgb = this.toRgb();
        var R;
        var G;
        var B;
        var RsRGB = rgb.r / 255;
        var GsRGB = rgb.g / 255;
        var BsRGB = rgb.b / 255;
        if (RsRGB <= 0.03928) {
          R = RsRGB / 12.92;
        } else {
          R = Math.pow((RsRGB + 0.055) / 1.055, 2.4);
        }
        if (GsRGB <= 0.03928) {
          G = GsRGB / 12.92;
        } else {
          G = Math.pow((GsRGB + 0.055) / 1.055, 2.4);
        }
        if (BsRGB <= 0.03928) {
          B = BsRGB / 12.92;
        } else {
          B = Math.pow((BsRGB + 0.055) / 1.055, 2.4);
        }
        return 0.2126 * R + 0.7152 * G + 0.0722 * B;
      };
      TinyColor2.prototype.getAlpha = function() {
        return this.a;
      };
      TinyColor2.prototype.setAlpha = function(alpha) {
        this.a = boundAlpha(alpha);
        this.roundA = Math.round(100 * this.a) / 100;
        return this;
      };
      TinyColor2.prototype.toHsv = function() {
        var hsv = rgbToHsv(this.r, this.g, this.b);
        return { h: hsv.h * 360, s: hsv.s, v: hsv.v, a: this.a };
      };
      TinyColor2.prototype.toHsvString = function() {
        var hsv = rgbToHsv(this.r, this.g, this.b);
        var h = Math.round(hsv.h * 360);
        var s = Math.round(hsv.s * 100);
        var v = Math.round(hsv.v * 100);
        return this.a === 1 ? "hsv(".concat(h, ", ").concat(s, "%, ").concat(v, "%)") : "hsva(".concat(h, ", ").concat(s, "%, ").concat(v, "%, ").concat(this.roundA, ")");
      };
      TinyColor2.prototype.toHsl = function() {
        var hsl = rgbToHsl(this.r, this.g, this.b);
        return { h: hsl.h * 360, s: hsl.s, l: hsl.l, a: this.a };
      };
      TinyColor2.prototype.toHslString = function() {
        var hsl = rgbToHsl(this.r, this.g, this.b);
        var h = Math.round(hsl.h * 360);
        var s = Math.round(hsl.s * 100);
        var l = Math.round(hsl.l * 100);
        return this.a === 1 ? "hsl(".concat(h, ", ").concat(s, "%, ").concat(l, "%)") : "hsla(".concat(h, ", ").concat(s, "%, ").concat(l, "%, ").concat(this.roundA, ")");
      };
      TinyColor2.prototype.toHex = function(allow3Char) {
        if (allow3Char === void 0) {
          allow3Char = false;
        }
        return rgbToHex(this.r, this.g, this.b, allow3Char);
      };
      TinyColor2.prototype.toHexString = function(allow3Char) {
        if (allow3Char === void 0) {
          allow3Char = false;
        }
        return "#" + this.toHex(allow3Char);
      };
      TinyColor2.prototype.toHex8 = function(allow4Char) {
        if (allow4Char === void 0) {
          allow4Char = false;
        }
        return rgbaToHex(this.r, this.g, this.b, this.a, allow4Char);
      };
      TinyColor2.prototype.toHex8String = function(allow4Char) {
        if (allow4Char === void 0) {
          allow4Char = false;
        }
        return "#" + this.toHex8(allow4Char);
      };
      TinyColor2.prototype.toRgb = function() {
        return {
          r: Math.round(this.r),
          g: Math.round(this.g),
          b: Math.round(this.b),
          a: this.a
        };
      };
      TinyColor2.prototype.toRgbString = function() {
        var r = Math.round(this.r);
        var g = Math.round(this.g);
        var b = Math.round(this.b);
        return this.a === 1 ? "rgb(".concat(r, ", ").concat(g, ", ").concat(b, ")") : "rgba(".concat(r, ", ").concat(g, ", ").concat(b, ", ").concat(this.roundA, ")");
      };
      TinyColor2.prototype.toPercentageRgb = function() {
        var fmt = function(x) {
          return "".concat(Math.round(bound01$1(x, 255) * 100), "%");
        };
        return {
          r: fmt(this.r),
          g: fmt(this.g),
          b: fmt(this.b),
          a: this.a
        };
      };
      TinyColor2.prototype.toPercentageRgbString = function() {
        var rnd = function(x) {
          return Math.round(bound01$1(x, 255) * 100);
        };
        return this.a === 1 ? "rgb(".concat(rnd(this.r), "%, ").concat(rnd(this.g), "%, ").concat(rnd(this.b), "%)") : "rgba(".concat(rnd(this.r), "%, ").concat(rnd(this.g), "%, ").concat(rnd(this.b), "%, ").concat(this.roundA, ")");
      };
      TinyColor2.prototype.toName = function() {
        if (this.a === 0) {
          return "transparent";
        }
        if (this.a < 1) {
          return false;
        }
        var hex = "#" + rgbToHex(this.r, this.g, this.b, false);
        for (var _i = 0, _a = Object.entries(names); _i < _a.length; _i++) {
          var _b = _a[_i], key = _b[0], value = _b[1];
          if (hex === value) {
            return key;
          }
        }
        return false;
      };
      TinyColor2.prototype.toString = function(format) {
        var formatSet = Boolean(format);
        format = format !== null && format !== void 0 ? format : this.format;
        var formattedString = false;
        var hasAlpha = this.a < 1 && this.a >= 0;
        var needsAlphaFormat = !formatSet && hasAlpha && (format.startsWith("hex") || format === "name");
        if (needsAlphaFormat) {
          if (format === "name" && this.a === 0) {
            return this.toName();
          }
          return this.toRgbString();
        }
        if (format === "rgb") {
          formattedString = this.toRgbString();
        }
        if (format === "prgb") {
          formattedString = this.toPercentageRgbString();
        }
        if (format === "hex" || format === "hex6") {
          formattedString = this.toHexString();
        }
        if (format === "hex3") {
          formattedString = this.toHexString(true);
        }
        if (format === "hex4") {
          formattedString = this.toHex8String(true);
        }
        if (format === "hex8") {
          formattedString = this.toHex8String();
        }
        if (format === "name") {
          formattedString = this.toName();
        }
        if (format === "hsl") {
          formattedString = this.toHslString();
        }
        if (format === "hsv") {
          formattedString = this.toHsvString();
        }
        return formattedString || this.toHexString();
      };
      TinyColor2.prototype.toNumber = function() {
        return (Math.round(this.r) << 16) + (Math.round(this.g) << 8) + Math.round(this.b);
      };
      TinyColor2.prototype.clone = function() {
        return new TinyColor2(this.toString());
      };
      TinyColor2.prototype.lighten = function(amount) {
        if (amount === void 0) {
          amount = 10;
        }
        var hsl = this.toHsl();
        hsl.l += amount / 100;
        hsl.l = clamp01(hsl.l);
        return new TinyColor2(hsl);
      };
      TinyColor2.prototype.brighten = function(amount) {
        if (amount === void 0) {
          amount = 10;
        }
        var rgb = this.toRgb();
        rgb.r = Math.max(0, Math.min(255, rgb.r - Math.round(255 * -(amount / 100))));
        rgb.g = Math.max(0, Math.min(255, rgb.g - Math.round(255 * -(amount / 100))));
        rgb.b = Math.max(0, Math.min(255, rgb.b - Math.round(255 * -(amount / 100))));
        return new TinyColor2(rgb);
      };
      TinyColor2.prototype.darken = function(amount) {
        if (amount === void 0) {
          amount = 10;
        }
        var hsl = this.toHsl();
        hsl.l -= amount / 100;
        hsl.l = clamp01(hsl.l);
        return new TinyColor2(hsl);
      };
      TinyColor2.prototype.tint = function(amount) {
        if (amount === void 0) {
          amount = 10;
        }
        return this.mix("white", amount);
      };
      TinyColor2.prototype.shade = function(amount) {
        if (amount === void 0) {
          amount = 10;
        }
        return this.mix("black", amount);
      };
      TinyColor2.prototype.desaturate = function(amount) {
        if (amount === void 0) {
          amount = 10;
        }
        var hsl = this.toHsl();
        hsl.s -= amount / 100;
        hsl.s = clamp01(hsl.s);
        return new TinyColor2(hsl);
      };
      TinyColor2.prototype.saturate = function(amount) {
        if (amount === void 0) {
          amount = 10;
        }
        var hsl = this.toHsl();
        hsl.s += amount / 100;
        hsl.s = clamp01(hsl.s);
        return new TinyColor2(hsl);
      };
      TinyColor2.prototype.greyscale = function() {
        return this.desaturate(100);
      };
      TinyColor2.prototype.spin = function(amount) {
        var hsl = this.toHsl();
        var hue = (hsl.h + amount) % 360;
        hsl.h = hue < 0 ? 360 + hue : hue;
        return new TinyColor2(hsl);
      };
      TinyColor2.prototype.mix = function(color, amount) {
        if (amount === void 0) {
          amount = 50;
        }
        var rgb1 = this.toRgb();
        var rgb2 = new TinyColor2(color).toRgb();
        var p = amount / 100;
        var rgba = {
          r: (rgb2.r - rgb1.r) * p + rgb1.r,
          g: (rgb2.g - rgb1.g) * p + rgb1.g,
          b: (rgb2.b - rgb1.b) * p + rgb1.b,
          a: (rgb2.a - rgb1.a) * p + rgb1.a
        };
        return new TinyColor2(rgba);
      };
      TinyColor2.prototype.analogous = function(results, slices) {
        if (results === void 0) {
          results = 6;
        }
        if (slices === void 0) {
          slices = 30;
        }
        var hsl = this.toHsl();
        var part = 360 / slices;
        var ret = [this];
        for (hsl.h = (hsl.h - (part * results >> 1) + 720) % 360; --results; ) {
          hsl.h = (hsl.h + part) % 360;
          ret.push(new TinyColor2(hsl));
        }
        return ret;
      };
      TinyColor2.prototype.complement = function() {
        var hsl = this.toHsl();
        hsl.h = (hsl.h + 180) % 360;
        return new TinyColor2(hsl);
      };
      TinyColor2.prototype.monochromatic = function(results) {
        if (results === void 0) {
          results = 6;
        }
        var hsv = this.toHsv();
        var h = hsv.h;
        var s = hsv.s;
        var v = hsv.v;
        var res = [];
        var modification = 1 / results;
        while (results--) {
          res.push(new TinyColor2({ h, s, v }));
          v = (v + modification) % 1;
        }
        return res;
      };
      TinyColor2.prototype.splitcomplement = function() {
        var hsl = this.toHsl();
        var h = hsl.h;
        return [
          this,
          new TinyColor2({ h: (h + 72) % 360, s: hsl.s, l: hsl.l }),
          new TinyColor2({ h: (h + 216) % 360, s: hsl.s, l: hsl.l })
        ];
      };
      TinyColor2.prototype.onBackground = function(background) {
        var fg = this.toRgb();
        var bg = new TinyColor2(background).toRgb();
        return new TinyColor2({
          r: bg.r + (fg.r - bg.r) * fg.a,
          g: bg.g + (fg.g - bg.g) * fg.a,
          b: bg.b + (fg.b - bg.b) * fg.a
        });
      };
      TinyColor2.prototype.triad = function() {
        return this.polyad(3);
      };
      TinyColor2.prototype.tetrad = function() {
        return this.polyad(4);
      };
      TinyColor2.prototype.polyad = function(n) {
        var hsl = this.toHsl();
        var h = hsl.h;
        var result = [this];
        var increment = 360 / n;
        for (var i = 1; i < n; i++) {
          result.push(new TinyColor2({ h: (h + i * increment) % 360, s: hsl.s, l: hsl.l }));
        }
        return result;
      };
      TinyColor2.prototype.equals = function(color) {
        return this.toRgbString() === new TinyColor2(color).toRgbString();
      };
      return TinyColor2;
    }();
  
    function darken(color, amount = 20) {
      return color.mix("#141414", amount).toString();
    }
    function useButtonCustomStyle(props) {
      const _disabled = useDisabled();
      const ns = useNamespace("button");
      return vue.computed(() => {
        let styles = {};
        const buttonColor = props.color;
        if (buttonColor) {
          const color = new TinyColor(buttonColor);
          const activeBgColor = props.dark ? color.tint(20).toString() : darken(color, 20);
          if (props.plain) {
            styles = ns.cssVarBlock({
              "bg-color": props.dark ? darken(color, 90) : color.tint(90).toString(),
              "text-color": buttonColor,
              "border-color": props.dark ? darken(color, 50) : color.tint(50).toString(),
              "hover-text-color": `var(${ns.cssVarName("color-white")})`,
              "hover-bg-color": buttonColor,
              "hover-border-color": buttonColor,
              "active-bg-color": activeBgColor,
              "active-text-color": `var(${ns.cssVarName("color-white")})`,
              "active-border-color": activeBgColor
            });
            if (_disabled.value) {
              styles[ns.cssVarBlockName("disabled-bg-color")] = props.dark ? darken(color, 90) : color.tint(90).toString();
              styles[ns.cssVarBlockName("disabled-text-color")] = props.dark ? darken(color, 50) : color.tint(50).toString();
              styles[ns.cssVarBlockName("disabled-border-color")] = props.dark ? darken(color, 80) : color.tint(80).toString();
            }
          } else {
            const hoverBgColor = props.dark ? darken(color, 30) : color.tint(30).toString();
            const textColor = color.isDark() ? `var(${ns.cssVarName("color-white")})` : `var(${ns.cssVarName("color-black")})`;
            styles = ns.cssVarBlock({
              "bg-color": buttonColor,
              "text-color": textColor,
              "border-color": buttonColor,
              "hover-bg-color": hoverBgColor,
              "hover-text-color": textColor,
              "hover-border-color": hoverBgColor,
              "active-bg-color": activeBgColor,
              "active-border-color": activeBgColor
            });
            if (_disabled.value) {
              const disabledButtonColor = props.dark ? darken(color, 50) : color.tint(50).toString();
              styles[ns.cssVarBlockName("disabled-bg-color")] = disabledButtonColor;
              styles[ns.cssVarBlockName("disabled-text-color")] = props.dark ? "rgba(255, 255, 255, 0.5)" : `var(${ns.cssVarName("color-white")})`;
              styles[ns.cssVarBlockName("disabled-border-color")] = disabledButtonColor;
            }
          }
        }
        return styles;
      });
    }
  
    const _hoisted_1$_ = ["aria-disabled", "disabled", "autofocus", "type"];
    const __default__$1e = vue.defineComponent({
      name: "ElButton"
    });
    const _sfc_main$1W = /* @__PURE__ */ vue.defineComponent({
      ...__default__$1e,
      props: buttonProps,
      emits: buttonEmits,
      setup(__props, { expose, emit }) {
        const props = __props;
        const buttonStyle = useButtonCustomStyle(props);
        const ns = useNamespace("button");
        const { _ref, _size, _type, _disabled, shouldAddSpace, handleClick } = useButton(props, emit);
        expose({
          ref: _ref,
          size: _size,
          type: _type,
          disabled: _disabled,
          shouldAddSpace
        });
        return (_ctx, _cache) => {
          return vue.openBlock(), vue.createElementBlock("button", {
            ref_key: "_ref",
            ref: _ref,
            class: vue.normalizeClass([
              vue.unref(ns).b(),
              vue.unref(ns).m(vue.unref(_type)),
              vue.unref(ns).m(vue.unref(_size)),
              vue.unref(ns).is("disabled", vue.unref(_disabled)),
              vue.unref(ns).is("loading", _ctx.loading),
              vue.unref(ns).is("plain", _ctx.plain),
              vue.unref(ns).is("round", _ctx.round),
              vue.unref(ns).is("circle", _ctx.circle),
              vue.unref(ns).is("text", _ctx.text),
              vue.unref(ns).is("link", _ctx.link),
              vue.unref(ns).is("has-bg", _ctx.bg)
            ]),
            "aria-disabled": vue.unref(_disabled) || _ctx.loading,
            disabled: vue.unref(_disabled) || _ctx.loading,
            autofocus: _ctx.autofocus,
            type: _ctx.nativeType,
            style: vue.normalizeStyle(vue.unref(buttonStyle)),
            onClick: _cache[0] || (_cache[0] = (...args) => vue.unref(handleClick) && vue.unref(handleClick)(...args))
          }, [
            _ctx.loading ? (vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: 0 }, [
              _ctx.$slots.loading ? vue.renderSlot(_ctx.$slots, "loading", { key: 0 }) : (vue.openBlock(), vue.createBlock(vue.unref(ElIcon), {
                key: 1,
                class: vue.normalizeClass(vue.unref(ns).is("loading"))
              }, {
                default: vue.withCtx(() => [
                  (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(_ctx.loadingIcon)))
                ]),
                _: 1
              }, 8, ["class"]))
            ], 64)) : _ctx.icon || _ctx.$slots.icon ? (vue.openBlock(), vue.createBlock(vue.unref(ElIcon), { key: 1 }, {
              default: vue.withCtx(() => [
                _ctx.icon ? (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(_ctx.icon), { key: 0 })) : vue.renderSlot(_ctx.$slots, "icon", { key: 1 })
              ]),
              _: 3
            })) : vue.createCommentVNode("v-if", true),
            _ctx.$slots.default ? (vue.openBlock(), vue.createElementBlock("span", {
              key: 2,
              class: vue.normalizeClass({ [vue.unref(ns).em("text", "expand")]: vue.unref(shouldAddSpace) })
            }, [
              vue.renderSlot(_ctx.$slots, "default")
            ], 2)) : vue.createCommentVNode("v-if", true)
          ], 14, _hoisted_1$_);
        };
      }
    });
    var Button = /* @__PURE__ */ _export_sfc(_sfc_main$1W, [["__file", "button.vue"]]);
  
    const buttonGroupProps = {
      size: buttonProps.size,
      type: buttonProps.type
    };
  
    const __default__$1d = vue.defineComponent({
      name: "ElButtonGroup"
    });
    const _sfc_main$1V = /* @__PURE__ */ vue.defineComponent({
      ...__default__$1d,
      props: buttonGroupProps,
      setup(__props) {
        const props = __props;
        vue.provide(buttonGroupContextKey, vue.reactive({
          size: vue.toRef(props, "size"),
          type: vue.toRef(props, "type")
        }));
        const ns = useNamespace("button");
        return (_ctx, _cache) => {
          return vue.openBlock(), vue.createElementBlock("div", {
            class: vue.normalizeClass(`${vue.unref(ns).b("group")}`)
          }, [
            vue.renderSlot(_ctx.$slots, "default")
          ], 2);
        };
      }
    });
    var ButtonGroup = /* @__PURE__ */ _export_sfc(_sfc_main$1V, [["__file", "button-group.vue"]]);
  
    const ElButton = withInstall(Button, {
      ButtonGroup
    });
    const ElButtonGroup$1 = withNoopInstall(ButtonGroup);
  
    var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
  
    var dayjs_min = {exports: {}};
  
    (function(module, exports) {
      !function(t, e) {
        module.exports = e() ;
      }(commonjsGlobal, function() {
        var t = 1e3, e = 6e4, n = 36e5, r = "millisecond", i = "second", s = "minute", u = "hour", a = "day", o = "week", f = "month", h = "quarter", c = "year", d = "date", $ = "Invalid Date", l = /^(\d{4})[-/]?(\d{1,2})?[-/]?(\d{0,2})[Tt\s]*(\d{1,2})?:?(\d{1,2})?:?(\d{1,2})?[.:]?(\d+)?$/, y = /\[([^\]]+)]|Y{1,4}|M{1,4}|D{1,2}|d{1,4}|H{1,2}|h{1,2}|a|A|m{1,2}|s{1,2}|Z{1,2}|SSS/g, M = { name: "en", weekdays: "Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday".split("_"), months: "January_February_March_April_May_June_July_August_September_October_November_December".split("_") }, m = function(t2, e2, n2) {
          var r2 = String(t2);
          return !r2 || r2.length >= e2 ? t2 : "" + Array(e2 + 1 - r2.length).join(n2) + t2;
        }, g = { s: m, z: function(t2) {
          var e2 = -t2.utcOffset(), n2 = Math.abs(e2), r2 = Math.floor(n2 / 60), i2 = n2 % 60;
          return (e2 <= 0 ? "+" : "-") + m(r2, 2, "0") + ":" + m(i2, 2, "0");
        }, m: function t2(e2, n2) {
          if (e2.date() < n2.date())
            return -t2(n2, e2);
          var r2 = 12 * (n2.year() - e2.year()) + (n2.month() - e2.month()), i2 = e2.clone().add(r2, f), s2 = n2 - i2 < 0, u2 = e2.clone().add(r2 + (s2 ? -1 : 1), f);
          return +(-(r2 + (n2 - i2) / (s2 ? i2 - u2 : u2 - i2)) || 0);
        }, a: function(t2) {
          return t2 < 0 ? Math.ceil(t2) || 0 : Math.floor(t2);
        }, p: function(t2) {
          return { M: f, y: c, w: o, d: a, D: d, h: u, m: s, s: i, ms: r, Q: h }[t2] || String(t2 || "").toLowerCase().replace(/s$/, "");
        }, u: function(t2) {
          return t2 === void 0;
        } }, v = "en", D = {};
        D[v] = M;
        var p = function(t2) {
          return t2 instanceof _;
        }, S = function t2(e2, n2, r2) {
          var i2;
          if (!e2)
            return v;
          if (typeof e2 == "string") {
            var s2 = e2.toLowerCase();
            D[s2] && (i2 = s2), n2 && (D[s2] = n2, i2 = s2);
            var u2 = e2.split("-");
            if (!i2 && u2.length > 1)
              return t2(u2[0]);
          } else {
            var a2 = e2.name;
            D[a2] = e2, i2 = a2;
          }
          return !r2 && i2 && (v = i2), i2 || !r2 && v;
        }, w = function(t2, e2) {
          if (p(t2))
            return t2.clone();
          var n2 = typeof e2 == "object" ? e2 : {};
          return n2.date = t2, n2.args = arguments, new _(n2);
        }, O = g;
        O.l = S, O.i = p, O.w = function(t2, e2) {
          return w(t2, { locale: e2.$L, utc: e2.$u, x: e2.$x, $offset: e2.$offset });
        };
        var _ = function() {
          function M2(t2) {
            this.$L = S(t2.locale, null, true), this.parse(t2);
          }
          var m2 = M2.prototype;
          return m2.parse = function(t2) {
            this.$d = function(t3) {
              var e2 = t3.date, n2 = t3.utc;
              if (e2 === null)
                return new Date(NaN);
              if (O.u(e2))
                return new Date();
              if (e2 instanceof Date)
                return new Date(e2);
              if (typeof e2 == "string" && !/Z$/i.test(e2)) {
                var r2 = e2.match(l);
                if (r2) {
                  var i2 = r2[2] - 1 || 0, s2 = (r2[7] || "0").substring(0, 3);
                  return n2 ? new Date(Date.UTC(r2[1], i2, r2[3] || 1, r2[4] || 0, r2[5] || 0, r2[6] || 0, s2)) : new Date(r2[1], i2, r2[3] || 1, r2[4] || 0, r2[5] || 0, r2[6] || 0, s2);
                }
              }
              return new Date(e2);
            }(t2), this.$x = t2.x || {}, this.init();
          }, m2.init = function() {
            var t2 = this.$d;
            this.$y = t2.getFullYear(), this.$M = t2.getMonth(), this.$D = t2.getDate(), this.$W = t2.getDay(), this.$H = t2.getHours(), this.$m = t2.getMinutes(), this.$s = t2.getSeconds(), this.$ms = t2.getMilliseconds();
          }, m2.$utils = function() {
            return O;
          }, m2.isValid = function() {
            return !(this.$d.toString() === $);
          }, m2.isSame = function(t2, e2) {
            var n2 = w(t2);
            return this.startOf(e2) <= n2 && n2 <= this.endOf(e2);
          }, m2.isAfter = function(t2, e2) {
            return w(t2) < this.startOf(e2);
          }, m2.isBefore = function(t2, e2) {
            return this.endOf(e2) < w(t2);
          }, m2.$g = function(t2, e2, n2) {
            return O.u(t2) ? this[e2] : this.set(n2, t2);
          }, m2.unix = function() {
            return Math.floor(this.valueOf() / 1e3);
          }, m2.valueOf = function() {
            return this.$d.getTime();
          }, m2.startOf = function(t2, e2) {
            var n2 = this, r2 = !!O.u(e2) || e2, h2 = O.p(t2), $2 = function(t3, e3) {
              var i2 = O.w(n2.$u ? Date.UTC(n2.$y, e3, t3) : new Date(n2.$y, e3, t3), n2);
              return r2 ? i2 : i2.endOf(a);
            }, l2 = function(t3, e3) {
              return O.w(n2.toDate()[t3].apply(n2.toDate("s"), (r2 ? [0, 0, 0, 0] : [23, 59, 59, 999]).slice(e3)), n2);
            }, y2 = this.$W, M3 = this.$M, m3 = this.$D, g2 = "set" + (this.$u ? "UTC" : "");
            switch (h2) {
              case c:
                return r2 ? $2(1, 0) : $2(31, 11);
              case f:
                return r2 ? $2(1, M3) : $2(0, M3 + 1);
              case o:
                var v2 = this.$locale().weekStart || 0, D2 = (y2 < v2 ? y2 + 7 : y2) - v2;
                return $2(r2 ? m3 - D2 : m3 + (6 - D2), M3);
              case a:
              case d:
                return l2(g2 + "Hours", 0);
              case u:
                return l2(g2 + "Minutes", 1);
              case s:
                return l2(g2 + "Seconds", 2);
              case i:
                return l2(g2 + "Milliseconds", 3);
              default:
                return this.clone();
            }
          }, m2.endOf = function(t2) {
            return this.startOf(t2, false);
          }, m2.$set = function(t2, e2) {
            var n2, o2 = O.p(t2), h2 = "set" + (this.$u ? "UTC" : ""), $2 = (n2 = {}, n2[a] = h2 + "Date", n2[d] = h2 + "Date", n2[f] = h2 + "Month", n2[c] = h2 + "FullYear", n2[u] = h2 + "Hours", n2[s] = h2 + "Minutes", n2[i] = h2 + "Seconds", n2[r] = h2 + "Milliseconds", n2)[o2], l2 = o2 === a ? this.$D + (e2 - this.$W) : e2;
            if (o2 === f || o2 === c) {
              var y2 = this.clone().set(d, 1);
              y2.$d[$2](l2), y2.init(), this.$d = y2.set(d, Math.min(this.$D, y2.daysInMonth())).$d;
            } else
              $2 && this.$d[$2](l2);
            return this.init(), this;
          }, m2.set = function(t2, e2) {
            return this.clone().$set(t2, e2);
          }, m2.get = function(t2) {
            return this[O.p(t2)]();
          }, m2.add = function(r2, h2) {
            var d2, $2 = this;
            r2 = Number(r2);
            var l2 = O.p(h2), y2 = function(t2) {
              var e2 = w($2);
              return O.w(e2.date(e2.date() + Math.round(t2 * r2)), $2);
            };
            if (l2 === f)
              return this.set(f, this.$M + r2);
            if (l2 === c)
              return this.set(c, this.$y + r2);
            if (l2 === a)
              return y2(1);
            if (l2 === o)
              return y2(7);
            var M3 = (d2 = {}, d2[s] = e, d2[u] = n, d2[i] = t, d2)[l2] || 1, m3 = this.$d.getTime() + r2 * M3;
            return O.w(m3, this);
          }, m2.subtract = function(t2, e2) {
            return this.add(-1 * t2, e2);
          }, m2.format = function(t2) {
            var e2 = this, n2 = this.$locale();
            if (!this.isValid())
              return n2.invalidDate || $;
            var r2 = t2 || "YYYY-MM-DDTHH:mm:ssZ", i2 = O.z(this), s2 = this.$H, u2 = this.$m, a2 = this.$M, o2 = n2.weekdays, f2 = n2.months, h2 = function(t3, n3, i3, s3) {
              return t3 && (t3[n3] || t3(e2, r2)) || i3[n3].slice(0, s3);
            }, c2 = function(t3) {
              return O.s(s2 % 12 || 12, t3, "0");
            }, d2 = n2.meridiem || function(t3, e3, n3) {
              var r3 = t3 < 12 ? "AM" : "PM";
              return n3 ? r3.toLowerCase() : r3;
            }, l2 = { YY: String(this.$y).slice(-2), YYYY: this.$y, M: a2 + 1, MM: O.s(a2 + 1, 2, "0"), MMM: h2(n2.monthsShort, a2, f2, 3), MMMM: h2(f2, a2), D: this.$D, DD: O.s(this.$D, 2, "0"), d: String(this.$W), dd: h2(n2.weekdaysMin, this.$W, o2, 2), ddd: h2(n2.weekdaysShort, this.$W, o2, 3), dddd: o2[this.$W], H: String(s2), HH: O.s(s2, 2, "0"), h: c2(1), hh: c2(2), a: d2(s2, u2, true), A: d2(s2, u2, false), m: String(u2), mm: O.s(u2, 2, "0"), s: String(this.$s), ss: O.s(this.$s, 2, "0"), SSS: O.s(this.$ms, 3, "0"), Z: i2 };
            return r2.replace(y, function(t3, e3) {
              return e3 || l2[t3] || i2.replace(":", "");
            });
          }, m2.utcOffset = function() {
            return 15 * -Math.round(this.$d.getTimezoneOffset() / 15);
          }, m2.diff = function(r2, d2, $2) {
            var l2, y2 = O.p(d2), M3 = w(r2), m3 = (M3.utcOffset() - this.utcOffset()) * e, g2 = this - M3, v2 = O.m(this, M3);
            return v2 = (l2 = {}, l2[c] = v2 / 12, l2[f] = v2, l2[h] = v2 / 3, l2[o] = (g2 - m3) / 6048e5, l2[a] = (g2 - m3) / 864e5, l2[u] = g2 / n, l2[s] = g2 / e, l2[i] = g2 / t, l2)[y2] || g2, $2 ? v2 : O.a(v2);
          }, m2.daysInMonth = function() {
            return this.endOf(f).$D;
          }, m2.$locale = function() {
            return D[this.$L];
          }, m2.locale = function(t2, e2) {
            if (!t2)
              return this.$L;
            var n2 = this.clone(), r2 = S(t2, e2, true);
            return r2 && (n2.$L = r2), n2;
          }, m2.clone = function() {
            return O.w(this.$d, this);
          }, m2.toDate = function() {
            return new Date(this.valueOf());
          }, m2.toJSON = function() {
            return this.isValid() ? this.toISOString() : null;
          }, m2.toISOString = function() {
            return this.$d.toISOString();
          }, m2.toString = function() {
            return this.$d.toUTCString();
          }, M2;
        }(), T = _.prototype;
        return w.prototype = T, [["$ms", r], ["$s", i], ["$m", s], ["$H", u], ["$W", a], ["$M", f], ["$y", c], ["$D", d]].forEach(function(t2) {
          T[t2[1]] = function(e2) {
            return this.$g(e2, t2[0], t2[1]);
          };
        }), w.extend = function(t2, e2) {
          return t2.$i || (t2(e2, _, w), t2.$i = true), w;
        }, w.locale = S, w.isDayjs = p, w.unix = function(t2) {
          return w(1e3 * t2);
        }, w.en = D[v], w.Ls = D, w.p = {}, w;
      });
    })(dayjs_min);
    var dayjs = dayjs_min.exports;
  
    var customParseFormat$1 = {exports: {}};
  
    (function(module, exports) {
      !function(e, t) {
        module.exports = t() ;
      }(commonjsGlobal, function() {
        var e = { LTS: "h:mm:ss A", LT: "h:mm A", L: "MM/DD/YYYY", LL: "MMMM D, YYYY", LLL: "MMMM D, YYYY h:mm A", LLLL: "dddd, MMMM D, YYYY h:mm A" }, t = /(\[[^[]*\])|([-_:/.,()\s]+)|(A|a|YYYY|YY?|MM?M?M?|Do|DD?|hh?|HH?|mm?|ss?|S{1,3}|z|ZZ?)/g, n = /\d\d/, r = /\d\d?/, i = /\d*[^-_:/,()\s\d]+/, o = {}, s = function(e2) {
          return (e2 = +e2) + (e2 > 68 ? 1900 : 2e3);
        };
        var a = function(e2) {
          return function(t2) {
            this[e2] = +t2;
          };
        }, f = [/[+-]\d\d:?(\d\d)?|Z/, function(e2) {
          (this.zone || (this.zone = {})).offset = function(e3) {
            if (!e3)
              return 0;
            if (e3 === "Z")
              return 0;
            var t2 = e3.match(/([+-]|\d\d)/g), n2 = 60 * t2[1] + (+t2[2] || 0);
            return n2 === 0 ? 0 : t2[0] === "+" ? -n2 : n2;
          }(e2);
        }], h = function(e2) {
          var t2 = o[e2];
          return t2 && (t2.indexOf ? t2 : t2.s.concat(t2.f));
        }, u = function(e2, t2) {
          var n2, r2 = o.meridiem;
          if (r2) {
            for (var i2 = 1; i2 <= 24; i2 += 1)
              if (e2.indexOf(r2(i2, 0, t2)) > -1) {
                n2 = i2 > 12;
                break;
              }
          } else
            n2 = e2 === (t2 ? "pm" : "PM");
          return n2;
        }, d = { A: [i, function(e2) {
          this.afternoon = u(e2, false);
        }], a: [i, function(e2) {
          this.afternoon = u(e2, true);
        }], S: [/\d/, function(e2) {
          this.milliseconds = 100 * +e2;
        }], SS: [n, function(e2) {
          this.milliseconds = 10 * +e2;
        }], SSS: [/\d{3}/, function(e2) {
          this.milliseconds = +e2;
        }], s: [r, a("seconds")], ss: [r, a("seconds")], m: [r, a("minutes")], mm: [r, a("minutes")], H: [r, a("hours")], h: [r, a("hours")], HH: [r, a("hours")], hh: [r, a("hours")], D: [r, a("day")], DD: [n, a("day")], Do: [i, function(e2) {
          var t2 = o.ordinal, n2 = e2.match(/\d+/);
          if (this.day = n2[0], t2)
            for (var r2 = 1; r2 <= 31; r2 += 1)
              t2(r2).replace(/\[|\]/g, "") === e2 && (this.day = r2);
        }], M: [r, a("month")], MM: [n, a("month")], MMM: [i, function(e2) {
          var t2 = h("months"), n2 = (h("monthsShort") || t2.map(function(e3) {
            return e3.slice(0, 3);
          })).indexOf(e2) + 1;
          if (n2 < 1)
            throw new Error();
          this.month = n2 % 12 || n2;
        }], MMMM: [i, function(e2) {
          var t2 = h("months").indexOf(e2) + 1;
          if (t2 < 1)
            throw new Error();
          this.month = t2 % 12 || t2;
        }], Y: [/[+-]?\d+/, a("year")], YY: [n, function(e2) {
          this.year = s(e2);
        }], YYYY: [/\d{4}/, a("year")], Z: f, ZZ: f };
        function c(n2) {
          var r2, i2;
          r2 = n2, i2 = o && o.formats;
          for (var s2 = (n2 = r2.replace(/(\[[^\]]+])|(LTS?|l{1,4}|L{1,4})/g, function(t2, n3, r3) {
            var o2 = r3 && r3.toUpperCase();
            return n3 || i2[r3] || e[r3] || i2[o2].replace(/(\[[^\]]+])|(MMMM|MM|DD|dddd)/g, function(e2, t3, n4) {
              return t3 || n4.slice(1);
            });
          })).match(t), a2 = s2.length, f2 = 0; f2 < a2; f2 += 1) {
            var h2 = s2[f2], u2 = d[h2], c2 = u2 && u2[0], l = u2 && u2[1];
            s2[f2] = l ? { regex: c2, parser: l } : h2.replace(/^\[|\]$/g, "");
          }
          return function(e2) {
            for (var t2 = {}, n3 = 0, r3 = 0; n3 < a2; n3 += 1) {
              var i3 = s2[n3];
              if (typeof i3 == "string")
                r3 += i3.length;
              else {
                var o2 = i3.regex, f3 = i3.parser, h3 = e2.slice(r3), u3 = o2.exec(h3)[0];
                f3.call(t2, u3), e2 = e2.replace(u3, "");
              }
            }
            return function(e3) {
              var t3 = e3.afternoon;
              if (t3 !== void 0) {
                var n4 = e3.hours;
                t3 ? n4 < 12 && (e3.hours += 12) : n4 === 12 && (e3.hours = 0), delete e3.afternoon;
              }
            }(t2), t2;
          };
        }
        return function(e2, t2, n2) {
          n2.p.customParseFormat = true, e2 && e2.parseTwoDigitYear && (s = e2.parseTwoDigitYear);
          var r2 = t2.prototype, i2 = r2.parse;
          r2.parse = function(e3) {
            var t3 = e3.date, r3 = e3.utc, s2 = e3.args;
            this.$u = r3;
            var a2 = s2[1];
            if (typeof a2 == "string") {
              var f2 = s2[2] === true, h2 = s2[3] === true, u2 = f2 || h2, d2 = s2[2];
              h2 && (d2 = s2[2]), o = this.$locale(), !f2 && d2 && (o = n2.Ls[d2]), this.$d = function(e4, t4, n3) {
                try {
                  if (["x", "X"].indexOf(t4) > -1)
                    return new Date((t4 === "X" ? 1e3 : 1) * e4);
                  var r4 = c(t4)(e4), i3 = r4.year, o2 = r4.month, s3 = r4.day, a3 = r4.hours, f3 = r4.minutes, h3 = r4.seconds, u3 = r4.milliseconds, d3 = r4.zone, l2 = new Date(), m2 = s3 || (i3 || o2 ? 1 : l2.getDate()), M2 = i3 || l2.getFullYear(), Y = 0;
                  i3 && !o2 || (Y = o2 > 0 ? o2 - 1 : l2.getMonth());
                  var p = a3 || 0, v = f3 || 0, D = h3 || 0, g = u3 || 0;
                  return d3 ? new Date(Date.UTC(M2, Y, m2, p, v, D, g + 60 * d3.offset * 1e3)) : n3 ? new Date(Date.UTC(M2, Y, m2, p, v, D, g)) : new Date(M2, Y, m2, p, v, D, g);
                } catch (e5) {
                  return new Date("");
                }
              }(t3, a2, r3), this.init(), d2 && d2 !== true && (this.$L = this.locale(d2).$L), u2 && t3 != this.format(a2) && (this.$d = new Date("")), o = {};
            } else if (a2 instanceof Array)
              for (var l = a2.length, m = 1; m <= l; m += 1) {
                s2[1] = a2[m - 1];
                var M = n2.apply(this, s2);
                if (M.isValid()) {
                  this.$d = M.$d, this.$L = M.$L, this.init();
                  break;
                }
                m === l && (this.$d = new Date(""));
              }
            else
              i2.call(this, e3);
          };
        };
      });
    })(customParseFormat$1);
    var customParseFormat = customParseFormat$1.exports;
  
    const timeUnits = ["hours", "minutes", "seconds"];
    const DEFAULT_FORMATS_TIME = "HH:mm:ss";
    const DEFAULT_FORMATS_DATE = "YYYY-MM-DD";
    const DEFAULT_FORMATS_DATEPICKER = {
      date: DEFAULT_FORMATS_DATE,
      dates: DEFAULT_FORMATS_DATE,
      week: "gggg[w]ww",
      year: "YYYY",
      month: "YYYY-MM",
      datetime: `${DEFAULT_FORMATS_DATE} ${DEFAULT_FORMATS_TIME}`,
      monthrange: "YYYY-MM",
      daterange: DEFAULT_FORMATS_DATE,
      datetimerange: `${DEFAULT_FORMATS_DATE} ${DEFAULT_FORMATS_TIME}`
    };
  
    const buildTimeList = (value, bound) => {
      return [
        value > 0 ? value - 1 : void 0,
        value,
        value < bound ? value + 1 : void 0
      ];
    };
    const rangeArr = (n) => Array.from(Array.from({ length: n }).keys());
    const extractDateFormat = (format) => {
      return format.replace(/\W?m{1,2}|\W?ZZ/g, "").replace(/\W?h{1,2}|\W?s{1,3}|\W?a/gi, "").trim();
    };
    const extractTimeFormat = (format) => {
      return format.replace(/\W?D{1,2}|\W?Do|\W?d{1,4}|\W?M{1,4}|\W?Y{2,4}/g, "").trim();
    };
    const dateEquals = function(a, b) {
      const aIsDate = isDate(a);
      const bIsDate = isDate(b);
      if (aIsDate && bIsDate) {
        return a.getTime() === b.getTime();
      }
      if (!aIsDate && !bIsDate) {
        return a === b;
      }
      return false;
    };
    const valueEquals = function(a, b) {
      const aIsArray = isArray(a);
      const bIsArray = isArray(b);
      if (aIsArray && bIsArray) {
        if (a.length !== b.length) {
          return false;
        }
        return a.every((item, index) => dateEquals(item, b[index]));
      }
      if (!aIsArray && !bIsArray) {
        return dateEquals(a, b);
      }
      return false;
    };
    const parseDate = function(date, format, lang) {
      const day = isEmpty(format) || format === "x" ? dayjs(date).locale(lang) : dayjs(date, format).locale(lang);
      return day.isValid() ? day : void 0;
    };
    const formatter = function(date, format, lang) {
      if (isEmpty(format))
        return date;
      if (format === "x")
        return +date;
      return dayjs(date).locale(lang).format(format);
    };
    const makeList = (total, method) => {
      var _a;
      const arr = [];
      const disabledArr = method == null ? void 0 : method();
      for (let i = 0; i < total; i++) {
        arr.push((_a = disabledArr == null ? void 0 : disabledArr.includes(i)) != null ? _a : false);
      }
      return arr;
    };
  
    const disabledTimeListsProps = buildProps({
      disabledHours: {
        type: definePropType(Function)
      },
      disabledMinutes: {
        type: definePropType(Function)
      },
      disabledSeconds: {
        type: definePropType(Function)
      }
    });
    const timePanelSharedProps = buildProps({
      visible: Boolean,
      actualVisible: {
        type: Boolean,
        default: void 0
      },
      format: {
        type: String,
        default: ""
      }
    });
  
    const timePickerDefaultProps = buildProps({
      id: {
        type: definePropType([Array, String])
      },
      name: {
        type: definePropType([Array, String]),
        default: ""
      },
      popperClass: {
        type: String,
        default: ""
      },
      format: String,
      valueFormat: String,
      type: {
        type: String,
        default: ""
      },
      clearable: {
        type: Boolean,
        default: true
      },
      clearIcon: {
        type: definePropType([String, Object]),
        default: circle_close_default
      },
      editable: {
        type: Boolean,
        default: true
      },
      prefixIcon: {
        type: definePropType([String, Object]),
        default: ""
      },
      size: useSizeProp,
      readonly: {
        type: Boolean,
        default: false
      },
      disabled: {
        type: Boolean,
        default: false
      },
      placeholder: {
        type: String,
        default: ""
      },
      popperOptions: {
        type: definePropType(Object),
        default: () => ({})
      },
      modelValue: {
        type: definePropType([Date, Array, String, Number]),
        default: ""
      },
      rangeSeparator: {
        type: String,
        default: "-"
      },
      startPlaceholder: String,
      endPlaceholder: String,
      defaultValue: {
        type: definePropType([Date, Array])
      },
      defaultTime: {
        type: definePropType([Date, Array])
      },
      isRange: {
        type: Boolean,
        default: false
      },
      ...disabledTimeListsProps,
      disabledDate: {
        type: Function
      },
      cellClassName: {
        type: Function
      },
      shortcuts: {
        type: Array,
        default: () => []
      },
      arrowControl: {
        type: Boolean,
        default: false
      },
      label: {
        type: String,
        default: void 0
      },
      tabindex: {
        type: definePropType([String, Number]),
        default: 0
      },
      validateEvent: {
        type: Boolean,
        default: true
      },
      unlinkPanels: Boolean
    });
  
    const _hoisted_1$Z = ["id", "name", "placeholder", "value", "disabled", "readonly"];
    const _hoisted_2$D = ["id", "name", "placeholder", "value", "disabled", "readonly"];
    const __default__$1c = vue.defineComponent({
      name: "Picker"
    });
    const _sfc_main$1U = /* @__PURE__ */ vue.defineComponent({
      ...__default__$1c,
      props: timePickerDefaultProps,
      emits: [
        "update:modelValue",
        "change",
        "focus",
        "blur",
        "calendar-change",
        "panel-change",
        "visible-change",
        "keydown"
      ],
      setup(__props, { expose, emit }) {
        const props = __props;
        const { lang } = useLocale();
        const nsDate = useNamespace("date");
        const nsInput = useNamespace("input");
        const nsRange = useNamespace("range");
        const { form, formItem } = useFormItem();
        const elPopperOptions = vue.inject("ElPopperOptions", {});
        const refPopper = vue.ref();
        const inputRef = vue.ref();
        const pickerVisible = vue.ref(false);
        const pickerActualVisible = vue.ref(false);
        const valueOnOpen = vue.ref(null);
        let hasJustTabExitedInput = false;
        let ignoreFocusEvent = false;
        vue.watch(pickerVisible, (val) => {
          if (!val) {
            userInput.value = null;
            vue.nextTick(() => {
              emitChange(props.modelValue);
            });
          } else {
            vue.nextTick(() => {
              if (val) {
                valueOnOpen.value = props.modelValue;
              }
            });
          }
        });
        const emitChange = (val, isClear) => {
          if (isClear || !valueEquals(val, valueOnOpen.value)) {
            emit("change", val);
            props.validateEvent && (formItem == null ? void 0 : formItem.validate("change").catch((err) => debugWarn()));
          }
        };
        const emitInput = (input) => {
          if (!valueEquals(props.modelValue, input)) {
            let formatted;
            if (isArray(input)) {
              formatted = input.map((item) => formatter(item, props.valueFormat, lang.value));
            } else if (input) {
              formatted = formatter(input, props.valueFormat, lang.value);
            }
            emit("update:modelValue", input ? formatted : input, lang.value);
          }
        };
        const emitKeydown = (e) => {
          emit("keydown", e);
        };
        const refInput = vue.computed(() => {
          if (inputRef.value) {
            const _r = isRangeInput.value ? inputRef.value : inputRef.value.$el;
            return Array.from(_r.querySelectorAll("input"));
          }
          return [];
        });
        const setSelectionRange = (start, end, pos) => {
          const _inputs = refInput.value;
          if (!_inputs.length)
            return;
          if (!pos || pos === "min") {
            _inputs[0].setSelectionRange(start, end);
            _inputs[0].focus();
          } else if (pos === "max") {
            _inputs[1].setSelectionRange(start, end);
            _inputs[1].focus();
          }
        };
        const focusOnInputBox = () => {
          focus(true, true);
          vue.nextTick(() => {
            ignoreFocusEvent = false;
          });
        };
        const onPick = (date = "", visible = false) => {
          if (!visible) {
            ignoreFocusEvent = true;
          }
          pickerVisible.value = visible;
          let result;
          if (isArray(date)) {
            result = date.map((_) => _.toDate());
          } else {
            result = date ? date.toDate() : date;
          }
          userInput.value = null;
          emitInput(result);
        };
        const onBeforeShow = () => {
          pickerActualVisible.value = true;
        };
        const onShow = () => {
          emit("visible-change", true);
        };
        const onKeydownPopperContent = (event) => {
          if ((event == null ? void 0 : event.key) === EVENT_CODE.esc) {
            focus(true, true);
          }
        };
        const onHide = () => {
          pickerActualVisible.value = false;
          pickerVisible.value = false;
          ignoreFocusEvent = false;
          emit("visible-change", false);
        };
        const handleOpen = () => {
          pickerVisible.value = true;
        };
        const handleClose = () => {
          pickerVisible.value = false;
        };
        const focus = (focusStartInput = true, isIgnoreFocusEvent = false) => {
          ignoreFocusEvent = isIgnoreFocusEvent;
          const [leftInput, rightInput] = vue.unref(refInput);
          let input = leftInput;
          if (!focusStartInput && isRangeInput.value) {
            input = rightInput;
          }
          if (input) {
            input.focus();
          }
        };
        const handleFocusInput = (e) => {
          if (props.readonly || pickerDisabled.value || pickerVisible.value || ignoreFocusEvent) {
            return;
          }
          pickerVisible.value = true;
          emit("focus", e);
        };
        let currentHandleBlurDeferCallback = void 0;
        const handleBlurInput = (e) => {
          const handleBlurDefer = async () => {
            setTimeout(() => {
              var _a;
              if (currentHandleBlurDeferCallback === handleBlurDefer) {
                if (!(((_a = refPopper.value) == null ? void 0 : _a.isFocusInsideContent()) && !hasJustTabExitedInput) && refInput.value.filter((input) => {
                  return input.contains(document.activeElement);
                }).length === 0) {
                  handleChange();
                  pickerVisible.value = false;
                  emit("blur", e);
                  props.validateEvent && (formItem == null ? void 0 : formItem.validate("blur").catch((err) => debugWarn()));
                }
                hasJustTabExitedInput = false;
              }
            }, 0);
          };
          currentHandleBlurDeferCallback = handleBlurDefer;
          handleBlurDefer();
        };
        const pickerDisabled = vue.computed(() => {
          return props.disabled || (form == null ? void 0 : form.disabled);
        });
        const parsedValue = vue.computed(() => {
          let dayOrDays;
          if (valueIsEmpty.value) {
            if (pickerOptions.value.getDefaultValue) {
              dayOrDays = pickerOptions.value.getDefaultValue();
            }
          } else {
            if (isArray(props.modelValue)) {
              dayOrDays = props.modelValue.map((d) => parseDate(d, props.valueFormat, lang.value));
            } else {
              dayOrDays = parseDate(props.modelValue, props.valueFormat, lang.value);
            }
          }
          if (pickerOptions.value.getRangeAvailableTime) {
            const availableResult = pickerOptions.value.getRangeAvailableTime(dayOrDays);
            if (!isEqual$1(availableResult, dayOrDays)) {
              dayOrDays = availableResult;
              emitInput(isArray(dayOrDays) ? dayOrDays.map((_) => _.toDate()) : dayOrDays.toDate());
            }
          }
          if (isArray(dayOrDays) && dayOrDays.some((day) => !day)) {
            dayOrDays = [];
          }
          return dayOrDays;
        });
        const displayValue = vue.computed(() => {
          if (!pickerOptions.value.panelReady)
            return "";
          const formattedValue = formatDayjsToString(parsedValue.value);
          if (isArray(userInput.value)) {
            return [
              userInput.value[0] || formattedValue && formattedValue[0] || "",
              userInput.value[1] || formattedValue && formattedValue[1] || ""
            ];
          } else if (userInput.value !== null) {
            return userInput.value;
          }
          if (!isTimePicker.value && valueIsEmpty.value)
            return "";
          if (!pickerVisible.value && valueIsEmpty.value)
            return "";
          if (formattedValue) {
            return isDatesPicker.value ? formattedValue.join(", ") : formattedValue;
          }
          return "";
        });
        const isTimeLikePicker = vue.computed(() => props.type.includes("time"));
        const isTimePicker = vue.computed(() => props.type.startsWith("time"));
        const isDatesPicker = vue.computed(() => props.type === "dates");
        const triggerIcon = vue.computed(() => props.prefixIcon || (isTimeLikePicker.value ? clock_default : calendar_default));
        const showClose = vue.ref(false);
        const onClearIconClick = (event) => {
          if (props.readonly || pickerDisabled.value)
            return;
          if (showClose.value) {
            event.stopPropagation();
            focusOnInputBox();
            emitInput(null);
            emitChange(null, true);
            showClose.value = false;
            pickerVisible.value = false;
            pickerOptions.value.handleClear && pickerOptions.value.handleClear();
          }
        };
        const valueIsEmpty = vue.computed(() => {
          const { modelValue } = props;
          return !modelValue || isArray(modelValue) && !modelValue.filter(Boolean).length;
        });
        const onMouseDownInput = async (event) => {
          var _a;
          if (props.readonly || pickerDisabled.value)
            return;
          if (((_a = event.target) == null ? void 0 : _a.tagName) !== "INPUT" || refInput.value.includes(document.activeElement)) {
            pickerVisible.value = true;
          }
        };
        const onMouseEnter = () => {
          if (props.readonly || pickerDisabled.value)
            return;
          if (!valueIsEmpty.value && props.clearable) {
            showClose.value = true;
          }
        };
        const onMouseLeave = () => {
          showClose.value = false;
        };
        const onTouchStartInput = (event) => {
          var _a;
          if (props.readonly || pickerDisabled.value)
            return;
          if (((_a = event.touches[0].target) == null ? void 0 : _a.tagName) !== "INPUT" || refInput.value.includes(document.activeElement)) {
            pickerVisible.value = true;
          }
        };
        const isRangeInput = vue.computed(() => {
          return props.type.includes("range");
        });
        const pickerSize = useSize();
        const popperEl = vue.computed(() => {
          var _a, _b;
          return (_b = (_a = vue.unref(refPopper)) == null ? void 0 : _a.popperRef) == null ? void 0 : _b.contentRef;
        });
        const actualInputRef = vue.computed(() => {
          var _a;
          if (vue.unref(isRangeInput)) {
            return vue.unref(inputRef);
          }
          return (_a = vue.unref(inputRef)) == null ? void 0 : _a.$el;
        });
        onClickOutside(actualInputRef, (e) => {
          const unrefedPopperEl = vue.unref(popperEl);
          const inputEl = vue.unref(actualInputRef);
          if (unrefedPopperEl && (e.target === unrefedPopperEl || e.composedPath().includes(unrefedPopperEl)) || e.target === inputEl || e.composedPath().includes(inputEl))
            return;
          pickerVisible.value = false;
        });
        const userInput = vue.ref(null);
        const handleChange = () => {
          if (userInput.value) {
            const value = parseUserInputToDayjs(displayValue.value);
            if (value) {
              if (isValidValue(value)) {
                emitInput(isArray(value) ? value.map((_) => _.toDate()) : value.toDate());
                userInput.value = null;
              }
            }
          }
          if (userInput.value === "") {
            emitInput(null);
            emitChange(null);
            userInput.value = null;
          }
        };
        const parseUserInputToDayjs = (value) => {
          if (!value)
            return null;
          return pickerOptions.value.parseUserInput(value);
        };
        const formatDayjsToString = (value) => {
          if (!value)
            return null;
          return pickerOptions.value.formatToString(value);
        };
        const isValidValue = (value) => {
          return pickerOptions.value.isValidValue(value);
        };
        const handleKeydownInput = async (event) => {
          if (props.readonly || pickerDisabled.value)
            return;
          const { code } = event;
          emitKeydown(event);
          if (code === EVENT_CODE.esc) {
            if (pickerVisible.value === true) {
              pickerVisible.value = false;
              event.preventDefault();
              event.stopPropagation();
            }
            return;
          }
          if (code === EVENT_CODE.down) {
            if (pickerOptions.value.handleFocusPicker) {
              event.preventDefault();
              event.stopPropagation();
            }
            if (pickerVisible.value === false) {
              pickerVisible.value = true;
              await vue.nextTick();
            }
            if (pickerOptions.value.handleFocusPicker) {
              pickerOptions.value.handleFocusPicker();
              return;
            }
          }
          if (code === EVENT_CODE.tab) {
            hasJustTabExitedInput = true;
            return;
          }
          if (code === EVENT_CODE.enter || code === EVENT_CODE.numpadEnter) {
            if (userInput.value === null || userInput.value === "" || isValidValue(parseUserInputToDayjs(displayValue.value))) {
              handleChange();
              pickerVisible.value = false;
            }
            event.stopPropagation();
            return;
          }
          if (userInput.value) {
            event.stopPropagation();
            return;
          }
          if (pickerOptions.value.handleKeydownInput) {
            pickerOptions.value.handleKeydownInput(event);
          }
        };
        const onUserInput = (e) => {
          userInput.value = e;
          if (!pickerVisible.value) {
            pickerVisible.value = true;
          }
        };
        const handleStartInput = (event) => {
          const target = event.target;
          if (userInput.value) {
            userInput.value = [target.value, userInput.value[1]];
          } else {
            userInput.value = [target.value, null];
          }
        };
        const handleEndInput = (event) => {
          const target = event.target;
          if (userInput.value) {
            userInput.value = [userInput.value[0], target.value];
          } else {
            userInput.value = [null, target.value];
          }
        };
        const handleStartChange = () => {
          var _a;
          const values = userInput.value;
          const value = parseUserInputToDayjs(values && values[0]);
          const parsedVal = vue.unref(parsedValue);
          if (value && value.isValid()) {
            userInput.value = [
              formatDayjsToString(value),
              ((_a = displayValue.value) == null ? void 0 : _a[1]) || null
            ];
            const newValue = [value, parsedVal && (parsedVal[1] || null)];
            if (isValidValue(newValue)) {
              emitInput(newValue);
              userInput.value = null;
            }
          }
        };
        const handleEndChange = () => {
          var _a;
          const values = vue.unref(userInput);
          const value = parseUserInputToDayjs(values && values[1]);
          const parsedVal = vue.unref(parsedValue);
          if (value && value.isValid()) {
            userInput.value = [
              ((_a = vue.unref(displayValue)) == null ? void 0 : _a[0]) || null,
              formatDayjsToString(value)
            ];
            const newValue = [parsedVal && parsedVal[0], value];
            if (isValidValue(newValue)) {
              emitInput(newValue);
              userInput.value = null;
            }
          }
        };
        const pickerOptions = vue.ref({});
        const onSetPickerOption = (e) => {
          pickerOptions.value[e[0]] = e[1];
          pickerOptions.value.panelReady = true;
        };
        const onCalendarChange = (e) => {
          emit("calendar-change", e);
        };
        const onPanelChange = (value, mode, view) => {
          emit("panel-change", value, mode, view);
        };
        vue.provide("EP_PICKER_BASE", {
          props
        });
        expose({
          focus,
          handleFocusInput,
          handleBlurInput,
          handleOpen,
          handleClose,
          onPick
        });
        return (_ctx, _cache) => {
          return vue.openBlock(), vue.createBlock(vue.unref(ElTooltip), vue.mergeProps({
            ref_key: "refPopper",
            ref: refPopper,
            visible: pickerVisible.value,
            effect: "light",
            pure: "",
            trigger: "click"
          }, _ctx.$attrs, {
            role: "dialog",
            teleported: "",
            transition: `${vue.unref(nsDate).namespace.value}-zoom-in-top`,
            "popper-class": [`${vue.unref(nsDate).namespace.value}-picker__popper`, _ctx.popperClass],
            "popper-options": vue.unref(elPopperOptions),
            "fallback-placements": ["bottom", "top", "right", "left"],
            "gpu-acceleration": false,
            "stop-popper-mouse-event": false,
            "hide-after": 0,
            persistent: "",
            onBeforeShow,
            onShow,
            onHide
          }), {
            default: vue.withCtx(() => [
              !vue.unref(isRangeInput) ? (vue.openBlock(), vue.createBlock(vue.unref(ElInput), {
                key: 0,
                id: _ctx.id,
                ref_key: "inputRef",
                ref: inputRef,
                "container-role": "combobox",
                "model-value": vue.unref(displayValue),
                name: _ctx.name,
                size: vue.unref(pickerSize),
                disabled: vue.unref(pickerDisabled),
                placeholder: _ctx.placeholder,
                class: vue.normalizeClass([vue.unref(nsDate).b("editor"), vue.unref(nsDate).bm("editor", _ctx.type), _ctx.$attrs.class]),
                style: vue.normalizeStyle(_ctx.$attrs.style),
                readonly: !_ctx.editable || _ctx.readonly || vue.unref(isDatesPicker) || _ctx.type === "week",
                label: _ctx.label,
                tabindex: _ctx.tabindex,
                "validate-event": false,
                onInput: onUserInput,
                onFocus: handleFocusInput,
                onBlur: handleBlurInput,
                onKeydown: handleKeydownInput,
                onChange: handleChange,
                onMousedown: onMouseDownInput,
                onMouseenter: onMouseEnter,
                onMouseleave: onMouseLeave,
                onTouchstart: onTouchStartInput,
                onClick: _cache[0] || (_cache[0] = vue.withModifiers(() => {
                }, ["stop"]))
              }, {
                prefix: vue.withCtx(() => [
                  vue.unref(triggerIcon) ? (vue.openBlock(), vue.createBlock(vue.unref(ElIcon), {
                    key: 0,
                    class: vue.normalizeClass(vue.unref(nsInput).e("icon")),
                    onMousedown: vue.withModifiers(onMouseDownInput, ["prevent"]),
                    onTouchstart: onTouchStartInput
                  }, {
                    default: vue.withCtx(() => [
                      (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(vue.unref(triggerIcon))))
                    ]),
                    _: 1
                  }, 8, ["class", "onMousedown"])) : vue.createCommentVNode("v-if", true)
                ]),
                suffix: vue.withCtx(() => [
                  showClose.value && _ctx.clearIcon ? (vue.openBlock(), vue.createBlock(vue.unref(ElIcon), {
                    key: 0,
                    class: vue.normalizeClass(`${vue.unref(nsInput).e("icon")} clear-icon`),
                    onClick: vue.withModifiers(onClearIconClick, ["stop"])
                  }, {
                    default: vue.withCtx(() => [
                      (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(_ctx.clearIcon)))
                    ]),
                    _: 1
                  }, 8, ["class", "onClick"])) : vue.createCommentVNode("v-if", true)
                ]),
                _: 1
              }, 8, ["id", "model-value", "name", "size", "disabled", "placeholder", "class", "style", "readonly", "label", "tabindex", "onKeydown"])) : (vue.openBlock(), vue.createElementBlock("div", {
                key: 1,
                ref_key: "inputRef",
                ref: inputRef,
                class: vue.normalizeClass([
                  vue.unref(nsDate).b("editor"),
                  vue.unref(nsDate).bm("editor", _ctx.type),
                  vue.unref(nsInput).e("wrapper"),
                  vue.unref(nsDate).is("disabled", vue.unref(pickerDisabled)),
                  vue.unref(nsDate).is("active", pickerVisible.value),
                  vue.unref(nsRange).b("editor"),
                  vue.unref(pickerSize) ? vue.unref(nsRange).bm("editor", vue.unref(pickerSize)) : "",
                  _ctx.$attrs.class
                ]),
                style: vue.normalizeStyle(_ctx.$attrs.style),
                onClick: handleFocusInput,
                onMouseenter: onMouseEnter,
                onMouseleave: onMouseLeave,
                onTouchstart: onTouchStartInput,
                onKeydown: handleKeydownInput
              }, [
                vue.unref(triggerIcon) ? (vue.openBlock(), vue.createBlock(vue.unref(ElIcon), {
                  key: 0,
                  class: vue.normalizeClass([vue.unref(nsInput).e("icon"), vue.unref(nsRange).e("icon")]),
                  onMousedown: vue.withModifiers(onMouseDownInput, ["prevent"]),
                  onTouchstart: onTouchStartInput
                }, {
                  default: vue.withCtx(() => [
                    (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(vue.unref(triggerIcon))))
                  ]),
                  _: 1
                }, 8, ["class", "onMousedown"])) : vue.createCommentVNode("v-if", true),
                vue.createElementVNode("input", {
                  id: _ctx.id && _ctx.id[0],
                  autocomplete: "off",
                  name: _ctx.name && _ctx.name[0],
                  placeholder: _ctx.startPlaceholder,
                  value: vue.unref(displayValue) && vue.unref(displayValue)[0],
                  disabled: vue.unref(pickerDisabled),
                  readonly: !_ctx.editable || _ctx.readonly,
                  class: vue.normalizeClass(vue.unref(nsRange).b("input")),
                  onMousedown: onMouseDownInput,
                  onInput: handleStartInput,
                  onChange: handleStartChange,
                  onFocus: handleFocusInput,
                  onBlur: handleBlurInput
                }, null, 42, _hoisted_1$Z),
                vue.renderSlot(_ctx.$slots, "range-separator", {}, () => [
                  vue.createElementVNode("span", {
                    class: vue.normalizeClass(vue.unref(nsRange).b("separator"))
                  }, vue.toDisplayString(_ctx.rangeSeparator), 3)
                ]),
                vue.createElementVNode("input", {
                  id: _ctx.id && _ctx.id[1],
                  autocomplete: "off",
                  name: _ctx.name && _ctx.name[1],
                  placeholder: _ctx.endPlaceholder,
                  value: vue.unref(displayValue) && vue.unref(displayValue)[1],
                  disabled: vue.unref(pickerDisabled),
                  readonly: !_ctx.editable || _ctx.readonly,
                  class: vue.normalizeClass(vue.unref(nsRange).b("input")),
                  onMousedown: onMouseDownInput,
                  onFocus: handleFocusInput,
                  onBlur: handleBlurInput,
                  onInput: handleEndInput,
                  onChange: handleEndChange
                }, null, 42, _hoisted_2$D),
                _ctx.clearIcon ? (vue.openBlock(), vue.createBlock(vue.unref(ElIcon), {
                  key: 1,
                  class: vue.normalizeClass([
                    vue.unref(nsInput).e("icon"),
                    vue.unref(nsRange).e("close-icon"),
                    {
                      [vue.unref(nsRange).e("close-icon--hidden")]: !showClose.value
                    }
                  ]),
                  onClick: onClearIconClick
                }, {
                  default: vue.withCtx(() => [
                    (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(_ctx.clearIcon)))
                  ]),
                  _: 1
                }, 8, ["class"])) : vue.createCommentVNode("v-if", true)
              ], 38))
            ]),
            content: vue.withCtx(() => [
              vue.renderSlot(_ctx.$slots, "default", {
                visible: pickerVisible.value,
                actualVisible: pickerActualVisible.value,
                parsedValue: vue.unref(parsedValue),
                format: _ctx.format,
                unlinkPanels: _ctx.unlinkPanels,
                type: _ctx.type,
                defaultValue: _ctx.defaultValue,
                onPick,
                onSelectRange: setSelectionRange,
                onSetPickerOption,
                onCalendarChange,
                onPanelChange,
                onKeydown: onKeydownPopperContent,
                onMousedown: _cache[1] || (_cache[1] = vue.withModifiers(() => {
                }, ["stop"]))
              })
            ]),
            _: 3
          }, 16, ["visible", "transition", "popper-class", "popper-options"]);
        };
      }
    });
    var CommonPicker = /* @__PURE__ */ _export_sfc(_sfc_main$1U, [["__file", "picker.vue"]]);
  
    const panelTimePickerProps = buildProps({
      ...timePanelSharedProps,
      datetimeRole: String,
      parsedValue: {
        type: definePropType(Object)
      }
    });
  
    const useTimePanel = ({
      getAvailableHours,
      getAvailableMinutes,
      getAvailableSeconds
    }) => {
      const getAvailableTime = (date, role, first, compareDate) => {
        const availableTimeGetters = {
          hour: getAvailableHours,
          minute: getAvailableMinutes,
          second: getAvailableSeconds
        };
        let result = date;
        ["hour", "minute", "second"].forEach((type) => {
          if (availableTimeGetters[type]) {
            let availableTimeSlots;
            const method = availableTimeGetters[type];
            switch (type) {
              case "minute": {
                availableTimeSlots = method(result.hour(), role, compareDate);
                break;
              }
              case "second": {
                availableTimeSlots = method(result.hour(), result.minute(), role, compareDate);
                break;
              }
              default: {
                availableTimeSlots = method(role, compareDate);
                break;
              }
            }
            if ((availableTimeSlots == null ? void 0 : availableTimeSlots.length) && !availableTimeSlots.includes(result[type]())) {
              const pos = first ? 0 : availableTimeSlots.length - 1;
              result = result[type](availableTimeSlots[pos]);
            }
          }
        });
        return result;
      };
      const timePickerOptions = {};
      const onSetOption = ([key, val]) => {
        timePickerOptions[key] = val;
      };
      return {
        timePickerOptions,
        getAvailableTime,
        onSetOption
      };
    };
  
    const makeAvailableArr = (disabledList) => {
      const trueOrNumber = (isDisabled, index) => isDisabled || index;
      const getNumber = (predicate) => predicate !== true;
      return disabledList.map(trueOrNumber).filter(getNumber);
    };
    const getTimeLists = (disabledHours, disabledMinutes, disabledSeconds) => {
      const getHoursList = (role, compare) => {
        return makeList(24, disabledHours && (() => disabledHours == null ? void 0 : disabledHours(role, compare)));
      };
      const getMinutesList = (hour, role, compare) => {
        return makeList(60, disabledMinutes && (() => disabledMinutes == null ? void 0 : disabledMinutes(hour, role, compare)));
      };
      const getSecondsList = (hour, minute, role, compare) => {
        return makeList(60, disabledSeconds && (() => disabledSeconds == null ? void 0 : disabledSeconds(hour, minute, role, compare)));
      };
      return {
        getHoursList,
        getMinutesList,
        getSecondsList
      };
    };
    const buildAvailableTimeSlotGetter = (disabledHours, disabledMinutes, disabledSeconds) => {
      const { getHoursList, getMinutesList, getSecondsList } = getTimeLists(disabledHours, disabledMinutes, disabledSeconds);
      const getAvailableHours = (role, compare) => {
        return makeAvailableArr(getHoursList(role, compare));
      };
      const getAvailableMinutes = (hour, role, compare) => {
        return makeAvailableArr(getMinutesList(hour, role, compare));
      };
      const getAvailableSeconds = (hour, minute, role, compare) => {
        return makeAvailableArr(getSecondsList(hour, minute, role, compare));
      };
      return {
        getAvailableHours,
        getAvailableMinutes,
        getAvailableSeconds
      };
    };
    const useOldValue = (props) => {
      const oldValue = vue.ref(props.parsedValue);
      vue.watch(() => props.visible, (val) => {
        if (!val) {
          oldValue.value = props.parsedValue;
        }
      });
      return oldValue;
    };
  
    const nodeList = /* @__PURE__ */ new Map();
    let startClick;
    if (isClient) {
      document.addEventListener("mousedown", (e) => startClick = e);
      document.addEventListener("mouseup", (e) => {
        for (const handlers of nodeList.values()) {
          for (const { documentHandler } of handlers) {
            documentHandler(e, startClick);
          }
        }
      });
    }
    function createDocumentHandler(el, binding) {
      let excludes = [];
      if (Array.isArray(binding.arg)) {
        excludes = binding.arg;
      } else if (isElement$1(binding.arg)) {
        excludes.push(binding.arg);
      }
      return function(mouseup, mousedown) {
        const popperRef = binding.instance.popperRef;
        const mouseUpTarget = mouseup.target;
        const mouseDownTarget = mousedown == null ? void 0 : mousedown.target;
        const isBound = !binding || !binding.instance;
        const isTargetExists = !mouseUpTarget || !mouseDownTarget;
        const isContainedByEl = el.contains(mouseUpTarget) || el.contains(mouseDownTarget);
        const isSelf = el === mouseUpTarget;
        const isTargetExcluded = excludes.length && excludes.some((item) => item == null ? void 0 : item.contains(mouseUpTarget)) || excludes.length && excludes.includes(mouseDownTarget);
        const isContainedByPopper = popperRef && (popperRef.contains(mouseUpTarget) || popperRef.contains(mouseDownTarget));
        if (isBound || isTargetExists || isContainedByEl || isSelf || isTargetExcluded || isContainedByPopper) {
          return;
        }
        binding.value(mouseup, mousedown);
      };
    }
    const ClickOutside = {
      beforeMount(el, binding) {
        if (!nodeList.has(el)) {
          nodeList.set(el, []);
        }
        nodeList.get(el).push({
          documentHandler: createDocumentHandler(el, binding),
          bindingFn: binding.value
        });
      },
      updated(el, binding) {
        if (!nodeList.has(el)) {
          nodeList.set(el, []);
        }
        const handlers = nodeList.get(el);
        const oldHandlerIndex = handlers.findIndex((item) => item.bindingFn === binding.oldValue);
        const newHandler = {
          documentHandler: createDocumentHandler(el, binding),
          bindingFn: binding.value
        };
        if (oldHandlerIndex >= 0) {
          handlers.splice(oldHandlerIndex, 1, newHandler);
        } else {
          handlers.push(newHandler);
        }
      },
      unmounted(el) {
        nodeList.delete(el);
      }
    };
  
    const REPEAT_INTERVAL = 100;
    const REPEAT_DELAY = 600;
    const vRepeatClick = {
      beforeMount(el, binding) {
        const value = binding.value;
        const { interval = REPEAT_INTERVAL, delay = REPEAT_DELAY } = isFunction(value) ? {} : value;
        let intervalId;
        let delayId;
        const handler = () => isFunction(value) ? value() : value.handler();
        const clear = () => {
          if (delayId) {
            clearTimeout(delayId);
            delayId = void 0;
          }
          if (intervalId) {
            clearInterval(intervalId);
            intervalId = void 0;
          }
        };
        el.addEventListener("mousedown", (evt) => {
          if (evt.button !== 0)
            return;
          clear();
          handler();
          document.addEventListener("mouseup", () => clear(), {
            once: true
          });
          delayId = setTimeout(() => {
            intervalId = setInterval(() => {
              handler();
            }, interval);
          }, delay);
        });
      }
    };
  
    const FOCUSABLE_CHILDREN = "_trap-focus-children";
    const FOCUS_STACK = [];
    const FOCUS_HANDLER = (e) => {
      if (FOCUS_STACK.length === 0)
        return;
      const focusableElement = FOCUS_STACK[FOCUS_STACK.length - 1][FOCUSABLE_CHILDREN];
      if (focusableElement.length > 0 && e.code === EVENT_CODE.tab) {
        if (focusableElement.length === 1) {
          e.preventDefault();
          if (document.activeElement !== focusableElement[0]) {
            focusableElement[0].focus();
          }
          return;
        }
        const goingBackward = e.shiftKey;
        const isFirst = e.target === focusableElement[0];
        const isLast = e.target === focusableElement[focusableElement.length - 1];
        if (isFirst && goingBackward) {
          e.preventDefault();
          focusableElement[focusableElement.length - 1].focus();
        }
        if (isLast && !goingBackward) {
          e.preventDefault();
          focusableElement[0].focus();
        }
      }
    };
    const TrapFocus = {
      beforeMount(el) {
        el[FOCUSABLE_CHILDREN] = obtainAllFocusableElements$1(el);
        FOCUS_STACK.push(el);
        if (FOCUS_STACK.length <= 1) {
          document.addEventListener("keydown", FOCUS_HANDLER);
        }
      },
      updated(el) {
        vue.nextTick(() => {
          el[FOCUSABLE_CHILDREN] = obtainAllFocusableElements$1(el);
        });
      },
      unmounted() {
        FOCUS_STACK.shift();
        if (FOCUS_STACK.length === 0) {
          document.removeEventListener("keydown", FOCUS_HANDLER);
        }
      }
    };
  
    var v=!1,o,f,s,u,d,N,l,p,m,w,D,x,E,M,F;function a(){if(!v){v=!0;var e=navigator.userAgent,n=/(?:MSIE.(\d+\.\d+))|(?:(?:Firefox|GranParadiso|Iceweasel).(\d+\.\d+))|(?:Opera(?:.+Version.|.)(\d+\.\d+))|(?:AppleWebKit.(\d+(?:\.\d+)?))|(?:Trident\/\d+\.\d+.*rv:(\d+\.\d+))/.exec(e),i=/(Mac OS X)|(Windows)|(Linux)/.exec(e);if(x=/\b(iPhone|iP[ao]d)/.exec(e),E=/\b(iP[ao]d)/.exec(e),w=/Android/i.exec(e),M=/FBAN\/\w+;/i.exec(e),F=/Mobile/i.exec(e),D=!!/Win64/.exec(e),n){o=n[1]?parseFloat(n[1]):n[5]?parseFloat(n[5]):NaN,o&&document&&document.documentMode&&(o=document.documentMode);var r=/(?:Trident\/(\d+.\d+))/.exec(e);N=r?parseFloat(r[1])+4:o,f=n[2]?parseFloat(n[2]):NaN,s=n[3]?parseFloat(n[3]):NaN,u=n[4]?parseFloat(n[4]):NaN,u?(n=/(?:Chrome\/(\d+\.\d+))/.exec(e),d=n&&n[1]?parseFloat(n[1]):NaN):d=NaN;}else o=f=s=d=u=NaN;if(i){if(i[1]){var t=/(?:Mac OS X (\d+(?:[._]\d+)?))/.exec(e);l=t?parseFloat(t[1].replace("_",".")):!0;}else l=!1;p=!!i[2],m=!!i[3];}else l=p=m=!1;}}var _={ie:function(){return a()||o},ieCompatibilityMode:function(){return a()||N>o},ie64:function(){return _.ie()&&D},firefox:function(){return a()||f},opera:function(){return a()||s},webkit:function(){return a()||u},safari:function(){return _.webkit()},chrome:function(){return a()||d},windows:function(){return a()||p},osx:function(){return a()||l},linux:function(){return a()||m},iphone:function(){return a()||x},mobile:function(){return a()||x||E||w||F},nativeApp:function(){return a()||M},android:function(){return a()||w},ipad:function(){return a()||E}},A=_;var c=!!(typeof window<"u"&&window.document&&window.document.createElement),U={canUseDOM:c,canUseWorkers:typeof Worker<"u",canUseEventListeners:c&&!!(window.addEventListener||window.attachEvent),canUseViewport:c&&!!window.screen,isInWorker:!c},h=U;var X;h.canUseDOM&&(X=document.implementation&&document.implementation.hasFeature&&document.implementation.hasFeature("","")!==!0);function S(e,n){if(!h.canUseDOM||n&&!("addEventListener"in document))return !1;var i="on"+e,r=i in document;if(!r){var t=document.createElement("div");t.setAttribute(i,"return;"),r=typeof t[i]=="function";}return !r&&X&&e==="wheel"&&(r=document.implementation.hasFeature("Events.wheel","3.0")),r}var b=S;var O=10,I=40,P=800;function T(e){var n=0,i=0,r=0,t=0;return "detail"in e&&(i=e.detail),"wheelDelta"in e&&(i=-e.wheelDelta/120),"wheelDeltaY"in e&&(i=-e.wheelDeltaY/120),"wheelDeltaX"in e&&(n=-e.wheelDeltaX/120),"axis"in e&&e.axis===e.HORIZONTAL_AXIS&&(n=i,i=0),r=n*O,t=i*O,"deltaY"in e&&(t=e.deltaY),"deltaX"in e&&(r=e.deltaX),(r||t)&&e.deltaMode&&(e.deltaMode==1?(r*=I,t*=I):(r*=P,t*=P)),r&&!n&&(n=r<1?-1:1),t&&!i&&(i=t<1?-1:1),{spinX:n,spinY:i,pixelX:r,pixelY:t}}T.getEventType=function(){return A.firefox()?"DOMMouseScroll":b("wheel")?"wheel":"mousewheel"};var Y=T;/**
     * Checks if an event is supported in the current execution environment.
     *
     * NOTE: This will not work correctly for non-generic events such as `change`,
     * `reset`, `load`, `error`, and `select`.
     *
     * Borrows from Modernizr.
     *
     * @param {string} eventNameSuffix Event name, e.g. "click".
     * @param {?boolean} capture Check if the capture phase is supported.
     * @return {boolean} True if the event is supported.
     * @internal
     * @license Modernizr 3.0.0pre (Custom Build) | MIT
     */
  
    const mousewheel = function(element, callback) {
      if (element && element.addEventListener) {
        const fn = function(event) {
          const normalized = Y(event);
          callback && Reflect.apply(callback, this, [event, normalized]);
        };
        element.addEventListener("wheel", fn, { passive: true });
      }
    };
    const Mousewheel = {
      beforeMount(el, binding) {
        mousewheel(el, binding.value);
      }
    };
  
    const basicTimeSpinnerProps = buildProps({
      role: {
        type: String,
        required: true
      },
      spinnerDate: {
        type: definePropType(Object),
        required: true
      },
      showSeconds: {
        type: Boolean,
        default: true
      },
      arrowControl: Boolean,
      amPmMode: {
        type: definePropType(String),
        default: ""
      },
      ...disabledTimeListsProps
    });
  
    const _hoisted_1$Y = ["onClick"];
    const _hoisted_2$C = ["onMouseenter"];
    const _sfc_main$1T = /* @__PURE__ */ vue.defineComponent({
      __name: "basic-time-spinner",
      props: basicTimeSpinnerProps,
      emits: ["change", "select-range", "set-option"],
      setup(__props, { emit }) {
        const props = __props;
        const ns = useNamespace("time");
        const { getHoursList, getMinutesList, getSecondsList } = getTimeLists(props.disabledHours, props.disabledMinutes, props.disabledSeconds);
        let isScrolling = false;
        const currentScrollbar = vue.ref();
        const listHoursRef = vue.ref();
        const listMinutesRef = vue.ref();
        const listSecondsRef = vue.ref();
        const listRefsMap = {
          hours: listHoursRef,
          minutes: listMinutesRef,
          seconds: listSecondsRef
        };
        const spinnerItems = vue.computed(() => {
          return props.showSeconds ? timeUnits : timeUnits.slice(0, 2);
        });
        const timePartials = vue.computed(() => {
          const { spinnerDate } = props;
          const hours = spinnerDate.hour();
          const minutes = spinnerDate.minute();
          const seconds = spinnerDate.second();
          return { hours, minutes, seconds };
        });
        const timeList = vue.computed(() => {
          const { hours, minutes } = vue.unref(timePartials);
          return {
            hours: getHoursList(props.role),
            minutes: getMinutesList(hours, props.role),
            seconds: getSecondsList(hours, minutes, props.role)
          };
        });
        const arrowControlTimeList = vue.computed(() => {
          const { hours, minutes, seconds } = vue.unref(timePartials);
          return {
            hours: buildTimeList(hours, 23),
            minutes: buildTimeList(minutes, 59),
            seconds: buildTimeList(seconds, 59)
          };
        });
        const debouncedResetScroll = debounce((type) => {
          isScrolling = false;
          adjustCurrentSpinner(type);
        }, 200);
        const getAmPmFlag = (hour) => {
          const shouldShowAmPm = !!props.amPmMode;
          if (!shouldShowAmPm)
            return "";
          const isCapital = props.amPmMode === "A";
          let content = hour < 12 ? " am" : " pm";
          if (isCapital)
            content = content.toUpperCase();
          return content;
        };
        const emitSelectRange = (type) => {
          let range;
          switch (type) {
            case "hours":
              range = [0, 2];
              break;
            case "minutes":
              range = [3, 5];
              break;
            case "seconds":
              range = [6, 8];
              break;
          }
          const [left, right] = range;
          emit("select-range", left, right);
          currentScrollbar.value = type;
        };
        const adjustCurrentSpinner = (type) => {
          adjustSpinner(type, vue.unref(timePartials)[type]);
        };
        const adjustSpinners = () => {
          adjustCurrentSpinner("hours");
          adjustCurrentSpinner("minutes");
          adjustCurrentSpinner("seconds");
        };
        const getScrollbarElement = (el) => el.querySelector(`.${ns.namespace.value}-scrollbar__wrap`);
        const adjustSpinner = (type, value) => {
          if (props.arrowControl)
            return;
          const scrollbar = vue.unref(listRefsMap[type]);
          if (scrollbar && scrollbar.$el) {
            getScrollbarElement(scrollbar.$el).scrollTop = Math.max(0, value * typeItemHeight(type));
          }
        };
        const typeItemHeight = (type) => {
          const scrollbar = vue.unref(listRefsMap[type]);
          return (scrollbar == null ? void 0 : scrollbar.$el.querySelector("li").offsetHeight) || 0;
        };
        const onIncrement = () => {
          scrollDown(1);
        };
        const onDecrement = () => {
          scrollDown(-1);
        };
        const scrollDown = (step) => {
          if (!currentScrollbar.value) {
            emitSelectRange("hours");
          }
          const label = currentScrollbar.value;
          const now = vue.unref(timePartials)[label];
          const total = currentScrollbar.value === "hours" ? 24 : 60;
          const next = findNextUnDisabled(label, now, step, total);
          modifyDateField(label, next);
          adjustSpinner(label, next);
          vue.nextTick(() => emitSelectRange(label));
        };
        const findNextUnDisabled = (type, now, step, total) => {
          let next = (now + step + total) % total;
          const list = vue.unref(timeList)[type];
          while (list[next] && next !== now) {
            next = (next + step + total) % total;
          }
          return next;
        };
        const modifyDateField = (type, value) => {
          const list = vue.unref(timeList)[type];
          const isDisabled = list[value];
          if (isDisabled)
            return;
          const { hours, minutes, seconds } = vue.unref(timePartials);
          let changeTo;
          switch (type) {
            case "hours":
              changeTo = props.spinnerDate.hour(value).minute(minutes).second(seconds);
              break;
            case "minutes":
              changeTo = props.spinnerDate.hour(hours).minute(value).second(seconds);
              break;
            case "seconds":
              changeTo = props.spinnerDate.hour(hours).minute(minutes).second(value);
              break;
          }
          emit("change", changeTo);
        };
        const handleClick = (type, { value, disabled }) => {
          if (!disabled) {
            modifyDateField(type, value);
            emitSelectRange(type);
            adjustSpinner(type, value);
          }
        };
        const handleScroll = (type) => {
          isScrolling = true;
          debouncedResetScroll(type);
          const value = Math.min(Math.round((getScrollbarElement(vue.unref(listRefsMap[type]).$el).scrollTop - (scrollBarHeight(type) * 0.5 - 10) / typeItemHeight(type) + 3) / typeItemHeight(type)), type === "hours" ? 23 : 59);
          modifyDateField(type, value);
        };
        const scrollBarHeight = (type) => {
          return vue.unref(listRefsMap[type]).$el.offsetHeight;
        };
        const bindScrollEvent = () => {
          const bindFunction = (type) => {
            const scrollbar = vue.unref(listRefsMap[type]);
            if (scrollbar && scrollbar.$el) {
              getScrollbarElement(scrollbar.$el).onscroll = () => {
                handleScroll(type);
              };
            }
          };
          bindFunction("hours");
          bindFunction("minutes");
          bindFunction("seconds");
        };
        vue.onMounted(() => {
          vue.nextTick(() => {
            !props.arrowControl && bindScrollEvent();
            adjustSpinners();
            if (props.role === "start")
              emitSelectRange("hours");
          });
        });
        const setRef = (scrollbar, type) => {
          listRefsMap[type].value = scrollbar;
        };
        emit("set-option", [`${props.role}_scrollDown`, scrollDown]);
        emit("set-option", [`${props.role}_emitSelectRange`, emitSelectRange]);
        vue.watch(() => props.spinnerDate, () => {
          if (isScrolling)
            return;
          adjustSpinners();
        });
        return (_ctx, _cache) => {
          return vue.openBlock(), vue.createElementBlock("div", {
            class: vue.normalizeClass([vue.unref(ns).b("spinner"), { "has-seconds": _ctx.showSeconds }])
          }, [
            !_ctx.arrowControl ? (vue.openBlock(true), vue.createElementBlock(vue.Fragment, { key: 0 }, vue.renderList(vue.unref(spinnerItems), (item) => {
              return vue.openBlock(), vue.createBlock(vue.unref(ElScrollbar), {
                key: item,
                ref_for: true,
                ref: (scrollbar) => setRef(scrollbar, item),
                class: vue.normalizeClass(vue.unref(ns).be("spinner", "wrapper")),
                "wrap-style": "max-height: inherit;",
                "view-class": vue.unref(ns).be("spinner", "list"),
                noresize: "",
                tag: "ul",
                onMouseenter: ($event) => emitSelectRange(item),
                onMousemove: ($event) => adjustCurrentSpinner(item)
              }, {
                default: vue.withCtx(() => [
                  (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(vue.unref(timeList)[item], (disabled, key) => {
                    return vue.openBlock(), vue.createElementBlock("li", {
                      key,
                      class: vue.normalizeClass([
                        vue.unref(ns).be("spinner", "item"),
                        vue.unref(ns).is("active", key === vue.unref(timePartials)[item]),
                        vue.unref(ns).is("disabled", disabled)
                      ]),
                      onClick: ($event) => handleClick(item, { value: key, disabled })
                    }, [
                      item === "hours" ? (vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: 0 }, [
                        vue.createTextVNode(vue.toDisplayString(("0" + (_ctx.amPmMode ? key % 12 || 12 : key)).slice(-2)) + vue.toDisplayString(getAmPmFlag(key)), 1)
                      ], 64)) : (vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: 1 }, [
                        vue.createTextVNode(vue.toDisplayString(("0" + key).slice(-2)), 1)
                      ], 64))
                    ], 10, _hoisted_1$Y);
                  }), 128))
                ]),
                _: 2
              }, 1032, ["class", "view-class", "onMouseenter", "onMousemove"]);
            }), 128)) : vue.createCommentVNode("v-if", true),
            _ctx.arrowControl ? (vue.openBlock(true), vue.createElementBlock(vue.Fragment, { key: 1 }, vue.renderList(vue.unref(spinnerItems), (item) => {
              return vue.openBlock(), vue.createElementBlock("div", {
                key: item,
                class: vue.normalizeClass([vue.unref(ns).be("spinner", "wrapper"), vue.unref(ns).is("arrow")]),
                onMouseenter: ($event) => emitSelectRange(item)
              }, [
                vue.withDirectives((vue.openBlock(), vue.createBlock(vue.unref(ElIcon), {
                  class: vue.normalizeClass(["arrow-up", vue.unref(ns).be("spinner", "arrow")])
                }, {
                  default: vue.withCtx(() => [
                    vue.createVNode(vue.unref(arrow_up_default))
                  ]),
                  _: 1
                }, 8, ["class"])), [
                  [vue.unref(vRepeatClick), onDecrement]
                ]),
                vue.withDirectives((vue.openBlock(), vue.createBlock(vue.unref(ElIcon), {
                  class: vue.normalizeClass(["arrow-down", vue.unref(ns).be("spinner", "arrow")])
                }, {
                  default: vue.withCtx(() => [
                    vue.createVNode(vue.unref(arrow_down_default))
                  ]),
                  _: 1
                }, 8, ["class"])), [
                  [vue.unref(vRepeatClick), onIncrement]
                ]),
                vue.createElementVNode("ul", {
                  class: vue.normalizeClass(vue.unref(ns).be("spinner", "list"))
                }, [
                  (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(vue.unref(arrowControlTimeList)[item], (time, key) => {
                    return vue.openBlock(), vue.createElementBlock("li", {
                      key,
                      class: vue.normalizeClass([
                        vue.unref(ns).be("spinner", "item"),
                        vue.unref(ns).is("active", time === vue.unref(timePartials)[item]),
                        vue.unref(ns).is("disabled", vue.unref(timeList)[item][time])
                      ])
                    }, [
                      typeof time === "number" ? (vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: 0 }, [
                        item === "hours" ? (vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: 0 }, [
                          vue.createTextVNode(vue.toDisplayString(("0" + (_ctx.amPmMode ? time % 12 || 12 : time)).slice(-2)) + vue.toDisplayString(getAmPmFlag(time)), 1)
                        ], 64)) : (vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: 1 }, [
                          vue.createTextVNode(vue.toDisplayString(("0" + time).slice(-2)), 1)
                        ], 64))
                      ], 64)) : vue.createCommentVNode("v-if", true)
                    ], 2);
                  }), 128))
                ], 2)
              ], 42, _hoisted_2$C);
            }), 128)) : vue.createCommentVNode("v-if", true)
          ], 2);
        };
      }
    });
    var TimeSpinner = /* @__PURE__ */ _export_sfc(_sfc_main$1T, [["__file", "basic-time-spinner.vue"]]);
  
    const _sfc_main$1S = /* @__PURE__ */ vue.defineComponent({
      __name: "panel-time-pick",
      props: panelTimePickerProps,
      emits: ["pick", "select-range", "set-picker-option"],
      setup(__props, { emit }) {
        const props = __props;
        const pickerBase = vue.inject("EP_PICKER_BASE");
        const {
          arrowControl,
          disabledHours,
          disabledMinutes,
          disabledSeconds,
          defaultValue
        } = pickerBase.props;
        const { getAvailableHours, getAvailableMinutes, getAvailableSeconds } = buildAvailableTimeSlotGetter(disabledHours, disabledMinutes, disabledSeconds);
        const ns = useNamespace("time");
        const { t, lang } = useLocale();
        const selectionRange = vue.ref([0, 2]);
        const oldValue = useOldValue(props);
        const transitionName = vue.computed(() => {
          return isUndefined(props.actualVisible) ? `${ns.namespace.value}-zoom-in-top` : "";
        });
        const showSeconds = vue.computed(() => {
          return props.format.includes("ss");
        });
        const amPmMode = vue.computed(() => {
          if (props.format.includes("A"))
            return "A";
          if (props.format.includes("a"))
            return "a";
          return "";
        });
        const isValidValue = (_date) => {
          const parsedDate = dayjs(_date).locale(lang.value);
          const result = getRangeAvailableTime(parsedDate);
          return parsedDate.isSame(result);
        };
        const handleCancel = () => {
          emit("pick", oldValue.value, false);
        };
        const handleConfirm = (visible = false, first = false) => {
          if (first)
            return;
          emit("pick", props.parsedValue, visible);
        };
        const handleChange = (_date) => {
          if (!props.visible) {
            return;
          }
          const result = getRangeAvailableTime(_date).millisecond(0);
          emit("pick", result, true);
        };
        const setSelectionRange = (start, end) => {
          emit("select-range", start, end);
          selectionRange.value = [start, end];
        };
        const changeSelectionRange = (step) => {
          const list = [0, 3].concat(showSeconds.value ? [6] : []);
          const mapping = ["hours", "minutes"].concat(showSeconds.value ? ["seconds"] : []);
          const index = list.indexOf(selectionRange.value[0]);
          const next = (index + step + list.length) % list.length;
          timePickerOptions["start_emitSelectRange"](mapping[next]);
        };
        const handleKeydown = (event) => {
          const code = event.code;
          const { left, right, up, down } = EVENT_CODE;
          if ([left, right].includes(code)) {
            const step = code === left ? -1 : 1;
            changeSelectionRange(step);
            event.preventDefault();
            return;
          }
          if ([up, down].includes(code)) {
            const step = code === up ? -1 : 1;
            timePickerOptions["start_scrollDown"](step);
            event.preventDefault();
            return;
          }
        };
        const { timePickerOptions, onSetOption, getAvailableTime } = useTimePanel({
          getAvailableHours,
          getAvailableMinutes,
          getAvailableSeconds
        });
        const getRangeAvailableTime = (date) => {
          return getAvailableTime(date, props.datetimeRole || "", true);
        };
        const parseUserInput = (value) => {
          if (!value)
            return null;
          return dayjs(value, props.format).locale(lang.value);
        };
        const formatToString = (value) => {
          if (!value)
            return null;
          return value.format(props.format);
        };
        const getDefaultValue = () => {
          return dayjs(defaultValue).locale(lang.value);
        };
        emit("set-picker-option", ["isValidValue", isValidValue]);
        emit("set-picker-option", ["formatToString", formatToString]);
        emit("set-picker-option", ["parseUserInput", parseUserInput]);
        emit("set-picker-option", ["handleKeydownInput", handleKeydown]);
        emit("set-picker-option", ["getRangeAvailableTime", getRangeAvailableTime]);
        emit("set-picker-option", ["getDefaultValue", getDefaultValue]);
        return (_ctx, _cache) => {
          return vue.openBlock(), vue.createBlock(vue.Transition, { name: vue.unref(transitionName) }, {
            default: vue.withCtx(() => [
              _ctx.actualVisible || _ctx.visible ? (vue.openBlock(), vue.createElementBlock("div", {
                key: 0,
                class: vue.normalizeClass(vue.unref(ns).b("panel"))
              }, [
                vue.createElementVNode("div", {
                  class: vue.normalizeClass([vue.unref(ns).be("panel", "content"), { "has-seconds": vue.unref(showSeconds) }])
                }, [
                  vue.createVNode(TimeSpinner, {
                    ref: "spinner",
                    role: _ctx.datetimeRole || "start",
                    "arrow-control": vue.unref(arrowControl),
                    "show-seconds": vue.unref(showSeconds),
                    "am-pm-mode": vue.unref(amPmMode),
                    "spinner-date": _ctx.parsedValue,
                    "disabled-hours": vue.unref(disabledHours),
                    "disabled-minutes": vue.unref(disabledMinutes),
                    "disabled-seconds": vue.unref(disabledSeconds),
                    onChange: handleChange,
                    onSetOption: vue.unref(onSetOption),
                    onSelectRange: setSelectionRange
                  }, null, 8, ["role", "arrow-control", "show-seconds", "am-pm-mode", "spinner-date", "disabled-hours", "disabled-minutes", "disabled-seconds", "onSetOption"])
                ], 2),
                vue.createElementVNode("div", {
                  class: vue.normalizeClass(vue.unref(ns).be("panel", "footer"))
                }, [
                  vue.createElementVNode("button", {
                    type: "button",
                    class: vue.normalizeClass([vue.unref(ns).be("panel", "btn"), "cancel"]),
                    onClick: handleCancel
                  }, vue.toDisplayString(vue.unref(t)("el.datepicker.cancel")), 3),
                  vue.createElementVNode("button", {
                    type: "button",
                    class: vue.normalizeClass([vue.unref(ns).be("panel", "btn"), "confirm"]),
                    onClick: _cache[0] || (_cache[0] = ($event) => handleConfirm())
                  }, vue.toDisplayString(vue.unref(t)("el.datepicker.confirm")), 3)
                ], 2)
              ], 2)) : vue.createCommentVNode("v-if", true)
            ]),
            _: 1
          }, 8, ["name"]);
        };
      }
    });
    var TimePickPanel = /* @__PURE__ */ _export_sfc(_sfc_main$1S, [["__file", "panel-time-pick.vue"]]);
  
    const panelTimeRangeProps = buildProps({
      ...timePanelSharedProps,
      parsedValue: {
        type: definePropType(Array)
      }
    });
  
    const _hoisted_1$X = ["disabled"];
    const _sfc_main$1R = /* @__PURE__ */ vue.defineComponent({
      __name: "panel-time-range",
      props: panelTimeRangeProps,
      emits: ["pick", "select-range", "set-picker-option"],
      setup(__props, { emit }) {
        const props = __props;
        const makeSelectRange = (start, end) => {
          const result = [];
          for (let i = start; i <= end; i++) {
            result.push(i);
          }
          return result;
        };
        const { t, lang } = useLocale();
        const nsTime = useNamespace("time");
        const nsPicker = useNamespace("picker");
        const pickerBase = vue.inject("EP_PICKER_BASE");
        const {
          arrowControl,
          disabledHours,
          disabledMinutes,
          disabledSeconds,
          defaultValue
        } = pickerBase.props;
        const startTime = vue.computed(() => props.parsedValue[0]);
        const endTime = vue.computed(() => props.parsedValue[1]);
        const oldValue = useOldValue(props);
        const handleCancel = () => {
          emit("pick", oldValue.value, false);
        };
        const showSeconds = vue.computed(() => {
          return props.format.includes("ss");
        });
        const amPmMode = vue.computed(() => {
          if (props.format.includes("A"))
            return "A";
          if (props.format.includes("a"))
            return "a";
          return "";
        });
        const handleConfirm = (visible = false) => {
          emit("pick", [startTime.value, endTime.value], visible);
        };
        const handleMinChange = (date) => {
          handleChange(date.millisecond(0), endTime.value);
        };
        const handleMaxChange = (date) => {
          handleChange(startTime.value, date.millisecond(0));
        };
        const isValidValue = (_date) => {
          const parsedDate = _date.map((_) => dayjs(_).locale(lang.value));
          const result = getRangeAvailableTime(parsedDate);
          return parsedDate[0].isSame(result[0]) && parsedDate[1].isSame(result[1]);
        };
        const handleChange = (start, end) => {
          emit("pick", [start, end], true);
        };
        const btnConfirmDisabled = vue.computed(() => {
          return startTime.value > endTime.value;
        });
        const selectionRange = vue.ref([0, 2]);
        const setMinSelectionRange = (start, end) => {
          emit("select-range", start, end, "min");
          selectionRange.value = [start, end];
        };
        const offset = vue.computed(() => showSeconds.value ? 11 : 8);
        const setMaxSelectionRange = (start, end) => {
          emit("select-range", start, end, "max");
          const _offset = vue.unref(offset);
          selectionRange.value = [start + _offset, end + _offset];
        };
        const changeSelectionRange = (step) => {
          const list = showSeconds.value ? [0, 3, 6, 11, 14, 17] : [0, 3, 8, 11];
          const mapping = ["hours", "minutes"].concat(showSeconds.value ? ["seconds"] : []);
          const index = list.indexOf(selectionRange.value[0]);
          const next = (index + step + list.length) % list.length;
          const half = list.length / 2;
          if (next < half) {
            timePickerOptions["start_emitSelectRange"](mapping[next]);
          } else {
            timePickerOptions["end_emitSelectRange"](mapping[next - half]);
          }
        };
        const handleKeydown = (event) => {
          const code = event.code;
          const { left, right, up, down } = EVENT_CODE;
          if ([left, right].includes(code)) {
            const step = code === left ? -1 : 1;
            changeSelectionRange(step);
            event.preventDefault();
            return;
          }
          if ([up, down].includes(code)) {
            const step = code === up ? -1 : 1;
            const role = selectionRange.value[0] < offset.value ? "start" : "end";
            timePickerOptions[`${role}_scrollDown`](step);
            event.preventDefault();
            return;
          }
        };
        const disabledHours_ = (role, compare) => {
          const defaultDisable = disabledHours ? disabledHours(role) : [];
          const isStart = role === "start";
          const compareDate = compare || (isStart ? endTime.value : startTime.value);
          const compareHour = compareDate.hour();
          const nextDisable = isStart ? makeSelectRange(compareHour + 1, 23) : makeSelectRange(0, compareHour - 1);
          return union(defaultDisable, nextDisable);
        };
        const disabledMinutes_ = (hour, role, compare) => {
          const defaultDisable = disabledMinutes ? disabledMinutes(hour, role) : [];
          const isStart = role === "start";
          const compareDate = compare || (isStart ? endTime.value : startTime.value);
          const compareHour = compareDate.hour();
          if (hour !== compareHour) {
            return defaultDisable;
          }
          const compareMinute = compareDate.minute();
          const nextDisable = isStart ? makeSelectRange(compareMinute + 1, 59) : makeSelectRange(0, compareMinute - 1);
          return union(defaultDisable, nextDisable);
        };
        const disabledSeconds_ = (hour, minute, role, compare) => {
          const defaultDisable = disabledSeconds ? disabledSeconds(hour, minute, role) : [];
          const isStart = role === "start";
          const compareDate = compare || (isStart ? endTime.value : startTime.value);
          const compareHour = compareDate.hour();
          const compareMinute = compareDate.minute();
          if (hour !== compareHour || minute !== compareMinute) {
            return defaultDisable;
          }
          const compareSecond = compareDate.second();
          const nextDisable = isStart ? makeSelectRange(compareSecond + 1, 59) : makeSelectRange(0, compareSecond - 1);
          return union(defaultDisable, nextDisable);
        };
        const getRangeAvailableTime = ([start, end]) => {
          return [
            getAvailableTime(start, "start", true, end),
            getAvailableTime(end, "end", false, start)
          ];
        };
        const { getAvailableHours, getAvailableMinutes, getAvailableSeconds } = buildAvailableTimeSlotGetter(disabledHours_, disabledMinutes_, disabledSeconds_);
        const {
          timePickerOptions,
          getAvailableTime,
          onSetOption
        } = useTimePanel({
          getAvailableHours,
          getAvailableMinutes,
          getAvailableSeconds
        });
        const parseUserInput = (days) => {
          if (!days)
            return null;
          if (isArray(days)) {
            return days.map((d) => dayjs(d, props.format).locale(lang.value));
          }
          return dayjs(days, props.format).locale(lang.value);
        };
        const formatToString = (days) => {
          if (!days)
            return null;
          if (isArray(days)) {
            return days.map((d) => d.format(props.format));
          }
          return days.format(props.format);
        };
        const getDefaultValue = () => {
          if (isArray(defaultValue)) {
            return defaultValue.map((d) => dayjs(d).locale(lang.value));
          }
          const defaultDay = dayjs(defaultValue).locale(lang.value);
          return [defaultDay, defaultDay.add(60, "m")];
        };
        emit("set-picker-option", ["formatToString", formatToString]);
        emit("set-picker-option", ["parseUserInput", parseUserInput]);
        emit("set-picker-option", ["isValidValue", isValidValue]);
        emit("set-picker-option", ["handleKeydownInput", handleKeydown]);
        emit("set-picker-option", ["getDefaultValue", getDefaultValue]);
        emit("set-picker-option", ["getRangeAvailableTime", getRangeAvailableTime]);
        return (_ctx, _cache) => {
          return _ctx.actualVisible ? (vue.openBlock(), vue.createElementBlock("div", {
            key: 0,
            class: vue.normalizeClass([vue.unref(nsTime).b("range-picker"), vue.unref(nsPicker).b("panel")])
          }, [
            vue.createElementVNode("div", {
              class: vue.normalizeClass(vue.unref(nsTime).be("range-picker", "content"))
            }, [
              vue.createElementVNode("div", {
                class: vue.normalizeClass(vue.unref(nsTime).be("range-picker", "cell"))
              }, [
                vue.createElementVNode("div", {
                  class: vue.normalizeClass(vue.unref(nsTime).be("range-picker", "header"))
                }, vue.toDisplayString(vue.unref(t)("el.datepicker.startTime")), 3),
                vue.createElementVNode("div", {
                  class: vue.normalizeClass([
                    vue.unref(nsTime).be("range-picker", "body"),
                    vue.unref(nsTime).be("panel", "content"),
                    vue.unref(nsTime).is("arrow", vue.unref(arrowControl)),
                    { "has-seconds": vue.unref(showSeconds) }
                  ])
                }, [
                  vue.createVNode(TimeSpinner, {
                    ref: "minSpinner",
                    role: "start",
                    "show-seconds": vue.unref(showSeconds),
                    "am-pm-mode": vue.unref(amPmMode),
                    "arrow-control": vue.unref(arrowControl),
                    "spinner-date": vue.unref(startTime),
                    "disabled-hours": disabledHours_,
                    "disabled-minutes": disabledMinutes_,
                    "disabled-seconds": disabledSeconds_,
                    onChange: handleMinChange,
                    onSetOption: vue.unref(onSetOption),
                    onSelectRange: setMinSelectionRange
                  }, null, 8, ["show-seconds", "am-pm-mode", "arrow-control", "spinner-date", "onSetOption"])
                ], 2)
              ], 2),
              vue.createElementVNode("div", {
                class: vue.normalizeClass(vue.unref(nsTime).be("range-picker", "cell"))
              }, [
                vue.createElementVNode("div", {
                  class: vue.normalizeClass(vue.unref(nsTime).be("range-picker", "header"))
                }, vue.toDisplayString(vue.unref(t)("el.datepicker.endTime")), 3),
                vue.createElementVNode("div", {
                  class: vue.normalizeClass([
                    vue.unref(nsTime).be("range-picker", "body"),
                    vue.unref(nsTime).be("panel", "content"),
                    vue.unref(nsTime).is("arrow", vue.unref(arrowControl)),
                    { "has-seconds": vue.unref(showSeconds) }
                  ])
                }, [
                  vue.createVNode(TimeSpinner, {
                    ref: "maxSpinner",
                    role: "end",
                    "show-seconds": vue.unref(showSeconds),
                    "am-pm-mode": vue.unref(amPmMode),
                    "arrow-control": vue.unref(arrowControl),
                    "spinner-date": vue.unref(endTime),
                    "disabled-hours": disabledHours_,
                    "disabled-minutes": disabledMinutes_,
                    "disabled-seconds": disabledSeconds_,
                    onChange: handleMaxChange,
                    onSetOption: vue.unref(onSetOption),
                    onSelectRange: setMaxSelectionRange
                  }, null, 8, ["show-seconds", "am-pm-mode", "arrow-control", "spinner-date", "onSetOption"])
                ], 2)
              ], 2)
            ], 2),
            vue.createElementVNode("div", {
              class: vue.normalizeClass(vue.unref(nsTime).be("panel", "footer"))
            }, [
              vue.createElementVNode("button", {
                type: "button",
                class: vue.normalizeClass([vue.unref(nsTime).be("panel", "btn"), "cancel"]),
                onClick: _cache[0] || (_cache[0] = ($event) => handleCancel())
              }, vue.toDisplayString(vue.unref(t)("el.datepicker.cancel")), 3),
              vue.createElementVNode("button", {
                type: "button",
                class: vue.normalizeClass([vue.unref(nsTime).be("panel", "btn"), "confirm"]),
                disabled: vue.unref(btnConfirmDisabled),
                onClick: _cache[1] || (_cache[1] = ($event) => handleConfirm())
              }, vue.toDisplayString(vue.unref(t)("el.datepicker.confirm")), 11, _hoisted_1$X)
            ], 2)
          ], 2)) : vue.createCommentVNode("v-if", true);
        };
      }
    });
    var TimeRangePanel = /* @__PURE__ */ _export_sfc(_sfc_main$1R, [["__file", "panel-time-range.vue"]]);
  
    dayjs.extend(customParseFormat);
    var TimePicker = vue.defineComponent({
      name: "ElTimePicker",
      install: null,
      props: {
        ...timePickerDefaultProps,
        isRange: {
          type: Boolean,
          default: false
        }
      },
      emits: ["update:modelValue"],
      setup(props, ctx) {
        const commonPicker = vue.ref();
        const [type, Panel] = props.isRange ? ["timerange", TimeRangePanel] : ["time", TimePickPanel];
        const modelUpdater = (value) => ctx.emit("update:modelValue", value);
        vue.provide("ElPopperOptions", props.popperOptions);
        ctx.expose({
          focus: (e) => {
            var _a;
            (_a = commonPicker.value) == null ? void 0 : _a.handleFocusInput(e);
          },
          blur: (e) => {
            var _a;
            (_a = commonPicker.value) == null ? void 0 : _a.handleBlurInput(e);
          },
          handleOpen: () => {
            var _a;
            (_a = commonPicker.value) == null ? void 0 : _a.handleOpen();
          },
          handleClose: () => {
            var _a;
            (_a = commonPicker.value) == null ? void 0 : _a.handleClose();
          }
        });
        return () => {
          var _a;
          const format = (_a = props.format) != null ? _a : DEFAULT_FORMATS_TIME;
          return vue.createVNode(CommonPicker, vue.mergeProps(props, {
            "ref": commonPicker,
            "type": type,
            "format": format,
            "onUpdate:modelValue": modelUpdater
          }), {
            default: (props2) => vue.createVNode(Panel, props2, null)
          });
        };
      }
    });
  
    const _TimePicker = TimePicker;
    _TimePicker.install = (app) => {
      app.component(_TimePicker.name, _TimePicker);
    };
    const ElTimePicker = _TimePicker;
  
    const getPrevMonthLastDays = (date, count) => {
      const lastDay = date.subtract(1, "month").endOf("month").date();
      return rangeArr(count).map((_, index) => lastDay - (count - index - 1));
    };
    const getMonthDays = (date) => {
      const days = date.daysInMonth();
      return rangeArr(days).map((_, index) => index + 1);
    };
    const toNestedArr = (days) => rangeArr(days.length / 7).map((index) => {
      const start = index * 7;
      return days.slice(start, start + 7);
    });
    const dateTableProps = buildProps({
      selectedDay: {
        type: definePropType(Object)
      },
      range: {
        type: definePropType(Array)
      },
      date: {
        type: definePropType(Object),
        required: true
      },
      hideHeader: {
        type: Boolean
      }
    });
    const dateTableEmits = {
      pick: (value) => isObject$1(value)
    };
  
    var localeData$1 = {exports: {}};
  
    (function(module, exports) {
      !function(n, e) {
        module.exports = e() ;
      }(commonjsGlobal, function() {
        return function(n, e, t) {
          var r = e.prototype, o = function(n2) {
            return n2 && (n2.indexOf ? n2 : n2.s);
          }, u = function(n2, e2, t2, r2, u2) {
            var i2 = n2.name ? n2 : n2.$locale(), a2 = o(i2[e2]), s2 = o(i2[t2]), f = a2 || s2.map(function(n3) {
              return n3.slice(0, r2);
            });
            if (!u2)
              return f;
            var d = i2.weekStart;
            return f.map(function(n3, e3) {
              return f[(e3 + (d || 0)) % 7];
            });
          }, i = function() {
            return t.Ls[t.locale()];
          }, a = function(n2, e2) {
            return n2.formats[e2] || function(n3) {
              return n3.replace(/(\[[^\]]+])|(MMMM|MM|DD|dddd)/g, function(n4, e3, t2) {
                return e3 || t2.slice(1);
              });
            }(n2.formats[e2.toUpperCase()]);
          }, s = function() {
            var n2 = this;
            return { months: function(e2) {
              return e2 ? e2.format("MMMM") : u(n2, "months");
            }, monthsShort: function(e2) {
              return e2 ? e2.format("MMM") : u(n2, "monthsShort", "months", 3);
            }, firstDayOfWeek: function() {
              return n2.$locale().weekStart || 0;
            }, weekdays: function(e2) {
              return e2 ? e2.format("dddd") : u(n2, "weekdays");
            }, weekdaysMin: function(e2) {
              return e2 ? e2.format("dd") : u(n2, "weekdaysMin", "weekdays", 2);
            }, weekdaysShort: function(e2) {
              return e2 ? e2.format("ddd") : u(n2, "weekdaysShort", "weekdays", 3);
            }, longDateFormat: function(e2) {
              return a(n2.$locale(), e2);
            }, meridiem: this.$locale().meridiem, ordinal: this.$locale().ordinal };
          };
          r.localeData = function() {
            return s.bind(this)();
          }, t.localeData = function() {
            var n2 = i();
            return { firstDayOfWeek: function() {
              return n2.weekStart || 0;
            }, weekdays: function() {
              return t.weekdays();
            }, weekdaysShort: function() {
              return t.weekdaysShort();
            }, weekdaysMin: function() {
              return t.weekdaysMin();
            }, months: function() {
              return t.months();
            }, monthsShort: function() {
              return t.monthsShort();
            }, longDateFormat: function(e2) {
              return a(n2, e2);
            }, meridiem: n2.meridiem, ordinal: n2.ordinal };
          }, t.months = function() {
            return u(i(), "months");
          }, t.monthsShort = function() {
            return u(i(), "monthsShort", "months", 3);
          }, t.weekdays = function(n2) {
            return u(i(), "weekdays", null, null, n2);
          }, t.weekdaysShort = function(n2) {
            return u(i(), "weekdaysShort", "weekdays", 3, n2);
          }, t.weekdaysMin = function(n2) {
            return u(i(), "weekdaysMin", "weekdays", 2, n2);
          };
        };
      });
    })(localeData$1);
    var localeData = localeData$1.exports;
  
    const useDateTable = (props, emit) => {
      dayjs.extend(localeData);
      const firstDayOfWeek = dayjs.localeData().firstDayOfWeek();
      const { t, lang } = useLocale();
      const now = dayjs().locale(lang.value);
      const isInRange = vue.computed(() => !!props.range && !!props.range.length);
      const rows = vue.computed(() => {
        let days = [];
        if (isInRange.value) {
          const [start, end] = props.range;
          const currentMonthRange = rangeArr(end.date() - start.date() + 1).map((index) => ({
            text: start.date() + index,
            type: "current"
          }));
          let remaining = currentMonthRange.length % 7;
          remaining = remaining === 0 ? 0 : 7 - remaining;
          const nextMonthRange = rangeArr(remaining).map((_, index) => ({
            text: index + 1,
            type: "next"
          }));
          days = currentMonthRange.concat(nextMonthRange);
        } else {
          const firstDay = props.date.startOf("month").day();
          const prevMonthDays = getPrevMonthLastDays(props.date, (firstDay - firstDayOfWeek + 7) % 7).map((day) => ({
            text: day,
            type: "prev"
          }));
          const currentMonthDays = getMonthDays(props.date).map((day) => ({
            text: day,
            type: "current"
          }));
          days = [...prevMonthDays, ...currentMonthDays];
          const remaining = 7 - (days.length % 7 || 7);
          const nextMonthDays = rangeArr(remaining).map((_, index) => ({
            text: index + 1,
            type: "next"
          }));
          days = days.concat(nextMonthDays);
        }
        return toNestedArr(days);
      });
      const weekDays = vue.computed(() => {
        const start = firstDayOfWeek;
        if (start === 0) {
          return WEEK_DAYS.map((_) => t(`el.datepicker.weeks.${_}`));
        } else {
          return WEEK_DAYS.slice(start).concat(WEEK_DAYS.slice(0, start)).map((_) => t(`el.datepicker.weeks.${_}`));
        }
      });
      const getFormattedDate = (day, type) => {
        switch (type) {
          case "prev":
            return props.date.startOf("month").subtract(1, "month").date(day);
          case "next":
            return props.date.startOf("month").add(1, "month").date(day);
          case "current":
            return props.date.date(day);
        }
      };
      const handlePickDay = ({ text, type }) => {
        const date = getFormattedDate(text, type);
        emit("pick", date);
      };
      const getSlotData = ({ text, type }) => {
        const day = getFormattedDate(text, type);
        return {
          isSelected: day.isSame(props.selectedDay),
          type: `${type}-month`,
          day: day.format("YYYY-MM-DD"),
          date: day.toDate()
        };
      };
      return {
        now,
        isInRange,
        rows,
        weekDays,
        getFormattedDate,
        handlePickDay,
        getSlotData
      };
    };
  
    const _hoisted_1$W = { key: 0 };
    const _hoisted_2$B = ["onClick"];
    const __default__$1b = vue.defineComponent({
      name: "DateTable"
    });
    const _sfc_main$1Q = /* @__PURE__ */ vue.defineComponent({
      ...__default__$1b,
      props: dateTableProps,
      emits: dateTableEmits,
      setup(__props, { expose, emit }) {
        const props = __props;
        const {
          isInRange,
          now,
          rows,
          weekDays,
          getFormattedDate,
          handlePickDay,
          getSlotData
        } = useDateTable(props, emit);
        const nsTable = useNamespace("calendar-table");
        const nsDay = useNamespace("calendar-day");
        const getCellClass = ({ text, type }) => {
          const classes = [type];
          if (type === "current") {
            const date = getFormattedDate(text, type);
            if (date.isSame(props.selectedDay, "day")) {
              classes.push(nsDay.is("selected"));
            }
            if (date.isSame(now, "day")) {
              classes.push(nsDay.is("today"));
            }
          }
          return classes;
        };
        expose({
          getFormattedDate
        });
        return (_ctx, _cache) => {
          return vue.openBlock(), vue.createElementBlock("table", {
            class: vue.normalizeClass([vue.unref(nsTable).b(), vue.unref(nsTable).is("range", vue.unref(isInRange))]),
            cellspacing: "0",
            cellpadding: "0"
          }, [
            !_ctx.hideHeader ? (vue.openBlock(), vue.createElementBlock("thead", _hoisted_1$W, [
              (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(vue.unref(weekDays), (day) => {
                return vue.openBlock(), vue.createElementBlock("th", { key: day }, vue.toDisplayString(day), 1);
              }), 128))
            ])) : vue.createCommentVNode("v-if", true),
            vue.createElementVNode("tbody", null, [
              (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(vue.unref(rows), (row, index) => {
                return vue.openBlock(), vue.createElementBlock("tr", {
                  key: index,
                  class: vue.normalizeClass({
                    [vue.unref(nsTable).e("row")]: true,
                    [vue.unref(nsTable).em("row", "hide-border")]: index === 0 && _ctx.hideHeader
                  })
                }, [
                  (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(row, (cell, key) => {
                    return vue.openBlock(), vue.createElementBlock("td", {
                      key,
                      class: vue.normalizeClass(getCellClass(cell)),
                      onClick: ($event) => vue.unref(handlePickDay)(cell)
                    }, [
                      vue.createElementVNode("div", {
                        class: vue.normalizeClass(vue.unref(nsDay).b())
                      }, [
                        vue.renderSlot(_ctx.$slots, "date-cell", {
                          data: vue.unref(getSlotData)(cell)
                        }, () => [
                          vue.createElementVNode("span", null, vue.toDisplayString(cell.text), 1)
                        ])
                      ], 2)
                    ], 10, _hoisted_2$B);
                  }), 128))
                ], 2);
              }), 128))
            ])
          ], 2);
        };
      }
    });
    var DateTable$1 = /* @__PURE__ */ _export_sfc(_sfc_main$1Q, [["__file", "date-table.vue"]]);
  
    const adjacentMonth = (start, end) => {
      const firstMonthLastDay = start.endOf("month");
      const lastMonthFirstDay = end.startOf("month");
      const isSameWeek = firstMonthLastDay.isSame(lastMonthFirstDay, "week");
      const lastMonthStartDay = isSameWeek ? lastMonthFirstDay.add(1, "week") : lastMonthFirstDay;
      return [
        [start, firstMonthLastDay],
        [lastMonthStartDay.startOf("week"), end]
      ];
    };
    const threeConsecutiveMonth = (start, end) => {
      const firstMonthLastDay = start.endOf("month");
      const secondMonthFirstDay = start.add(1, "month").startOf("month");
      const secondMonthStartDay = firstMonthLastDay.isSame(secondMonthFirstDay, "week") ? secondMonthFirstDay.add(1, "week") : secondMonthFirstDay;
      const secondMonthLastDay = secondMonthStartDay.endOf("month");
      const lastMonthFirstDay = end.startOf("month");
      const lastMonthStartDay = secondMonthLastDay.isSame(lastMonthFirstDay, "week") ? lastMonthFirstDay.add(1, "week") : lastMonthFirstDay;
      return [
        [start, firstMonthLastDay],
        [secondMonthStartDay.startOf("week"), secondMonthLastDay],
        [lastMonthStartDay.startOf("week"), end]
      ];
    };
    const useCalendar = (props, emit, componentName) => {
      const slots = vue.useSlots();
      const { lang } = useLocale();
      const selectedDay = vue.ref();
      const now = dayjs().locale(lang.value);
      const realSelectedDay = vue.computed({
        get() {
          if (!props.modelValue)
            return selectedDay.value;
          return date.value;
        },
        set(val) {
          if (!val)
            return;
          selectedDay.value = val;
          const result = val.toDate();
          emit(INPUT_EVENT, result);
          emit(UPDATE_MODEL_EVENT, result);
        }
      });
      const validatedRange = vue.computed(() => {
        if (!props.range)
          return [];
        const rangeArrDayjs = props.range.map((_) => dayjs(_).locale(lang.value));
        const [startDayjs, endDayjs] = rangeArrDayjs;
        if (startDayjs.isAfter(endDayjs)) {
          return [];
        }
        if (startDayjs.isSame(endDayjs, "month")) {
          return calculateValidatedDateRange(startDayjs, endDayjs);
        } else {
          if (startDayjs.add(1, "month").month() !== endDayjs.month()) {
            return [];
          }
          return calculateValidatedDateRange(startDayjs, endDayjs);
        }
      });
      const date = vue.computed(() => {
        if (!props.modelValue) {
          return realSelectedDay.value || (validatedRange.value.length ? validatedRange.value[0][0] : now);
        } else {
          return dayjs(props.modelValue).locale(lang.value);
        }
      });
      const prevMonthDayjs = vue.computed(() => date.value.subtract(1, "month").date(1));
      const nextMonthDayjs = vue.computed(() => date.value.add(1, "month").date(1));
      const prevYearDayjs = vue.computed(() => date.value.subtract(1, "year").date(1));
      const nextYearDayjs = vue.computed(() => date.value.add(1, "year").date(1));
      const calculateValidatedDateRange = (startDayjs, endDayjs) => {
        const firstDay = startDayjs.startOf("week");
        const lastDay = endDayjs.endOf("week");
        const firstMonth = firstDay.get("month");
        const lastMonth = lastDay.get("month");
        if (firstMonth === lastMonth) {
          return [[firstDay, lastDay]];
        } else if ((firstMonth + 1) % 12 === lastMonth) {
          return adjacentMonth(firstDay, lastDay);
        } else if (firstMonth + 2 === lastMonth || (firstMonth + 1) % 11 === lastMonth) {
          return threeConsecutiveMonth(firstDay, lastDay);
        } else {
          return [];
        }
      };
      const pickDay = (day) => {
        realSelectedDay.value = day;
      };
      const selectDate = (type) => {
        const dateMap = {
          "prev-month": prevMonthDayjs.value,
          "next-month": nextMonthDayjs.value,
          "prev-year": prevYearDayjs.value,
          "next-year": nextYearDayjs.value,
          today: now
        };
        const day = dateMap[type];
        if (!day.isSame(date.value, "day")) {
          pickDay(day);
        }
      };
      useDeprecated({
        from: '"dateCell"',
        replacement: '"date-cell"',
        scope: "ElCalendar",
        version: "2.3.0",
        ref: "https://element-plus.org/en-US/component/calendar.html#slots",
        type: "Slot"
      }, vue.computed(() => !!slots.dateCell));
      return {
        calculateValidatedDateRange,
        date,
        realSelectedDay,
        pickDay,
        selectDate,
        validatedRange
      };
    };
  
    const isValidRange$1 = (range) => isArray(range) && range.length === 2 && range.every((item) => isDate(item));
    const calendarProps = buildProps({
      modelValue: {
        type: Date
      },
      range: {
        type: definePropType(Array),
        validator: isValidRange$1
      }
    });
    const calendarEmits = {
      [UPDATE_MODEL_EVENT]: (value) => isDate(value),
      [INPUT_EVENT]: (value) => isDate(value)
    };
  
    const COMPONENT_NAME$h = "ElCalendar";
    const __default__$1a = vue.defineComponent({
      name: COMPONENT_NAME$h
    });
    const _sfc_main$1P = /* @__PURE__ */ vue.defineComponent({
      ...__default__$1a,
      props: calendarProps,
      emits: calendarEmits,
      setup(__props, { expose, emit }) {
        const props = __props;
        const ns = useNamespace("calendar");
        const {
          calculateValidatedDateRange,
          date,
          pickDay,
          realSelectedDay,
          selectDate,
          validatedRange
        } = useCalendar(props, emit);
        const { t } = useLocale();
        const i18nDate = vue.computed(() => {
          const pickedMonth = `el.datepicker.month${date.value.format("M")}`;
          return `${date.value.year()} ${t("el.datepicker.year")} ${t(pickedMonth)}`;
        });
        expose({
          selectedDay: realSelectedDay,
          pickDay,
          selectDate,
          calculateValidatedDateRange
        });
        return (_ctx, _cache) => {
          return vue.openBlock(), vue.createElementBlock("div", {
            class: vue.normalizeClass(vue.unref(ns).b())
          }, [
            vue.createElementVNode("div", {
              class: vue.normalizeClass(vue.unref(ns).e("header"))
            }, [
              vue.renderSlot(_ctx.$slots, "header", { date: vue.unref(i18nDate) }, () => [
                vue.createElementVNode("div", {
                  class: vue.normalizeClass(vue.unref(ns).e("title"))
                }, vue.toDisplayString(vue.unref(i18nDate)), 3),
                vue.unref(validatedRange).length === 0 ? (vue.openBlock(), vue.createElementBlock("div", {
                  key: 0,
                  class: vue.normalizeClass(vue.unref(ns).e("button-group"))
                }, [
                  vue.createVNode(vue.unref(ElButtonGroup$1), null, {
                    default: vue.withCtx(() => [
                      vue.createVNode(vue.unref(ElButton), {
                        size: "small",
                        onClick: _cache[0] || (_cache[0] = ($event) => vue.unref(selectDate)("prev-month"))
                      }, {
                        default: vue.withCtx(() => [
                          vue.createTextVNode(vue.toDisplayString(vue.unref(t)("el.datepicker.prevMonth")), 1)
                        ]),
                        _: 1
                      }),
                      vue.createVNode(vue.unref(ElButton), {
                        size: "small",
                        onClick: _cache[1] || (_cache[1] = ($event) => vue.unref(selectDate)("today"))
                      }, {
                        default: vue.withCtx(() => [
                          vue.createTextVNode(vue.toDisplayString(vue.unref(t)("el.datepicker.today")), 1)
                        ]),
                        _: 1
                      }),
                      vue.createVNode(vue.unref(ElButton), {
                        size: "small",
                        onClick: _cache[2] || (_cache[2] = ($event) => vue.unref(selectDate)("next-month"))
                      }, {
                        default: vue.withCtx(() => [
                          vue.createTextVNode(vue.toDisplayString(vue.unref(t)("el.datepicker.nextMonth")), 1)
                        ]),
                        _: 1
                      })
                    ]),
                    _: 1
                  })
                ], 2)) : vue.createCommentVNode("v-if", true)
              ])
            ], 2),
            vue.unref(validatedRange).length === 0 ? (vue.openBlock(), vue.createElementBlock("div", {
              key: 0,
              class: vue.normalizeClass(vue.unref(ns).e("body"))
            }, [
              vue.createVNode(DateTable$1, {
                date: vue.unref(date),
                "selected-day": vue.unref(realSelectedDay),
                onPick: vue.unref(pickDay)
              }, vue.createSlots({ _: 2 }, [
                _ctx.$slots["date-cell"] || _ctx.$slots.dateCell ? {
                  name: "date-cell",
                  fn: vue.withCtx((data) => [
                    _ctx.$slots["date-cell"] ? vue.renderSlot(_ctx.$slots, "date-cell", vue.normalizeProps(vue.mergeProps({ key: 0 }, data))) : vue.renderSlot(_ctx.$slots, "dateCell", vue.normalizeProps(vue.mergeProps({ key: 1 }, data)))
                  ])
                } : void 0
              ]), 1032, ["date", "selected-day", "onPick"])
            ], 2)) : (vue.openBlock(), vue.createElementBlock("div", {
              key: 1,
              class: vue.normalizeClass(vue.unref(ns).e("body"))
            }, [
              (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(vue.unref(validatedRange), (range_, index) => {
                return vue.openBlock(), vue.createBlock(DateTable$1, {
                  key: index,
                  date: range_[0],
                  "selected-day": vue.unref(realSelectedDay),
                  range: range_,
                  "hide-header": index !== 0,
                  onPick: vue.unref(pickDay)
                }, vue.createSlots({ _: 2 }, [
                  _ctx.$slots["date-cell"] || _ctx.$slots.dateCell ? {
                    name: "date-cell",
                    fn: vue.withCtx((data) => [
                      _ctx.$slots["date-cell"] ? vue.renderSlot(_ctx.$slots, "date-cell", vue.normalizeProps(vue.mergeProps({ key: 0 }, data))) : vue.renderSlot(_ctx.$slots, "dateCell", vue.normalizeProps(vue.mergeProps({ key: 1 }, data)))
                    ])
                  } : void 0
                ]), 1032, ["date", "selected-day", "range", "hide-header", "onPick"]);
              }), 128))
            ], 2))
          ], 2);
        };
      }
    });
    var Calendar = /* @__PURE__ */ _export_sfc(_sfc_main$1P, [["__file", "calendar.vue"]]);
  
    const ElCalendar = withInstall(Calendar);
  
    const cardProps = buildProps({
      header: {
        type: String,
        default: ""
      },
      bodyStyle: {
        type: definePropType([String, Object, Array]),
        default: ""
      },
      shadow: {
        type: String,
        values: ["always", "hover", "never"],
        default: "always"
      }
    });
  
    const __default__$19 = vue.defineComponent({
      name: "ElCard"
    });
    const _sfc_main$1O = /* @__PURE__ */ vue.defineComponent({
      ...__default__$19,
      props: cardProps,
      setup(__props) {
        const ns = useNamespace("card");
        return (_ctx, _cache) => {
          return vue.openBlock(), vue.createElementBlock("div", {
            class: vue.normalizeClass([vue.unref(ns).b(), vue.unref(ns).is(`${_ctx.shadow}-shadow`)])
          }, [
            _ctx.$slots.header || _ctx.header ? (vue.openBlock(), vue.createElementBlock("div", {
              key: 0,
              class: vue.normalizeClass(vue.unref(ns).e("header"))
            }, [
              vue.renderSlot(_ctx.$slots, "header", {}, () => [
                vue.createTextVNode(vue.toDisplayString(_ctx.header), 1)
              ])
            ], 2)) : vue.createCommentVNode("v-if", true),
            vue.createElementVNode("div", {
              class: vue.normalizeClass(vue.unref(ns).e("body")),
              style: vue.normalizeStyle(_ctx.bodyStyle)
            }, [
              vue.renderSlot(_ctx.$slots, "default")
            ], 6)
          ], 2);
        };
      }
    });
    var Card = /* @__PURE__ */ _export_sfc(_sfc_main$1O, [["__file", "card.vue"]]);
  
    const ElCard = withInstall(Card);
  
    const carouselProps = buildProps({
      initialIndex: {
        type: Number,
        default: 0
      },
      height: {
        type: String,
        default: ""
      },
      trigger: {
        type: String,
        values: ["hover", "click"],
        default: "hover"
      },
      autoplay: {
        type: Boolean,
        default: true
      },
      interval: {
        type: Number,
        default: 3e3
      },
      indicatorPosition: {
        type: String,
        values: ["", "none", "outside"],
        default: ""
      },
      indicator: {
        type: Boolean,
        default: true
      },
      arrow: {
        type: String,
        values: ["always", "hover", "never"],
        default: "hover"
      },
      type: {
        type: String,
        values: ["", "card"],
        default: ""
      },
      loop: {
        type: Boolean,
        default: true
      },
      direction: {
        type: String,
        values: ["horizontal", "vertical"],
        default: "horizontal"
      },
      pauseOnHover: {
        type: Boolean,
        default: true
      }
    });
    const carouselEmits = {
      change: (current, prev) => [current, prev].every(isNumber)
    };
  
    const THROTTLE_TIME = 300;
    const useCarousel = (props, emit, componentName) => {
      const {
        children: items,
        addChild: addItem,
        removeChild: removeItem
      } = useOrderedChildren(vue.getCurrentInstance(), "ElCarouselItem");
      const activeIndex = vue.ref(-1);
      const timer = vue.ref(null);
      const hover = vue.ref(false);
      const root = vue.ref();
      const arrowDisplay = vue.computed(() => props.arrow !== "never" && !vue.unref(isVertical));
      const hasLabel = vue.computed(() => {
        return items.value.some((item) => item.props.label.toString().length > 0);
      });
      const isCardType = vue.computed(() => props.type === "card");
      const isVertical = vue.computed(() => props.direction === "vertical");
      const throttledArrowClick = throttle((index) => {
        setActiveItem(index);
      }, THROTTLE_TIME, { trailing: true });
      const throttledIndicatorHover = throttle((index) => {
        handleIndicatorHover(index);
      }, THROTTLE_TIME);
      function pauseTimer() {
        if (timer.value) {
          clearInterval(timer.value);
          timer.value = null;
        }
      }
      function startTimer() {
        if (props.interval <= 0 || !props.autoplay || timer.value)
          return;
        timer.value = setInterval(() => playSlides(), props.interval);
      }
      const playSlides = () => {
        if (activeIndex.value < items.value.length - 1) {
          activeIndex.value = activeIndex.value + 1;
        } else if (props.loop) {
          activeIndex.value = 0;
        }
      };
      function setActiveItem(index) {
        if (isString(index)) {
          const filteredItems = items.value.filter((item) => item.props.name === index);
          if (filteredItems.length > 0) {
            index = items.value.indexOf(filteredItems[0]);
          }
        }
        index = Number(index);
        if (Number.isNaN(index) || index !== Math.floor(index)) {
          return;
        }
        const itemCount = items.value.length;
        const oldIndex = activeIndex.value;
        if (index < 0) {
          activeIndex.value = props.loop ? itemCount - 1 : 0;
        } else if (index >= itemCount) {
          activeIndex.value = props.loop ? 0 : itemCount - 1;
        } else {
          activeIndex.value = index;
        }
        if (oldIndex === activeIndex.value) {
          resetItemPosition(oldIndex);
        }
        resetTimer();
      }
      function resetItemPosition(oldIndex) {
        items.value.forEach((item, index) => {
          item.translateItem(index, activeIndex.value, oldIndex);
        });
      }
      function itemInStage(item, index) {
        var _a, _b, _c, _d;
        const _items = vue.unref(items);
        const itemCount = _items.length;
        if (itemCount === 0 || !item.states.inStage)
          return false;
        const nextItemIndex = index + 1;
        const prevItemIndex = index - 1;
        const lastItemIndex = itemCount - 1;
        const isLastItemActive = _items[lastItemIndex].states.active;
        const isFirstItemActive = _items[0].states.active;
        const isNextItemActive = (_b = (_a = _items[nextItemIndex]) == null ? void 0 : _a.states) == null ? void 0 : _b.active;
        const isPrevItemActive = (_d = (_c = _items[prevItemIndex]) == null ? void 0 : _c.states) == null ? void 0 : _d.active;
        if (index === lastItemIndex && isFirstItemActive || isNextItemActive) {
          return "left";
        } else if (index === 0 && isLastItemActive || isPrevItemActive) {
          return "right";
        }
        return false;
      }
      function handleMouseEnter() {
        hover.value = true;
        if (props.pauseOnHover) {
          pauseTimer();
        }
      }
      function handleMouseLeave() {
        hover.value = false;
        startTimer();
      }
      function handleButtonEnter(arrow) {
        if (vue.unref(isVertical))
          return;
        items.value.forEach((item, index) => {
          if (arrow === itemInStage(item, index)) {
            item.states.hover = true;
          }
        });
      }
      function handleButtonLeave() {
        if (vue.unref(isVertical))
          return;
        items.value.forEach((item) => {
          item.states.hover = false;
        });
      }
      function handleIndicatorClick(index) {
        activeIndex.value = index;
      }
      function handleIndicatorHover(index) {
        if (props.trigger === "hover" && index !== activeIndex.value) {
          activeIndex.value = index;
        }
      }
      function prev() {
        setActiveItem(activeIndex.value - 1);
      }
      function next() {
        setActiveItem(activeIndex.value + 1);
      }
      function resetTimer() {
        pauseTimer();
        startTimer();
      }
      vue.watch(() => activeIndex.value, (current, prev2) => {
        resetItemPosition(prev2);
        if (prev2 > -1) {
          emit("change", current, prev2);
        }
      });
      vue.watch(() => props.autoplay, (autoplay) => {
        autoplay ? startTimer() : pauseTimer();
      });
      vue.watch(() => props.loop, () => {
        setActiveItem(activeIndex.value);
      });
      vue.watch(() => props.interval, () => {
        resetTimer();
      });
      vue.watch(() => items.value, () => {
        if (items.value.length > 0)
          setActiveItem(props.initialIndex);
      });
      const resizeObserver = vue.shallowRef();
      vue.onMounted(() => {
        resizeObserver.value = useResizeObserver(root.value, () => {
          resetItemPosition();
        });
        startTimer();
      });
      vue.onBeforeUnmount(() => {
        pauseTimer();
        if (root.value && resizeObserver.value)
          resizeObserver.value.stop();
      });
      vue.provide(carouselContextKey, {
        root,
        isCardType,
        isVertical,
        items,
        loop: props.loop,
        addItem,
        removeItem,
        setActiveItem
      });
      return {
        root,
        activeIndex,
        arrowDisplay,
        hasLabel,
        hover,
        isCardType,
        items,
        handleButtonEnter,
        handleButtonLeave,
        handleIndicatorClick,
        handleMouseEnter,
        handleMouseLeave,
        setActiveItem,
        prev,
        next,
        throttledArrowClick,
        throttledIndicatorHover
      };
    };
  
    const _hoisted_1$V = ["onMouseenter", "onClick"];
    const _hoisted_2$A = { key: 0 };
    const COMPONENT_NAME$g = "ElCarousel";
    const __default__$18 = vue.defineComponent({
      name: COMPONENT_NAME$g
    });
    const _sfc_main$1N = /* @__PURE__ */ vue.defineComponent({
      ...__default__$18,
      props: carouselProps,
      emits: carouselEmits,
      setup(__props, { expose, emit }) {
        const props = __props;
        const {
          root,
          activeIndex,
          arrowDisplay,
          hasLabel,
          hover,
          isCardType,
          items,
          handleButtonEnter,
          handleButtonLeave,
          handleIndicatorClick,
          handleMouseEnter,
          handleMouseLeave,
          setActiveItem,
          prev,
          next,
          throttledArrowClick,
          throttledIndicatorHover
        } = useCarousel(props, emit);
        const ns = useNamespace("carousel");
        const carouselClasses = vue.computed(() => {
          const classes = [ns.b(), ns.m(props.direction)];
          if (vue.unref(isCardType)) {
            classes.push(ns.m("card"));
          }
          return classes;
        });
        const indicatorsClasses = vue.computed(() => {
          const classes = [ns.e("indicators"), ns.em("indicators", props.direction)];
          if (vue.unref(hasLabel)) {
            classes.push(ns.em("indicators", "labels"));
          }
          if (props.indicatorPosition === "outside" || vue.unref(isCardType)) {
            classes.push(ns.em("indicators", "outside"));
          }
          return classes;
        });
        expose({
          setActiveItem,
          prev,
          next
        });
        return (_ctx, _cache) => {
          return vue.openBlock(), vue.createElementBlock("div", {
            ref_key: "root",
            ref: root,
            class: vue.normalizeClass(vue.unref(carouselClasses)),
            onMouseenter: _cache[6] || (_cache[6] = vue.withModifiers((...args) => vue.unref(handleMouseEnter) && vue.unref(handleMouseEnter)(...args), ["stop"])),
            onMouseleave: _cache[7] || (_cache[7] = vue.withModifiers((...args) => vue.unref(handleMouseLeave) && vue.unref(handleMouseLeave)(...args), ["stop"]))
          }, [
            vue.createElementVNode("div", {
              class: vue.normalizeClass(vue.unref(ns).e("container")),
              style: vue.normalizeStyle({ height: _ctx.height })
            }, [
              vue.unref(arrowDisplay) ? (vue.openBlock(), vue.createBlock(vue.Transition, {
                key: 0,
                name: "carousel-arrow-left",
                persisted: ""
              }, {
                default: vue.withCtx(() => [
                  vue.withDirectives(vue.createElementVNode("button", {
                    type: "button",
                    class: vue.normalizeClass([vue.unref(ns).e("arrow"), vue.unref(ns).em("arrow", "left")]),
                    onMouseenter: _cache[0] || (_cache[0] = ($event) => vue.unref(handleButtonEnter)("left")),
                    onMouseleave: _cache[1] || (_cache[1] = (...args) => vue.unref(handleButtonLeave) && vue.unref(handleButtonLeave)(...args)),
                    onClick: _cache[2] || (_cache[2] = vue.withModifiers(($event) => vue.unref(throttledArrowClick)(vue.unref(activeIndex) - 1), ["stop"]))
                  }, [
                    vue.createVNode(vue.unref(ElIcon), null, {
                      default: vue.withCtx(() => [
                        vue.createVNode(vue.unref(arrow_left_default))
                      ]),
                      _: 1
                    })
                  ], 34), [
                    [
                      vue.vShow,
                      (_ctx.arrow === "always" || vue.unref(hover)) && (props.loop || vue.unref(activeIndex) > 0)
                    ]
                  ])
                ]),
                _: 1
              })) : vue.createCommentVNode("v-if", true),
              vue.unref(arrowDisplay) ? (vue.openBlock(), vue.createBlock(vue.Transition, {
                key: 1,
                name: "carousel-arrow-right",
                persisted: ""
              }, {
                default: vue.withCtx(() => [
                  vue.withDirectives(vue.createElementVNode("button", {
                    type: "button",
                    class: vue.normalizeClass([vue.unref(ns).e("arrow"), vue.unref(ns).em("arrow", "right")]),
                    onMouseenter: _cache[3] || (_cache[3] = ($event) => vue.unref(handleButtonEnter)("right")),
                    onMouseleave: _cache[4] || (_cache[4] = (...args) => vue.unref(handleButtonLeave) && vue.unref(handleButtonLeave)(...args)),
                    onClick: _cache[5] || (_cache[5] = vue.withModifiers(($event) => vue.unref(throttledArrowClick)(vue.unref(activeIndex) + 1), ["stop"]))
                  }, [
                    vue.createVNode(vue.unref(ElIcon), null, {
                      default: vue.withCtx(() => [
                        vue.createVNode(vue.unref(arrow_right_default))
                      ]),
                      _: 1
                    })
                  ], 34), [
                    [
                      vue.vShow,
                      (_ctx.arrow === "always" || vue.unref(hover)) && (props.loop || vue.unref(activeIndex) < vue.unref(items).length - 1)
                    ]
                  ])
                ]),
                _: 1
              })) : vue.createCommentVNode("v-if", true),
              vue.renderSlot(_ctx.$slots, "default")
            ], 6),
            _ctx.indicatorPosition !== "none" ? (vue.openBlock(), vue.createElementBlock("ul", {
              key: 0,
              class: vue.normalizeClass(vue.unref(indicatorsClasses))
            }, [
              (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(vue.unref(items), (item, index) => {
                return vue.openBlock(), vue.createElementBlock("li", {
                  key: index,
                  class: vue.normalizeClass([
                    vue.unref(ns).e("indicator"),
                    vue.unref(ns).em("indicator", _ctx.direction),
                    vue.unref(ns).is("active", index === vue.unref(activeIndex))
                  ]),
                  onMouseenter: ($event) => vue.unref(throttledIndicatorHover)(index),
                  onClick: vue.withModifiers(($event) => vue.unref(handleIndicatorClick)(index), ["stop"])
                }, [
                  vue.createElementVNode("button", {
                    class: vue.normalizeClass(vue.unref(ns).e("button"))
                  }, [
                    vue.unref(hasLabel) ? (vue.openBlock(), vue.createElementBlock("span", _hoisted_2$A, vue.toDisplayString(item.props.label), 1)) : vue.createCommentVNode("v-if", true)
                  ], 2)
                ], 42, _hoisted_1$V);
              }), 128))
            ], 2)) : vue.createCommentVNode("v-if", true)
          ], 34);
        };
      }
    });
    var Carousel = /* @__PURE__ */ _export_sfc(_sfc_main$1N, [["__file", "carousel.vue"]]);
  
    const carouselItemProps = buildProps({
      name: { type: String, default: "" },
      label: {
        type: [String, Number],
        default: ""
      }
    });
  
    const useCarouselItem = (props, componentName) => {
      const carouselContext = vue.inject(carouselContextKey);
      const instance = vue.getCurrentInstance();
      const CARD_SCALE = 0.83;
      const hover = vue.ref(false);
      const translate = vue.ref(0);
      const scale = vue.ref(1);
      const active = vue.ref(false);
      const ready = vue.ref(false);
      const inStage = vue.ref(false);
      const animating = vue.ref(false);
      const { isCardType, isVertical } = carouselContext;
      function processIndex(index, activeIndex, length) {
        const lastItemIndex = length - 1;
        const prevItemIndex = activeIndex - 1;
        const nextItemIndex = activeIndex + 1;
        const halfItemIndex = length / 2;
        if (activeIndex === 0 && index === lastItemIndex) {
          return -1;
        } else if (activeIndex === lastItemIndex && index === 0) {
          return length;
        } else if (index < prevItemIndex && activeIndex - index >= halfItemIndex) {
          return length + 1;
        } else if (index > nextItemIndex && index - activeIndex >= halfItemIndex) {
          return -2;
        }
        return index;
      }
      function calcCardTranslate(index, activeIndex) {
        var _a;
        const parentWidth = ((_a = carouselContext.root.value) == null ? void 0 : _a.offsetWidth) || 0;
        if (inStage.value) {
          return parentWidth * ((2 - CARD_SCALE) * (index - activeIndex) + 1) / 4;
        } else if (index < activeIndex) {
          return -(1 + CARD_SCALE) * parentWidth / 4;
        } else {
          return (3 + CARD_SCALE) * parentWidth / 4;
        }
      }
      function calcTranslate(index, activeIndex, isVertical2) {
        const rootEl = carouselContext.root.value;
        if (!rootEl)
          return 0;
        const distance = (isVertical2 ? rootEl.offsetHeight : rootEl.offsetWidth) || 0;
        return distance * (index - activeIndex);
      }
      const translateItem = (index, activeIndex, oldIndex) => {
        var _a;
        const _isCardType = vue.unref(isCardType);
        const carouselItemLength = (_a = carouselContext.items.value.length) != null ? _a : Number.NaN;
        const isActive = index === activeIndex;
        if (!_isCardType && !isUndefined(oldIndex)) {
          animating.value = isActive || index === oldIndex;
        }
        if (!isActive && carouselItemLength > 2 && carouselContext.loop) {
          index = processIndex(index, activeIndex, carouselItemLength);
        }
        const _isVertical = vue.unref(isVertical);
        active.value = isActive;
        if (_isCardType) {
          inStage.value = Math.round(Math.abs(index - activeIndex)) <= 1;
          translate.value = calcCardTranslate(index, activeIndex);
          scale.value = vue.unref(active) ? 1 : CARD_SCALE;
        } else {
          translate.value = calcTranslate(index, activeIndex, _isVertical);
        }
        ready.value = true;
      };
      function handleItemClick() {
        if (carouselContext && vue.unref(isCardType)) {
          const index = carouselContext.items.value.findIndex(({ uid }) => uid === instance.uid);
          carouselContext.setActiveItem(index);
        }
      }
      vue.onMounted(() => {
        carouselContext.addItem({
          props,
          states: vue.reactive({
            hover,
            translate,
            scale,
            active,
            ready,
            inStage,
            animating
          }),
          uid: instance.uid,
          translateItem
        });
      });
      vue.onUnmounted(() => {
        carouselContext.removeItem(instance.uid);
      });
      return {
        active,
        animating,
        hover,
        inStage,
        isVertical,
        translate,
        isCardType,
        scale,
        ready,
        handleItemClick
      };
    };
  
    const __default__$17 = vue.defineComponent({
      name: "ElCarouselItem"
    });
    const _sfc_main$1M = /* @__PURE__ */ vue.defineComponent({
      ...__default__$17,
      props: carouselItemProps,
      setup(__props) {
        const props = __props;
        const ns = useNamespace("carousel");
        const {
          active,
          animating,
          hover,
          inStage,
          isVertical,
          translate,
          isCardType,
          scale,
          ready,
          handleItemClick
        } = useCarouselItem(props);
        const itemStyle = vue.computed(() => {
          const translateType = `translate${vue.unref(isVertical) ? "Y" : "X"}`;
          const _translate = `${translateType}(${vue.unref(translate)}px)`;
          const _scale = `scale(${vue.unref(scale)})`;
          const transform = [_translate, _scale].join(" ");
          return {
            transform
          };
        });
        return (_ctx, _cache) => {
          return vue.withDirectives((vue.openBlock(), vue.createElementBlock("div", {
            class: vue.normalizeClass([
              vue.unref(ns).e("item"),
              vue.unref(ns).is("active", vue.unref(active)),
              vue.unref(ns).is("in-stage", vue.unref(inStage)),
              vue.unref(ns).is("hover", vue.unref(hover)),
              vue.unref(ns).is("animating", vue.unref(animating)),
              { [vue.unref(ns).em("item", "card")]: vue.unref(isCardType) }
            ]),
            style: vue.normalizeStyle(vue.unref(itemStyle)),
            onClick: _cache[0] || (_cache[0] = (...args) => vue.unref(handleItemClick) && vue.unref(handleItemClick)(...args))
          }, [
            vue.unref(isCardType) ? vue.withDirectives((vue.openBlock(), vue.createElementBlock("div", {
              key: 0,
              class: vue.normalizeClass(vue.unref(ns).e("mask"))
            }, null, 2)), [
              [vue.vShow, !vue.unref(active)]
            ]) : vue.createCommentVNode("v-if", true),
            vue.renderSlot(_ctx.$slots, "default")
          ], 6)), [
            [vue.vShow, vue.unref(ready)]
          ]);
        };
      }
    });
    var CarouselItem = /* @__PURE__ */ _export_sfc(_sfc_main$1M, [["__file", "carousel-item.vue"]]);
  
    const ElCarousel = withInstall(Carousel, {
      CarouselItem
    });
    const ElCarouselItem = withNoopInstall(CarouselItem);
  
    const checkboxProps = {
      modelValue: {
        type: [Number, String, Boolean],
        default: void 0
      },
      label: {
        type: [String, Boolean, Number, Object]
      },
      indeterminate: Boolean,
      disabled: Boolean,
      checked: Boolean,
      name: {
        type: String,
        default: void 0
      },
      trueLabel: {
        type: [String, Number],
        default: void 0
      },
      falseLabel: {
        type: [String, Number],
        default: void 0
      },
      id: {
        type: String,
        default: void 0
      },
      controls: {
        type: String,
        default: void 0
      },
      border: Boolean,
      size: useSizeProp,
      tabindex: [String, Number],
      validateEvent: {
        type: Boolean,
        default: true
      }
    };
    const checkboxEmits = {
      [UPDATE_MODEL_EVENT]: (val) => isString(val) || isNumber(val) || isBoolean(val),
      change: (val) => isString(val) || isNumber(val) || isBoolean(val)
    };
  
    const useCheckboxDisabled = ({
      model,
      isChecked
    }) => {
      const checkboxGroup = vue.inject(checkboxGroupContextKey, void 0);
      const isLimitDisabled = vue.computed(() => {
        var _a, _b;
        const max = (_a = checkboxGroup == null ? void 0 : checkboxGroup.max) == null ? void 0 : _a.value;
        const min = (_b = checkboxGroup == null ? void 0 : checkboxGroup.min) == null ? void 0 : _b.value;
        return !isUndefined(max) && model.value.length >= max && !isChecked.value || !isUndefined(min) && model.value.length <= min && isChecked.value;
      });
      const isDisabled = useDisabled(vue.computed(() => (checkboxGroup == null ? void 0 : checkboxGroup.disabled.value) || isLimitDisabled.value));
      return {
        isDisabled,
        isLimitDisabled
      };
    };
  
    const useCheckboxEvent = (props, {
      model,
      isLimitExceeded,
      hasOwnLabel,
      isDisabled,
      isLabeledByFormItem
    }) => {
      const checkboxGroup = vue.inject(checkboxGroupContextKey, void 0);
      const { formItem } = useFormItem();
      const { emit } = vue.getCurrentInstance();
      function getLabeledValue(value) {
        var _a, _b;
        return value === props.trueLabel || value === true ? (_a = props.trueLabel) != null ? _a : true : (_b = props.falseLabel) != null ? _b : false;
      }
      function emitChangeEvent(checked, e) {
        emit("change", getLabeledValue(checked), e);
      }
      function handleChange(e) {
        if (isLimitExceeded.value)
          return;
        const target = e.target;
        emit("change", getLabeledValue(target.checked), e);
      }
      async function onClickRoot(e) {
        if (isLimitExceeded.value)
          return;
        if (!hasOwnLabel.value && !isDisabled.value && isLabeledByFormItem.value) {
          const eventTargets = e.composedPath();
          const hasLabel = eventTargets.some((item) => item.tagName === "LABEL");
          if (!hasLabel) {
            model.value = getLabeledValue([false, props.falseLabel].includes(model.value));
            await vue.nextTick();
            emitChangeEvent(model.value, e);
          }
        }
      }
      const validateEvent = vue.computed(() => (checkboxGroup == null ? void 0 : checkboxGroup.validateEvent) || props.validateEvent);
      vue.watch(() => props.modelValue, () => {
        if (validateEvent.value) {
          formItem == null ? void 0 : formItem.validate("change").catch((err) => debugWarn());
        }
      });
      return {
        handleChange,
        onClickRoot
      };
    };
  
    const useCheckboxModel = (props) => {
      const selfModel = vue.ref(false);
      const { emit } = vue.getCurrentInstance();
      const checkboxGroup = vue.inject(checkboxGroupContextKey, void 0);
      const isGroup = vue.computed(() => isUndefined(checkboxGroup) === false);
      const isLimitExceeded = vue.ref(false);
      const model = vue.computed({
        get() {
          var _a, _b;
          return isGroup.value ? (_a = checkboxGroup == null ? void 0 : checkboxGroup.modelValue) == null ? void 0 : _a.value : (_b = props.modelValue) != null ? _b : selfModel.value;
        },
        set(val) {
          var _a, _b;
          if (isGroup.value && isArray(val)) {
            isLimitExceeded.value = ((_a = checkboxGroup == null ? void 0 : checkboxGroup.max) == null ? void 0 : _a.value) !== void 0 && val.length > (checkboxGroup == null ? void 0 : checkboxGroup.max.value);
            isLimitExceeded.value === false && ((_b = checkboxGroup == null ? void 0 : checkboxGroup.changeEvent) == null ? void 0 : _b.call(checkboxGroup, val));
          } else {
            emit(UPDATE_MODEL_EVENT, val);
            selfModel.value = val;
          }
        }
      });
      return {
        model,
        isGroup,
        isLimitExceeded
      };
    };
  
    const useCheckboxStatus = (props, slots, { model }) => {
      const checkboxGroup = vue.inject(checkboxGroupContextKey, void 0);
      const isFocused = vue.ref(false);
      const isChecked = vue.computed(() => {
        const value = model.value;
        if (isBoolean(value)) {
          return value;
        } else if (isArray(value)) {
          if (isObject$1(props.label)) {
            return value.map(vue.toRaw).some((o) => isEqual$1(o, props.label));
          } else {
            return value.map(vue.toRaw).includes(props.label);
          }
        } else if (value !== null && value !== void 0) {
          return value === props.trueLabel;
        } else {
          return !!value;
        }
      });
      const checkboxButtonSize = useSize(vue.computed(() => {
        var _a;
        return (_a = checkboxGroup == null ? void 0 : checkboxGroup.size) == null ? void 0 : _a.value;
      }), {
        prop: true
      });
      const checkboxSize = useSize(vue.computed(() => {
        var _a;
        return (_a = checkboxGroup == null ? void 0 : checkboxGroup.size) == null ? void 0 : _a.value;
      }));
      const hasOwnLabel = vue.computed(() => {
        return !!(slots.default || props.label);
      });
      return {
        checkboxButtonSize,
        isChecked,
        isFocused,
        checkboxSize,
        hasOwnLabel
      };
    };
  
    const setStoreValue = (props, { model }) => {
      function addToStore() {
        if (isArray(model.value) && !model.value.includes(props.label)) {
          model.value.push(props.label);
        } else {
          model.value = props.trueLabel || true;
        }
      }
      props.checked && addToStore();
    };
    const useCheckbox = (props, slots) => {
      const { formItem: elFormItem } = useFormItem();
      const { model, isGroup, isLimitExceeded } = useCheckboxModel(props);
      const {
        isFocused,
        isChecked,
        checkboxButtonSize,
        checkboxSize,
        hasOwnLabel
      } = useCheckboxStatus(props, slots, { model });
      const { isDisabled } = useCheckboxDisabled({ model, isChecked });
      const { inputId, isLabeledByFormItem } = useFormItemInputId(props, {
        formItemContext: elFormItem,
        disableIdGeneration: hasOwnLabel,
        disableIdManagement: isGroup
      });
      const { handleChange, onClickRoot } = useCheckboxEvent(props, {
        model,
        isLimitExceeded,
        hasOwnLabel,
        isDisabled,
        isLabeledByFormItem
      });
      setStoreValue(props, { model });
      return {
        inputId,
        isLabeledByFormItem,
        isChecked,
        isDisabled,
        isFocused,
        checkboxButtonSize,
        checkboxSize,
        hasOwnLabel,
        model,
        handleChange,
        onClickRoot
      };
    };
  
    const _hoisted_1$U = ["tabindex", "role", "aria-checked"];
    const _hoisted_2$z = ["id", "aria-hidden", "name", "tabindex", "disabled", "true-value", "false-value"];
    const _hoisted_3$i = ["id", "aria-hidden", "disabled", "value", "name", "tabindex"];
    const __default__$16 = vue.defineComponent({
      name: "ElCheckbox"
    });
    const _sfc_main$1L = /* @__PURE__ */ vue.defineComponent({
      ...__default__$16,
      props: checkboxProps,
      emits: checkboxEmits,
      setup(__props) {
        const props = __props;
        const slots = vue.useSlots();
        const {
          inputId,
          isLabeledByFormItem,
          isChecked,
          isDisabled,
          isFocused,
          checkboxSize,
          hasOwnLabel,
          model,
          handleChange,
          onClickRoot
        } = useCheckbox(props, slots);
        const ns = useNamespace("checkbox");
        return (_ctx, _cache) => {
          return vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(!vue.unref(hasOwnLabel) && vue.unref(isLabeledByFormItem) ? "span" : "label"), {
            class: vue.normalizeClass([
              vue.unref(ns).b(),
              vue.unref(ns).m(vue.unref(checkboxSize)),
              vue.unref(ns).is("disabled", vue.unref(isDisabled)),
              vue.unref(ns).is("bordered", _ctx.border),
              vue.unref(ns).is("checked", vue.unref(isChecked))
            ]),
            "aria-controls": _ctx.indeterminate ? _ctx.controls : null,
            onClick: vue.unref(onClickRoot)
          }, {
            default: vue.withCtx(() => [
              vue.createElementVNode("span", {
                class: vue.normalizeClass([
                  vue.unref(ns).e("input"),
                  vue.unref(ns).is("disabled", vue.unref(isDisabled)),
                  vue.unref(ns).is("checked", vue.unref(isChecked)),
                  vue.unref(ns).is("indeterminate", _ctx.indeterminate),
                  vue.unref(ns).is("focus", vue.unref(isFocused))
                ]),
                tabindex: _ctx.indeterminate ? 0 : void 0,
                role: _ctx.indeterminate ? "checkbox" : void 0,
                "aria-checked": _ctx.indeterminate ? "mixed" : void 0
              }, [
                _ctx.trueLabel || _ctx.falseLabel ? vue.withDirectives((vue.openBlock(), vue.createElementBlock("input", {
                  key: 0,
                  id: vue.unref(inputId),
                  "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => vue.isRef(model) ? model.value = $event : null),
                  class: vue.normalizeClass(vue.unref(ns).e("original")),
                  type: "checkbox",
                  "aria-hidden": _ctx.indeterminate ? "true" : "false",
                  name: _ctx.name,
                  tabindex: _ctx.tabindex,
                  disabled: vue.unref(isDisabled),
                  "true-value": _ctx.trueLabel,
                  "false-value": _ctx.falseLabel,
                  onChange: _cache[1] || (_cache[1] = (...args) => vue.unref(handleChange) && vue.unref(handleChange)(...args)),
                  onFocus: _cache[2] || (_cache[2] = ($event) => isFocused.value = true),
                  onBlur: _cache[3] || (_cache[3] = ($event) => isFocused.value = false)
                }, null, 42, _hoisted_2$z)), [
                  [vue.vModelCheckbox, vue.unref(model)]
                ]) : vue.withDirectives((vue.openBlock(), vue.createElementBlock("input", {
                  key: 1,
                  id: vue.unref(inputId),
                  "onUpdate:modelValue": _cache[4] || (_cache[4] = ($event) => vue.isRef(model) ? model.value = $event : null),
                  class: vue.normalizeClass(vue.unref(ns).e("original")),
                  type: "checkbox",
                  "aria-hidden": _ctx.indeterminate ? "true" : "false",
                  disabled: vue.unref(isDisabled),
                  value: _ctx.label,
                  name: _ctx.name,
                  tabindex: _ctx.tabindex,
                  onChange: _cache[5] || (_cache[5] = (...args) => vue.unref(handleChange) && vue.unref(handleChange)(...args)),
                  onFocus: _cache[6] || (_cache[6] = ($event) => isFocused.value = true),
                  onBlur: _cache[7] || (_cache[7] = ($event) => isFocused.value = false)
                }, null, 42, _hoisted_3$i)), [
                  [vue.vModelCheckbox, vue.unref(model)]
                ]),
                vue.createElementVNode("span", {
                  class: vue.normalizeClass(vue.unref(ns).e("inner"))
                }, null, 2)
              ], 10, _hoisted_1$U),
              vue.unref(hasOwnLabel) ? (vue.openBlock(), vue.createElementBlock("span", {
                key: 0,
                class: vue.normalizeClass(vue.unref(ns).e("label"))
              }, [
                vue.renderSlot(_ctx.$slots, "default"),
                !_ctx.$slots.default ? (vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: 0 }, [
                  vue.createTextVNode(vue.toDisplayString(_ctx.label), 1)
                ], 64)) : vue.createCommentVNode("v-if", true)
              ], 2)) : vue.createCommentVNode("v-if", true)
            ]),
            _: 3
          }, 8, ["class", "aria-controls", "onClick"]);
        };
      }
    });
    var Checkbox = /* @__PURE__ */ _export_sfc(_sfc_main$1L, [["__file", "checkbox.vue"]]);
  
    const _hoisted_1$T = ["name", "tabindex", "disabled", "true-value", "false-value"];
    const _hoisted_2$y = ["name", "tabindex", "disabled", "value"];
    const __default__$15 = vue.defineComponent({
      name: "ElCheckboxButton"
    });
    const _sfc_main$1K = /* @__PURE__ */ vue.defineComponent({
      ...__default__$15,
      props: checkboxProps,
      emits: checkboxEmits,
      setup(__props) {
        const props = __props;
        const slots = vue.useSlots();
        const {
          isFocused,
          isChecked,
          isDisabled,
          checkboxButtonSize,
          model,
          handleChange
        } = useCheckbox(props, slots);
        const checkboxGroup = vue.inject(checkboxGroupContextKey, void 0);
        const ns = useNamespace("checkbox");
        const activeStyle = vue.computed(() => {
          var _a, _b, _c, _d;
          const fillValue = (_b = (_a = checkboxGroup == null ? void 0 : checkboxGroup.fill) == null ? void 0 : _a.value) != null ? _b : "";
          return {
            backgroundColor: fillValue,
            borderColor: fillValue,
            color: (_d = (_c = checkboxGroup == null ? void 0 : checkboxGroup.textColor) == null ? void 0 : _c.value) != null ? _d : "",
            boxShadow: fillValue ? `-1px 0 0 0 ${fillValue}` : void 0
          };
        });
        return (_ctx, _cache) => {
          return vue.openBlock(), vue.createElementBlock("label", {
            class: vue.normalizeClass([
              vue.unref(ns).b("button"),
              vue.unref(ns).bm("button", vue.unref(checkboxButtonSize)),
              vue.unref(ns).is("disabled", vue.unref(isDisabled)),
              vue.unref(ns).is("checked", vue.unref(isChecked)),
              vue.unref(ns).is("focus", vue.unref(isFocused))
            ])
          }, [
            _ctx.trueLabel || _ctx.falseLabel ? vue.withDirectives((vue.openBlock(), vue.createElementBlock("input", {
              key: 0,
              "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => vue.isRef(model) ? model.value = $event : null),
              class: vue.normalizeClass(vue.unref(ns).be("button", "original")),
              type: "checkbox",
              name: _ctx.name,
              tabindex: _ctx.tabindex,
              disabled: vue.unref(isDisabled),
              "true-value": _ctx.trueLabel,
              "false-value": _ctx.falseLabel,
              onChange: _cache[1] || (_cache[1] = (...args) => vue.unref(handleChange) && vue.unref(handleChange)(...args)),
              onFocus: _cache[2] || (_cache[2] = ($event) => isFocused.value = true),
              onBlur: _cache[3] || (_cache[3] = ($event) => isFocused.value = false)
            }, null, 42, _hoisted_1$T)), [
              [vue.vModelCheckbox, vue.unref(model)]
            ]) : vue.withDirectives((vue.openBlock(), vue.createElementBlock("input", {
              key: 1,
              "onUpdate:modelValue": _cache[4] || (_cache[4] = ($event) => vue.isRef(model) ? model.value = $event : null),
              class: vue.normalizeClass(vue.unref(ns).be("button", "original")),
              type: "checkbox",
              name: _ctx.name,
              tabindex: _ctx.tabindex,
              disabled: vue.unref(isDisabled),
              value: _ctx.label,
              onChange: _cache[5] || (_cache[5] = (...args) => vue.unref(handleChange) && vue.unref(handleChange)(...args)),
              onFocus: _cache[6] || (_cache[6] = ($event) => isFocused.value = true),
              onBlur: _cache[7] || (_cache[7] = ($event) => isFocused.value = false)
            }, null, 42, _hoisted_2$y)), [
              [vue.vModelCheckbox, vue.unref(model)]
            ]),
            _ctx.$slots.default || _ctx.label ? (vue.openBlock(), vue.createElementBlock("span", {
              key: 2,
              class: vue.normalizeClass(vue.unref(ns).be("button", "inner")),
              style: vue.normalizeStyle(vue.unref(isChecked) ? vue.unref(activeStyle) : void 0)
            }, [
              vue.renderSlot(_ctx.$slots, "default", {}, () => [
                vue.createTextVNode(vue.toDisplayString(_ctx.label), 1)
              ])
            ], 6)) : vue.createCommentVNode("v-if", true)
          ], 2);
        };
      }
    });
    var CheckboxButton = /* @__PURE__ */ _export_sfc(_sfc_main$1K, [["__file", "checkbox-button.vue"]]);
  
    const checkboxGroupProps = buildProps({
      modelValue: {
        type: definePropType(Array),
        default: () => []
      },
      disabled: Boolean,
      min: Number,
      max: Number,
      size: useSizeProp,
      label: String,
      fill: String,
      textColor: String,
      tag: {
        type: String,
        default: "div"
      },
      validateEvent: {
        type: Boolean,
        default: true
      }
    });
    const checkboxGroupEmits = {
      [UPDATE_MODEL_EVENT]: (val) => isArray(val),
      change: (val) => isArray(val)
    };
  
    const __default__$14 = vue.defineComponent({
      name: "ElCheckboxGroup"
    });
    const _sfc_main$1J = /* @__PURE__ */ vue.defineComponent({
      ...__default__$14,
      props: checkboxGroupProps,
      emits: checkboxGroupEmits,
      setup(__props, { emit }) {
        const props = __props;
        const ns = useNamespace("checkbox");
        const { formItem } = useFormItem();
        const { inputId: groupId, isLabeledByFormItem } = useFormItemInputId(props, {
          formItemContext: formItem
        });
        const changeEvent = async (value) => {
          emit(UPDATE_MODEL_EVENT, value);
          await vue.nextTick();
          emit("change", value);
        };
        const modelValue = vue.computed({
          get() {
            return props.modelValue;
          },
          set(val) {
            changeEvent(val);
          }
        });
        vue.provide(checkboxGroupContextKey, {
          ...pick(vue.toRefs(props), [
            "size",
            "min",
            "max",
            "disabled",
            "validateEvent",
            "fill",
            "textColor"
          ]),
          modelValue,
          changeEvent
        });
        vue.watch(() => props.modelValue, () => {
          if (props.validateEvent) {
            formItem == null ? void 0 : formItem.validate("change").catch((err) => debugWarn());
          }
        });
        return (_ctx, _cache) => {
          var _a;
          return vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(_ctx.tag), {
            id: vue.unref(groupId),
            class: vue.normalizeClass(vue.unref(ns).b("group")),
            role: "group",
            "aria-label": !vue.unref(isLabeledByFormItem) ? _ctx.label || "checkbox-group" : void 0,
            "aria-labelledby": vue.unref(isLabeledByFormItem) ? (_a = vue.unref(formItem)) == null ? void 0 : _a.labelId : void 0
          }, {
            default: vue.withCtx(() => [
              vue.renderSlot(_ctx.$slots, "default")
            ]),
            _: 3
          }, 8, ["id", "class", "aria-label", "aria-labelledby"]);
        };
      }
    });
    var CheckboxGroup = /* @__PURE__ */ _export_sfc(_sfc_main$1J, [["__file", "checkbox-group.vue"]]);
  
    const ElCheckbox = withInstall(Checkbox, {
      CheckboxButton,
      CheckboxGroup
    });
    const ElCheckboxButton = withNoopInstall(CheckboxButton);
    const ElCheckboxGroup$1 = withNoopInstall(CheckboxGroup);
  
    const radioPropsBase = buildProps({
      size: useSizeProp,
      disabled: Boolean,
      label: {
        type: [String, Number, Boolean],
        default: ""
      }
    });
    const radioProps = buildProps({
      ...radioPropsBase,
      modelValue: {
        type: [String, Number, Boolean],
        default: ""
      },
      name: {
        type: String,
        default: ""
      },
      border: Boolean
    });
    const radioEmits = {
      [UPDATE_MODEL_EVENT]: (val) => isString(val) || isNumber(val) || isBoolean(val),
      [CHANGE_EVENT]: (val) => isString(val) || isNumber(val) || isBoolean(val)
    };
  
    const useRadio = (props, emit) => {
      const radioRef = vue.ref();
      const radioGroup = vue.inject(radioGroupKey, void 0);
      const isGroup = vue.computed(() => !!radioGroup);
      const modelValue = vue.computed({
        get() {
          return isGroup.value ? radioGroup.modelValue : props.modelValue;
        },
        set(val) {
          if (isGroup.value) {
            radioGroup.changeEvent(val);
          } else {
            emit && emit(UPDATE_MODEL_EVENT, val);
          }
          radioRef.value.checked = props.modelValue === props.label;
        }
      });
      const size = useSize(vue.computed(() => radioGroup == null ? void 0 : radioGroup.size));
      const disabled = useDisabled(vue.computed(() => radioGroup == null ? void 0 : radioGroup.disabled));
      const focus = vue.ref(false);
      const tabIndex = vue.computed(() => {
        return disabled.value || isGroup.value && modelValue.value !== props.label ? -1 : 0;
      });
      return {
        radioRef,
        isGroup,
        radioGroup,
        focus,
        size,
        disabled,
        tabIndex,
        modelValue
      };
    };
  
    const _hoisted_1$S = ["value", "name", "disabled"];
    const __default__$13 = vue.defineComponent({
      name: "ElRadio"
    });
    const _sfc_main$1I = /* @__PURE__ */ vue.defineComponent({
      ...__default__$13,
      props: radioProps,
      emits: radioEmits,
      setup(__props, { emit }) {
        const props = __props;
        const ns = useNamespace("radio");
        const { radioRef, radioGroup, focus, size, disabled, modelValue } = useRadio(props, emit);
        function handleChange() {
          vue.nextTick(() => emit("change", modelValue.value));
        }
        return (_ctx, _cache) => {
          var _a;
          return vue.openBlock(), vue.createElementBlock("label", {
            class: vue.normalizeClass([
              vue.unref(ns).b(),
              vue.unref(ns).is("disabled", vue.unref(disabled)),
              vue.unref(ns).is("focus", vue.unref(focus)),
              vue.unref(ns).is("bordered", _ctx.border),
              vue.unref(ns).is("checked", vue.unref(modelValue) === _ctx.label),
              vue.unref(ns).m(vue.unref(size))
            ])
          }, [
            vue.createElementVNode("span", {
              class: vue.normalizeClass([
                vue.unref(ns).e("input"),
                vue.unref(ns).is("disabled", vue.unref(disabled)),
                vue.unref(ns).is("checked", vue.unref(modelValue) === _ctx.label)
              ])
            }, [
              vue.withDirectives(vue.createElementVNode("input", {
                ref_key: "radioRef",
                ref: radioRef,
                "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => vue.isRef(modelValue) ? modelValue.value = $event : null),
                class: vue.normalizeClass(vue.unref(ns).e("original")),
                value: _ctx.label,
                name: _ctx.name || ((_a = vue.unref(radioGroup)) == null ? void 0 : _a.name),
                disabled: vue.unref(disabled),
                type: "radio",
                onFocus: _cache[1] || (_cache[1] = ($event) => focus.value = true),
                onBlur: _cache[2] || (_cache[2] = ($event) => focus.value = false),
                onChange: handleChange
              }, null, 42, _hoisted_1$S), [
                [vue.vModelRadio, vue.unref(modelValue)]
              ]),
              vue.createElementVNode("span", {
                class: vue.normalizeClass(vue.unref(ns).e("inner"))
              }, null, 2)
            ], 2),
            vue.createElementVNode("span", {
              class: vue.normalizeClass(vue.unref(ns).e("label")),
              onKeydown: _cache[3] || (_cache[3] = vue.withModifiers(() => {
              }, ["stop"]))
            }, [
              vue.renderSlot(_ctx.$slots, "default", {}, () => [
                vue.createTextVNode(vue.toDisplayString(_ctx.label), 1)
              ])
            ], 34)
          ], 2);
        };
      }
    });
    var Radio = /* @__PURE__ */ _export_sfc(_sfc_main$1I, [["__file", "radio.vue"]]);
  
    const radioButtonProps = buildProps({
      ...radioPropsBase,
      name: {
        type: String,
        default: ""
      }
    });
  
    const _hoisted_1$R = ["value", "name", "disabled"];
    const __default__$12 = vue.defineComponent({
      name: "ElRadioButton"
    });
    const _sfc_main$1H = /* @__PURE__ */ vue.defineComponent({
      ...__default__$12,
      props: radioButtonProps,
      setup(__props) {
        const props = __props;
        const ns = useNamespace("radio");
        const { radioRef, focus, size, disabled, modelValue, radioGroup } = useRadio(props);
        const activeStyle = vue.computed(() => {
          return {
            backgroundColor: (radioGroup == null ? void 0 : radioGroup.fill) || "",
            borderColor: (radioGroup == null ? void 0 : radioGroup.fill) || "",
            boxShadow: (radioGroup == null ? void 0 : radioGroup.fill) ? `-1px 0 0 0 ${radioGroup.fill}` : "",
            color: (radioGroup == null ? void 0 : radioGroup.textColor) || ""
          };
        });
        return (_ctx, _cache) => {
          var _a;
          return vue.openBlock(), vue.createElementBlock("label", {
            class: vue.normalizeClass([
              vue.unref(ns).b("button"),
              vue.unref(ns).is("active", vue.unref(modelValue) === _ctx.label),
              vue.unref(ns).is("disabled", vue.unref(disabled)),
              vue.unref(ns).is("focus", vue.unref(focus)),
              vue.unref(ns).bm("button", vue.unref(size))
            ])
          }, [
            vue.withDirectives(vue.createElementVNode("input", {
              ref_key: "radioRef",
              ref: radioRef,
              "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => vue.isRef(modelValue) ? modelValue.value = $event : null),
              class: vue.normalizeClass(vue.unref(ns).be("button", "original-radio")),
              value: _ctx.label,
              type: "radio",
              name: _ctx.name || ((_a = vue.unref(radioGroup)) == null ? void 0 : _a.name),
              disabled: vue.unref(disabled),
              onFocus: _cache[1] || (_cache[1] = ($event) => focus.value = true),
              onBlur: _cache[2] || (_cache[2] = ($event) => focus.value = false)
            }, null, 42, _hoisted_1$R), [
              [vue.vModelRadio, vue.unref(modelValue)]
            ]),
            vue.createElementVNode("span", {
              class: vue.normalizeClass(vue.unref(ns).be("button", "inner")),
              style: vue.normalizeStyle(vue.unref(modelValue) === _ctx.label ? vue.unref(activeStyle) : {}),
              onKeydown: _cache[3] || (_cache[3] = vue.withModifiers(() => {
              }, ["stop"]))
            }, [
              vue.renderSlot(_ctx.$slots, "default", {}, () => [
                vue.createTextVNode(vue.toDisplayString(_ctx.label), 1)
              ])
            ], 38)
          ], 2);
        };
      }
    });
    var RadioButton = /* @__PURE__ */ _export_sfc(_sfc_main$1H, [["__file", "radio-button.vue"]]);
  
    const radioGroupProps = buildProps({
      id: {
        type: String,
        default: void 0
      },
      size: useSizeProp,
      disabled: Boolean,
      modelValue: {
        type: [String, Number, Boolean],
        default: ""
      },
      fill: {
        type: String,
        default: ""
      },
      label: {
        type: String,
        default: void 0
      },
      textColor: {
        type: String,
        default: ""
      },
      name: {
        type: String,
        default: void 0
      },
      validateEvent: {
        type: Boolean,
        default: true
      }
    });
    const radioGroupEmits = radioEmits;
  
    const _hoisted_1$Q = ["id", "aria-label", "aria-labelledby"];
    const __default__$11 = vue.defineComponent({
      name: "ElRadioGroup"
    });
    const _sfc_main$1G = /* @__PURE__ */ vue.defineComponent({
      ...__default__$11,
      props: radioGroupProps,
      emits: radioGroupEmits,
      setup(__props, { emit }) {
        const props = __props;
        const ns = useNamespace("radio");
        const radioId = useId();
        const radioGroupRef = vue.ref();
        const { formItem } = useFormItem();
        const { inputId: groupId, isLabeledByFormItem } = useFormItemInputId(props, {
          formItemContext: formItem
        });
        const changeEvent = (value) => {
          emit(UPDATE_MODEL_EVENT, value);
          vue.nextTick(() => emit("change", value));
        };
        vue.onMounted(() => {
          const radios = radioGroupRef.value.querySelectorAll("[type=radio]");
          const firstLabel = radios[0];
          if (!Array.from(radios).some((radio) => radio.checked) && firstLabel) {
            firstLabel.tabIndex = 0;
          }
        });
        const name = vue.computed(() => {
          return props.name || radioId.value;
        });
        vue.provide(radioGroupKey, vue.reactive({
          ...vue.toRefs(props),
          changeEvent,
          name
        }));
        vue.watch(() => props.modelValue, () => {
          if (props.validateEvent) {
            formItem == null ? void 0 : formItem.validate("change").catch((err) => debugWarn());
          }
        });
        return (_ctx, _cache) => {
          return vue.openBlock(), vue.createElementBlock("div", {
            id: vue.unref(groupId),
            ref_key: "radioGroupRef",
            ref: radioGroupRef,
            class: vue.normalizeClass(vue.unref(ns).b("group")),
            role: "radiogroup",
            "aria-label": !vue.unref(isLabeledByFormItem) ? _ctx.label || "radio-group" : void 0,
            "aria-labelledby": vue.unref(isLabeledByFormItem) ? vue.unref(formItem).labelId : void 0
          }, [
            vue.renderSlot(_ctx.$slots, "default")
          ], 10, _hoisted_1$Q);
        };
      }
    });
    var RadioGroup = /* @__PURE__ */ _export_sfc(_sfc_main$1G, [["__file", "radio-group.vue"]]);
  
    const ElRadio = withInstall(Radio, {
      RadioButton,
      RadioGroup
    });
    const ElRadioGroup = withNoopInstall(RadioGroup);
    const ElRadioButton = withNoopInstall(RadioButton);
  
    var NodeContent$1 = vue.defineComponent({
      name: "NodeContent",
      setup() {
        const ns = useNamespace("cascader-node");
        return {
          ns
        };
      },
      render() {
        const { ns } = this;
        const { node, panel } = this.$parent;
        const { data, label } = node;
        const { renderLabelFn } = panel;
        return vue.h("span", { class: ns.e("label") }, renderLabelFn ? renderLabelFn({ node, data }) : label);
      }
    });
  
    const CASCADER_PANEL_INJECTION_KEY = Symbol();
  
    const _sfc_main$1F = vue.defineComponent({
      name: "ElCascaderNode",
      components: {
        ElCheckbox,
        ElRadio,
        NodeContent: NodeContent$1,
        ElIcon,
        Check: check_default,
        Loading: loading_default,
        ArrowRight: arrow_right_default
      },
      props: {
        node: {
          type: Object,
          required: true
        },
        menuId: String
      },
      emits: ["expand"],
      setup(props, { emit }) {
        const panel = vue.inject(CASCADER_PANEL_INJECTION_KEY);
        const ns = useNamespace("cascader-node");
        const isHoverMenu = vue.computed(() => panel.isHoverMenu);
        const multiple = vue.computed(() => panel.config.multiple);
        const checkStrictly = vue.computed(() => panel.config.checkStrictly);
        const checkedNodeId = vue.computed(() => {
          var _a;
          return (_a = panel.checkedNodes[0]) == null ? void 0 : _a.uid;
        });
        const isDisabled = vue.computed(() => props.node.isDisabled);
        const isLeaf = vue.computed(() => props.node.isLeaf);
        const expandable = vue.computed(() => checkStrictly.value && !isLeaf.value || !isDisabled.value);
        const inExpandingPath = vue.computed(() => isInPath(panel.expandingNode));
        const inCheckedPath = vue.computed(() => checkStrictly.value && panel.checkedNodes.some(isInPath));
        const isInPath = (node) => {
          var _a;
          const { level, uid } = props.node;
          return ((_a = node == null ? void 0 : node.pathNodes[level - 1]) == null ? void 0 : _a.uid) === uid;
        };
        const doExpand = () => {
          if (inExpandingPath.value)
            return;
          panel.expandNode(props.node);
        };
        const doCheck = (checked) => {
          const { node } = props;
          if (checked === node.checked)
            return;
          panel.handleCheckChange(node, checked);
        };
        const doLoad = () => {
          panel.lazyLoad(props.node, () => {
            if (!isLeaf.value)
              doExpand();
          });
        };
        const handleHoverExpand = (e) => {
          if (!isHoverMenu.value)
            return;
          handleExpand();
          !isLeaf.value && emit("expand", e);
        };
        const handleExpand = () => {
          const { node } = props;
          if (!expandable.value || node.loading)
            return;
          node.loaded ? doExpand() : doLoad();
        };
        const handleClick = () => {
          if (isHoverMenu.value && !isLeaf.value)
            return;
          if (isLeaf.value && !isDisabled.value && !checkStrictly.value && !multiple.value) {
            handleCheck(true);
          } else {
            handleExpand();
          }
        };
        const handleSelectCheck = (checked) => {
          if (checkStrictly.value) {
            doCheck(checked);
            if (props.node.loaded) {
              doExpand();
            }
          } else {
            handleCheck(checked);
          }
        };
        const handleCheck = (checked) => {
          if (!props.node.loaded) {
            doLoad();
          } else {
            doCheck(checked);
            !checkStrictly.value && doExpand();
          }
        };
        return {
          panel,
          isHoverMenu,
          multiple,
          checkStrictly,
          checkedNodeId,
          isDisabled,
          isLeaf,
          expandable,
          inExpandingPath,
          inCheckedPath,
          ns,
          handleHoverExpand,
          handleExpand,
          handleClick,
          handleCheck,
          handleSelectCheck
        };
      }
    });
    const _hoisted_1$P = ["id", "aria-haspopup", "aria-owns", "aria-expanded", "tabindex"];
    const _hoisted_2$x = /* @__PURE__ */ vue.createElementVNode("span", null, null, -1);
    function _sfc_render$x(_ctx, _cache, $props, $setup, $data, $options) {
      const _component_el_checkbox = vue.resolveComponent("el-checkbox");
      const _component_el_radio = vue.resolveComponent("el-radio");
      const _component_check = vue.resolveComponent("check");
      const _component_el_icon = vue.resolveComponent("el-icon");
      const _component_node_content = vue.resolveComponent("node-content");
      const _component_loading = vue.resolveComponent("loading");
      const _component_arrow_right = vue.resolveComponent("arrow-right");
      return vue.openBlock(), vue.createElementBlock("li", {
        id: `${_ctx.menuId}-${_ctx.node.uid}`,
        role: "menuitem",
        "aria-haspopup": !_ctx.isLeaf,
        "aria-owns": _ctx.isLeaf ? null : _ctx.menuId,
        "aria-expanded": _ctx.inExpandingPath,
        tabindex: _ctx.expandable ? -1 : void 0,
        class: vue.normalizeClass([
          _ctx.ns.b(),
          _ctx.ns.is("selectable", _ctx.checkStrictly),
          _ctx.ns.is("active", _ctx.node.checked),
          _ctx.ns.is("disabled", !_ctx.expandable),
          _ctx.inExpandingPath && "in-active-path",
          _ctx.inCheckedPath && "in-checked-path"
        ]),
        onMouseenter: _cache[2] || (_cache[2] = (...args) => _ctx.handleHoverExpand && _ctx.handleHoverExpand(...args)),
        onFocus: _cache[3] || (_cache[3] = (...args) => _ctx.handleHoverExpand && _ctx.handleHoverExpand(...args)),
        onClick: _cache[4] || (_cache[4] = (...args) => _ctx.handleClick && _ctx.handleClick(...args))
      }, [
        vue.createCommentVNode(" prefix "),
        _ctx.multiple ? (vue.openBlock(), vue.createBlock(_component_el_checkbox, {
          key: 0,
          "model-value": _ctx.node.checked,
          indeterminate: _ctx.node.indeterminate,
          disabled: _ctx.isDisabled,
          onClick: _cache[0] || (_cache[0] = vue.withModifiers(() => {
          }, ["stop"])),
          "onUpdate:modelValue": _ctx.handleSelectCheck
        }, null, 8, ["model-value", "indeterminate", "disabled", "onUpdate:modelValue"])) : _ctx.checkStrictly ? (vue.openBlock(), vue.createBlock(_component_el_radio, {
          key: 1,
          "model-value": _ctx.checkedNodeId,
          label: _ctx.node.uid,
          disabled: _ctx.isDisabled,
          "onUpdate:modelValue": _ctx.handleSelectCheck,
          onClick: _cache[1] || (_cache[1] = vue.withModifiers(() => {
          }, ["stop"]))
        }, {
          default: vue.withCtx(() => [
            vue.createCommentVNode("\n        Add an empty element to avoid render label,\n        do not use empty fragment here for https://github.com/vuejs/vue-next/pull/2485\n      "),
            _hoisted_2$x
          ]),
          _: 1
        }, 8, ["model-value", "label", "disabled", "onUpdate:modelValue"])) : _ctx.isLeaf && _ctx.node.checked ? (vue.openBlock(), vue.createBlock(_component_el_icon, {
          key: 2,
          class: vue.normalizeClass(_ctx.ns.e("prefix"))
        }, {
          default: vue.withCtx(() => [
            vue.createVNode(_component_check)
          ]),
          _: 1
        }, 8, ["class"])) : vue.createCommentVNode("v-if", true),
        vue.createCommentVNode(" content "),
        vue.createVNode(_component_node_content),
        vue.createCommentVNode(" postfix "),
        !_ctx.isLeaf ? (vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: 3 }, [
          _ctx.node.loading ? (vue.openBlock(), vue.createBlock(_component_el_icon, {
            key: 0,
            class: vue.normalizeClass([_ctx.ns.is("loading"), _ctx.ns.e("postfix")])
          }, {
            default: vue.withCtx(() => [
              vue.createVNode(_component_loading)
            ]),
            _: 1
          }, 8, ["class"])) : (vue.openBlock(), vue.createBlock(_component_el_icon, {
            key: 1,
            class: vue.normalizeClass(["arrow-right", _ctx.ns.e("postfix")])
          }, {
            default: vue.withCtx(() => [
              vue.createVNode(_component_arrow_right)
            ]),
            _: 1
          }, 8, ["class"]))
        ], 64)) : vue.createCommentVNode("v-if", true)
      ], 42, _hoisted_1$P);
    }
    var ElCascaderNode = /* @__PURE__ */ _export_sfc(_sfc_main$1F, [["render", _sfc_render$x], ["__file", "node.vue"]]);
  
    const _sfc_main$1E = vue.defineComponent({
      name: "ElCascaderMenu",
      components: {
        Loading: loading_default,
        ElIcon,
        ElScrollbar,
        ElCascaderNode
      },
      props: {
        nodes: {
          type: Array,
          required: true
        },
        index: {
          type: Number,
          required: true
        }
      },
      setup(props) {
        const instance = vue.getCurrentInstance();
        const ns = useNamespace("cascader-menu");
        const { t } = useLocale();
        const id = generateId();
        let activeNode = null;
        let hoverTimer = null;
        const panel = vue.inject(CASCADER_PANEL_INJECTION_KEY);
        const hoverZone = vue.ref(null);
        const isEmpty = vue.computed(() => !props.nodes.length);
        const isLoading = vue.computed(() => !panel.initialLoaded);
        const menuId = vue.computed(() => `cascader-menu-${id}-${props.index}`);
        const handleExpand = (e) => {
          activeNode = e.target;
        };
        const handleMouseMove = (e) => {
          if (!panel.isHoverMenu || !activeNode || !hoverZone.value)
            return;
          if (activeNode.contains(e.target)) {
            clearHoverTimer();
            const el = instance.vnode.el;
            const { left } = el.getBoundingClientRect();
            const { offsetWidth, offsetHeight } = el;
            const startX = e.clientX - left;
            const top = activeNode.offsetTop;
            const bottom = top + activeNode.offsetHeight;
            hoverZone.value.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) {
            hoverTimer = window.setTimeout(clearHoverZone, panel.config.hoverThreshold);
          }
        };
        const clearHoverTimer = () => {
          if (!hoverTimer)
            return;
          clearTimeout(hoverTimer);
          hoverTimer = null;
        };
        const clearHoverZone = () => {
          if (!hoverZone.value)
            return;
          hoverZone.value.innerHTML = "";
          clearHoverTimer();
        };
        return {
          ns,
          panel,
          hoverZone,
          isEmpty,
          isLoading,
          menuId,
          t,
          handleExpand,
          handleMouseMove,
          clearHoverZone
        };
      }
    });
    function _sfc_render$w(_ctx, _cache, $props, $setup, $data, $options) {
      const _component_el_cascader_node = vue.resolveComponent("el-cascader-node");
      const _component_loading = vue.resolveComponent("loading");
      const _component_el_icon = vue.resolveComponent("el-icon");
      const _component_el_scrollbar = vue.resolveComponent("el-scrollbar");
      return vue.openBlock(), vue.createBlock(_component_el_scrollbar, {
        key: _ctx.menuId,
        tag: "ul",
        role: "menu",
        class: vue.normalizeClass(_ctx.ns.b()),
        "wrap-class": _ctx.ns.e("wrap"),
        "view-class": [_ctx.ns.e("list"), _ctx.ns.is("empty", _ctx.isEmpty)],
        onMousemove: _ctx.handleMouseMove,
        onMouseleave: _ctx.clearHoverZone
      }, {
        default: vue.withCtx(() => {
          var _a;
          return [
            (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(_ctx.nodes, (node) => {
              return vue.openBlock(), vue.createBlock(_component_el_cascader_node, {
                key: node.uid,
                node,
                "menu-id": _ctx.menuId,
                onExpand: _ctx.handleExpand
              }, null, 8, ["node", "menu-id", "onExpand"]);
            }), 128)),
            _ctx.isLoading ? (vue.openBlock(), vue.createElementBlock("div", {
              key: 0,
              class: vue.normalizeClass(_ctx.ns.e("empty-text"))
            }, [
              vue.createVNode(_component_el_icon, {
                size: "14",
                class: vue.normalizeClass(_ctx.ns.is("loading"))
              }, {
                default: vue.withCtx(() => [
                  vue.createVNode(_component_loading)
                ]),
                _: 1
              }, 8, ["class"]),
              vue.createTextVNode(" " + vue.toDisplayString(_ctx.t("el.cascader.loading")), 1)
            ], 2)) : _ctx.isEmpty ? (vue.openBlock(), vue.createElementBlock("div", {
              key: 1,
              class: vue.normalizeClass(_ctx.ns.e("empty-text"))
            }, vue.toDisplayString(_ctx.t("el.cascader.noData")), 3)) : ((_a = _ctx.panel) == null ? void 0 : _a.isHoverMenu) ? (vue.openBlock(), vue.createElementBlock("svg", {
              key: 2,
              ref: "hoverZone",
              class: vue.normalizeClass(_ctx.ns.e("hover-zone"))
            }, null, 2)) : vue.createCommentVNode("v-if", true)
          ];
        }),
        _: 1
      }, 8, ["class", "wrap-class", "view-class", "onMousemove", "onMouseleave"]);
    }
    var ElCascaderMenu = /* @__PURE__ */ _export_sfc(_sfc_main$1E, [["render", _sfc_render$w], ["__file", "menu.vue"]]);
  
    let uid = 0;
    const calculatePathNodes = (node) => {
      const nodes = [node];
      let { parent } = node;
      while (parent) {
        nodes.unshift(parent);
        parent = parent.parent;
      }
      return nodes;
    };
    class Node$2 {
      constructor(data, config, parent, root = false) {
        this.data = data;
        this.config = config;
        this.parent = parent;
        this.root = root;
        this.uid = uid++;
        this.checked = false;
        this.indeterminate = false;
        this.loading = false;
        const { value: valueKey, label: labelKey, children: childrenKey } = config;
        const childrenData = data[childrenKey];
        const pathNodes = calculatePathNodes(this);
        this.level = root ? 0 : parent ? parent.level + 1 : 1;
        this.value = data[valueKey];
        this.label = data[labelKey];
        this.pathNodes = pathNodes;
        this.pathValues = pathNodes.map((node) => node.value);
        this.pathLabels = pathNodes.map((node) => node.label);
        this.childrenData = childrenData;
        this.children = (childrenData || []).map((child) => new Node$2(child, config, this));
        this.loaded = !config.lazy || this.isLeaf || !isEmpty(childrenData);
      }
      get isDisabled() {
        const { data, parent, config } = this;
        const { disabled, checkStrictly } = config;
        const isDisabled = isFunction(disabled) ? disabled(data, this) : !!data[disabled];
        return isDisabled || !checkStrictly && (parent == null ? void 0 : parent.isDisabled);
      }
      get isLeaf() {
        const { data, config, childrenData, loaded } = this;
        const { lazy, leaf } = config;
        const isLeaf = isFunction(leaf) ? leaf(data, this) : data[leaf];
        return isUndefined(isLeaf) ? lazy && !loaded ? false : !(Array.isArray(childrenData) && childrenData.length) : !!isLeaf;
      }
      get valueByOption() {
        return this.config.emitPath ? this.pathValues : this.value;
      }
      appendChild(childData) {
        const { childrenData, children } = this;
        const node = new Node$2(childData, this.config, this);
        if (Array.isArray(childrenData)) {
          childrenData.push(childData);
        } else {
          this.childrenData = [childData];
        }
        children.push(node);
        return node;
      }
      calcText(allLevels, separator) {
        const text = allLevels ? this.pathLabels.join(separator) : this.label;
        this.text = text;
        return text;
      }
      broadcast(event, ...args) {
        const handlerName = `onParent${capitalize(event)}`;
        this.children.forEach((child) => {
          if (child) {
            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 = this.loaded && this.children.filter((child) => !child.isDisabled).every((child) => child.loaded && child.checked) && checked;
        this.indeterminate = this.loaded && checkedNum !== totalNum && checkedNum > 0;
      }
      doCheck(checked) {
        if (this.checked === checked)
          return;
        const { checkStrictly, multiple } = this.config;
        if (checkStrictly || !multiple) {
          this.checked = checked;
        } else {
          this.broadcast("check", checked);
          this.setCheckState(checked);
          this.emit("check");
        }
      }
    }
    var Node$3 = Node$2;
  
    const flatNodes = (nodes, leafOnly) => {
      return nodes.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 {
      constructor(data, config) {
        this.config = config;
        const nodes = (data || []).map((nodeData) => new Node$3(nodeData, this.config));
        this.nodes = nodes;
        this.allNodes = flatNodes(nodes, false);
        this.leafNodes = flatNodes(nodes, true);
      }
      getNodes() {
        return this.nodes;
      }
      getFlattedNodes(leafOnly) {
        return leafOnly ? this.leafNodes : this.allNodes;
      }
      appendNode(nodeData, parentNode) {
        const node = parentNode ? parentNode.appendChild(nodeData) : new Node$3(nodeData, this.config);
        if (!parentNode)
          this.nodes.push(node);
        this.allNodes.push(node);
        node.isLeaf && this.leafNodes.push(node);
      }
      appendNodes(nodeDataList, parentNode) {
        nodeDataList.forEach((nodeData) => this.appendNode(nodeData, parentNode));
      }
      getNodeByValue(value, leafOnly = false) {
        if (!value && value !== 0)
          return null;
        const node = this.getFlattedNodes(leafOnly).find((node2) => isEqual$1(node2.value, value) || isEqual$1(node2.pathValues, value));
        return node || null;
      }
      getSameNode(node) {
        if (!node)
          return null;
        const node_ = this.getFlattedNodes(false).find(({ value, level }) => isEqual$1(node.value, value) && node.level === level);
        return node_ || null;
      }
    }
  
    const CommonProps = {
      modelValue: [Number, String, Array],
      options: {
        type: Array,
        default: () => []
      },
      props: {
        type: Object,
        default: () => ({})
      }
    };
    const DefaultProps = {
      expandTrigger: "click",
      multiple: false,
      checkStrictly: false,
      emitPath: true,
      lazy: false,
      lazyLoad: NOOP,
      value: "value",
      label: "label",
      children: "children",
      leaf: "leaf",
      disabled: "disabled",
      hoverThreshold: 500
    };
    const useCascaderConfig = (props) => {
      return vue.computed(() => ({
        ...DefaultProps,
        ...props.props
      }));
    };
  
    const getMenuIndex = (el) => {
      if (!el)
        return 0;
      const pieces = el.id.split("-");
      return Number(pieces[pieces.length - 2]);
    };
    const checkNode = (el) => {
      if (!el)
        return;
      const input = el.querySelector("input");
      if (input) {
        input.click();
      } else if (isLeaf(el)) {
        el.click();
      }
    };
    const sortByOriginalOrder = (oldNodes, newNodes) => {
      const newNodesCopy = newNodes.slice(0);
      const newIds = newNodesCopy.map((node) => node.uid);
      const res = oldNodes.reduce((acc, item) => {
        const index = newIds.indexOf(item.uid);
        if (index > -1) {
          acc.push(item);
          newNodesCopy.splice(index, 1);
          newIds.splice(index, 1);
        }
        return acc;
      }, []);
      res.push(...newNodesCopy);
      return res;
    };
  
    const _sfc_main$1D = vue.defineComponent({
      name: "ElCascaderPanel",
      components: {
        ElCascaderMenu
      },
      props: {
        ...CommonProps,
        border: {
          type: Boolean,
          default: true
        },
        renderLabel: Function
      },
      emits: [UPDATE_MODEL_EVENT, CHANGE_EVENT, "close", "expand-change"],
      setup(props, { emit, slots }) {
        let manualChecked = false;
        const ns = useNamespace("cascader");
        const config = useCascaderConfig(props);
        let store = null;
        const initialLoaded = vue.ref(true);
        const menuList = vue.ref([]);
        const checkedValue = vue.ref(null);
        const menus = vue.ref([]);
        const expandingNode = vue.ref(null);
        const checkedNodes = vue.ref([]);
        const isHoverMenu = vue.computed(() => config.value.expandTrigger === "hover");
        const renderLabelFn = vue.computed(() => props.renderLabel || slots.default);
        const initStore = () => {
          const { options } = props;
          const cfg = config.value;
          manualChecked = false;
          store = new Store(options, cfg);
          menus.value = [store.getNodes()];
          if (cfg.lazy && isEmpty(props.options)) {
            initialLoaded.value = false;
            lazyLoad(void 0, (list) => {
              if (list) {
                store = new Store(list, cfg);
                menus.value = [store.getNodes()];
              }
              initialLoaded.value = true;
              syncCheckedValue(false, true);
            });
          } else {
            syncCheckedValue(false, true);
          }
        };
        const lazyLoad = (node, cb) => {
          const cfg = config.value;
          node = node || new Node$3({}, cfg, void 0, true);
          node.loading = true;
          const resolve = (dataList) => {
            const _node = node;
            const parent = _node.root ? null : _node;
            dataList && (store == null ? void 0 : store.appendNodes(dataList, parent));
            _node.loading = false;
            _node.loaded = true;
            _node.childrenData = _node.childrenData || [];
            cb && cb(dataList);
          };
          cfg.lazyLoad(node, resolve);
        };
        const expandNode = (node, silent) => {
          var _a;
          const { level } = node;
          const newMenus = menus.value.slice(0, level);
          let newExpandingNode;
          if (node.isLeaf) {
            newExpandingNode = node.pathNodes[level - 2];
          } else {
            newExpandingNode = node;
            newMenus.push(node.children);
          }
          if (((_a = expandingNode.value) == null ? void 0 : _a.uid) !== (newExpandingNode == null ? void 0 : newExpandingNode.uid)) {
            expandingNode.value = node;
            menus.value = newMenus;
            !silent && emit("expand-change", (node == null ? void 0 : node.pathValues) || []);
          }
        };
        const handleCheckChange = (node, checked, emitClose = true) => {
          const { checkStrictly, multiple } = config.value;
          const oldNode = checkedNodes.value[0];
          manualChecked = true;
          !multiple && (oldNode == null ? void 0 : oldNode.doCheck(false));
          node.doCheck(checked);
          calculateCheckedValue();
          emitClose && !multiple && !checkStrictly && emit("close");
          !emitClose && !multiple && !checkStrictly && expandParentNode(node);
        };
        const expandParentNode = (node) => {
          if (!node)
            return;
          node = node.parent;
          expandParentNode(node);
          node && expandNode(node);
        };
        const getFlattedNodes = (leafOnly) => {
          return store == null ? void 0 : store.getFlattedNodes(leafOnly);
        };
        const getCheckedNodes = (leafOnly) => {
          var _a;
          return (_a = getFlattedNodes(leafOnly)) == null ? void 0 : _a.filter((node) => node.checked !== false);
        };
        const clearCheckedNodes = () => {
          checkedNodes.value.forEach((node) => node.doCheck(false));
          calculateCheckedValue();
        };
        const calculateCheckedValue = () => {
          var _a;
          const { checkStrictly, multiple } = config.value;
          const oldNodes = checkedNodes.value;
          const newNodes = getCheckedNodes(!checkStrictly);
          const nodes = sortByOriginalOrder(oldNodes, newNodes);
          const values = nodes.map((node) => node.valueByOption);
          checkedNodes.value = nodes;
          checkedValue.value = multiple ? values : (_a = values[0]) != null ? _a : null;
        };
        const syncCheckedValue = (loaded = false, forced = false) => {
          const { modelValue } = props;
          const { lazy, multiple, checkStrictly } = config.value;
          const leafOnly = !checkStrictly;
          if (!initialLoaded.value || manualChecked || !forced && isEqual$1(modelValue, checkedValue.value))
            return;
          if (lazy && !loaded) {
            const values = unique(flattenDeep(castArray(modelValue)));
            const nodes = values.map((val) => store == null ? void 0 : store.getNodeByValue(val)).filter((node) => !!node && !node.loaded && !node.loading);
            if (nodes.length) {
              nodes.forEach((node) => {
                lazyLoad(node, () => syncCheckedValue(false, forced));
              });
            } else {
              syncCheckedValue(true, forced);
            }
          } else {
            const values = multiple ? castArray(modelValue) : [modelValue];
            const nodes = unique(values.map((val) => store == null ? void 0 : store.getNodeByValue(val, leafOnly)));
            syncMenuState(nodes, forced);
            checkedValue.value = cloneDeep(modelValue);
          }
        };
        const syncMenuState = (newCheckedNodes, reserveExpandingState = true) => {
          const { checkStrictly } = config.value;
          const oldNodes = checkedNodes.value;
          const newNodes = newCheckedNodes.filter((node) => !!node && (checkStrictly || node.isLeaf));
          const oldExpandingNode = store == null ? void 0 : store.getSameNode(expandingNode.value);
          const newExpandingNode = reserveExpandingState && oldExpandingNode || newNodes[0];
          if (newExpandingNode) {
            newExpandingNode.pathNodes.forEach((node) => expandNode(node, true));
          } else {
            expandingNode.value = null;
          }
          oldNodes.forEach((node) => node.doCheck(false));
          newNodes.forEach((node) => node.doCheck(true));
          checkedNodes.value = newNodes;
          vue.nextTick(scrollToExpandingNode);
        };
        const scrollToExpandingNode = () => {
          if (!isClient)
            return;
          menuList.value.forEach((menu) => {
            const menuElement = menu == null ? void 0 : menu.$el;
            if (menuElement) {
              const container = menuElement.querySelector(`.${ns.namespace.value}-scrollbar__wrap`);
              const activeNode = menuElement.querySelector(`.${ns.b("node")}.${ns.is("active")}`) || menuElement.querySelector(`.${ns.b("node")}.in-active-path`);
              scrollIntoView(container, activeNode);
            }
          });
        };
        const handleKeyDown = (e) => {
          const target = e.target;
          const { code } = e;
          switch (code) {
            case EVENT_CODE.up:
            case EVENT_CODE.down: {
              e.preventDefault();
              const distance = code === EVENT_CODE.up ? -1 : 1;
              focusNode(getSibling(target, distance, `.${ns.b("node")}[tabindex="-1"]`));
              break;
            }
            case EVENT_CODE.left: {
              e.preventDefault();
              const preMenu = menuList.value[getMenuIndex(target) - 1];
              const expandedNode = preMenu == null ? void 0 : preMenu.$el.querySelector(`.${ns.b("node")}[aria-expanded="true"]`);
              focusNode(expandedNode);
              break;
            }
            case EVENT_CODE.right: {
              e.preventDefault();
              const nextMenu = menuList.value[getMenuIndex(target) + 1];
              const firstNode = nextMenu == null ? void 0 : nextMenu.$el.querySelector(`.${ns.b("node")}[tabindex="-1"]`);
              focusNode(firstNode);
              break;
            }
            case EVENT_CODE.enter:
              checkNode(target);
              break;
          }
        };
        vue.provide(CASCADER_PANEL_INJECTION_KEY, vue.reactive({
          config,
          expandingNode,
          checkedNodes,
          isHoverMenu,
          initialLoaded,
          renderLabelFn,
          lazyLoad,
          expandNode,
          handleCheckChange
        }));
        vue.watch([config, () => props.options], initStore, {
          deep: true,
          immediate: true
        });
        vue.watch(() => props.modelValue, () => {
          manualChecked = false;
          syncCheckedValue();
        }, {
          deep: true
        });
        vue.watch(() => checkedValue.value, (val) => {
          if (!isEqual$1(val, props.modelValue)) {
            emit(UPDATE_MODEL_EVENT, val);
            emit(CHANGE_EVENT, val);
          }
        });
        vue.onBeforeUpdate(() => menuList.value = []);
        vue.onMounted(() => !isEmpty(props.modelValue) && syncCheckedValue());
        return {
          ns,
          menuList,
          menus,
          checkedNodes,
          handleKeyDown,
          handleCheckChange,
          getFlattedNodes,
          getCheckedNodes,
          clearCheckedNodes,
          calculateCheckedValue,
          scrollToExpandingNode
        };
      }
    });
    function _sfc_render$v(_ctx, _cache, $props, $setup, $data, $options) {
      const _component_el_cascader_menu = vue.resolveComponent("el-cascader-menu");
      return vue.openBlock(), vue.createElementBlock("div", {
        class: vue.normalizeClass([_ctx.ns.b("panel"), _ctx.ns.is("bordered", _ctx.border)]),
        onKeydown: _cache[0] || (_cache[0] = (...args) => _ctx.handleKeyDown && _ctx.handleKeyDown(...args))
      }, [
        (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(_ctx.menus, (menu, index) => {
          return vue.openBlock(), vue.createBlock(_component_el_cascader_menu, {
            key: index,
            ref_for: true,
            ref: (item) => _ctx.menuList[index] = item,
            index,
            nodes: [...menu]
          }, null, 8, ["index", "nodes"]);
        }), 128))
      ], 34);
    }
    var CascaderPanel = /* @__PURE__ */ _export_sfc(_sfc_main$1D, [["render", _sfc_render$v], ["__file", "index.vue"]]);
  
    CascaderPanel.install = (app) => {
      app.component(CascaderPanel.name, CascaderPanel);
    };
    const _CascaderPanel = CascaderPanel;
    const ElCascaderPanel = _CascaderPanel;
  
    const tagProps = buildProps({
      closable: Boolean,
      type: {
        type: String,
        values: ["success", "info", "warning", "danger", ""],
        default: ""
      },
      hit: Boolean,
      disableTransitions: Boolean,
      color: {
        type: String,
        default: ""
      },
      size: {
        type: String,
        values: componentSizes,
        default: ""
      },
      effect: {
        type: String,
        values: ["dark", "light", "plain"],
        default: "light"
      },
      round: Boolean
    });
    const tagEmits = {
      close: (evt) => evt instanceof MouseEvent,
      click: (evt) => evt instanceof MouseEvent
    };
  
    const __default__$10 = vue.defineComponent({
      name: "ElTag"
    });
    const _sfc_main$1C = /* @__PURE__ */ vue.defineComponent({
      ...__default__$10,
      props: tagProps,
      emits: tagEmits,
      setup(__props, { emit }) {
        const props = __props;
        const tagSize = useSize();
        const ns = useNamespace("tag");
        const classes = vue.computed(() => {
          const { type, hit, effect, closable, round } = props;
          return [
            ns.b(),
            ns.is("closable", closable),
            ns.m(type),
            ns.m(tagSize.value),
            ns.m(effect),
            ns.is("hit", hit),
            ns.is("round", round)
          ];
        });
        const handleClose = (event) => {
          emit("close", event);
        };
        const handleClick = (event) => {
          emit("click", event);
        };
        return (_ctx, _cache) => {
          return _ctx.disableTransitions ? (vue.openBlock(), vue.createElementBlock("span", {
            key: 0,
            class: vue.normalizeClass(vue.unref(classes)),
            style: vue.normalizeStyle({ backgroundColor: _ctx.color }),
            onClick: handleClick
          }, [
            vue.createElementVNode("span", {
              class: vue.normalizeClass(vue.unref(ns).e("content"))
            }, [
              vue.renderSlot(_ctx.$slots, "default")
            ], 2),
            _ctx.closable ? (vue.openBlock(), vue.createBlock(vue.unref(ElIcon), {
              key: 0,
              class: vue.normalizeClass(vue.unref(ns).e("close")),
              onClick: vue.withModifiers(handleClose, ["stop"])
            }, {
              default: vue.withCtx(() => [
                vue.createVNode(vue.unref(close_default))
              ]),
              _: 1
            }, 8, ["class", "onClick"])) : vue.createCommentVNode("v-if", true)
          ], 6)) : (vue.openBlock(), vue.createBlock(vue.Transition, {
            key: 1,
            name: `${vue.unref(ns).namespace.value}-zoom-in-center`,
            appear: ""
          }, {
            default: vue.withCtx(() => [
              vue.createElementVNode("span", {
                class: vue.normalizeClass(vue.unref(classes)),
                style: vue.normalizeStyle({ backgroundColor: _ctx.color }),
                onClick: handleClick
              }, [
                vue.createElementVNode("span", {
                  class: vue.normalizeClass(vue.unref(ns).e("content"))
                }, [
                  vue.renderSlot(_ctx.$slots, "default")
                ], 2),
                _ctx.closable ? (vue.openBlock(), vue.createBlock(vue.unref(ElIcon), {
                  key: 0,
                  class: vue.normalizeClass(vue.unref(ns).e("close")),
                  onClick: vue.withModifiers(handleClose, ["stop"])
                }, {
                  default: vue.withCtx(() => [
                    vue.createVNode(vue.unref(close_default))
                  ]),
                  _: 1
                }, 8, ["class", "onClick"])) : vue.createCommentVNode("v-if", true)
              ], 6)
            ]),
            _: 3
          }, 8, ["name"]));
        };
      }
    });
    var Tag = /* @__PURE__ */ _export_sfc(_sfc_main$1C, [["__file", "tag.vue"]]);
  
    const ElTag = withInstall(Tag);
  
    const popperOptions = {
      modifiers: [
        {
          name: "arrowPosition",
          enabled: true,
          phase: "main",
          fn: ({ state }) => {
            const { modifiersData, placement } = state;
            if (["right", "left", "bottom", "top"].includes(placement))
              return;
            modifiersData.arrow.x = 35;
          },
          requires: ["arrow"]
        }
      ]
    };
    const COMPONENT_NAME$f = "ElCascader";
    const _sfc_main$1B = vue.defineComponent({
      name: COMPONENT_NAME$f,
      components: {
        ElCascaderPanel: _CascaderPanel,
        ElInput,
        ElTooltip,
        ElScrollbar,
        ElTag,
        ElIcon,
        CircleClose: circle_close_default,
        Check: check_default,
        ArrowDown: arrow_down_default
      },
      directives: {
        Clickoutside: ClickOutside
      },
      props: {
        ...CommonProps,
        size: {
          type: String,
          validator: isValidComponentSize
        },
        placeholder: {
          type: String
        },
        disabled: Boolean,
        clearable: Boolean,
        filterable: Boolean,
        filterMethod: {
          type: Function,
          default: (node, keyword) => node.text.includes(keyword)
        },
        separator: {
          type: String,
          default: " / "
        },
        showAllLevels: {
          type: Boolean,
          default: true
        },
        collapseTags: Boolean,
        collapseTagsTooltip: {
          type: Boolean,
          default: false
        },
        debounce: {
          type: Number,
          default: 300
        },
        beforeFilter: {
          type: Function,
          default: () => true
        },
        popperClass: {
          type: String,
          default: ""
        },
        teleported: useTooltipContentProps.teleported,
        tagType: { ...tagProps.type, default: "info" },
        validateEvent: {
          type: Boolean,
          default: true
        }
      },
      emits: [
        UPDATE_MODEL_EVENT,
        CHANGE_EVENT,
        "focus",
        "blur",
        "visible-change",
        "expand-change",
        "remove-tag"
      ],
      setup(props, { emit }) {
        let inputInitialHeight = 0;
        let pressDeleteCount = 0;
        const nsCascader = useNamespace("cascader");
        const nsInput = useNamespace("input");
        const { t } = useLocale();
        const { form, formItem } = useFormItem();
        const tooltipRef = vue.ref(null);
        const input = vue.ref(null);
        const tagWrapper = vue.ref(null);
        const panel = vue.ref(null);
        const suggestionPanel = vue.ref(null);
        const popperVisible = vue.ref(false);
        const inputHover = vue.ref(false);
        const filtering = vue.ref(false);
        const inputValue = vue.ref("");
        const searchInputValue = vue.ref("");
        const presentTags = vue.ref([]);
        const allPresentTags = vue.ref([]);
        const suggestions = vue.ref([]);
        const isOnComposition = vue.ref(false);
        const isDisabled = vue.computed(() => props.disabled || (form == null ? void 0 : form.disabled));
        const inputPlaceholder = vue.computed(() => props.placeholder || t("el.cascader.placeholder"));
        const currentPlaceholder = vue.computed(() => searchInputValue.value || presentTags.value.length > 0 ? "" : inputPlaceholder.value);
        const realSize = useSize();
        const tagSize = vue.computed(() => ["small"].includes(realSize.value) ? "small" : "default");
        const multiple = vue.computed(() => !!props.props.multiple);
        const readonly = vue.computed(() => !props.filterable || multiple.value);
        const searchKeyword = vue.computed(() => multiple.value ? searchInputValue.value : inputValue.value);
        const checkedNodes = vue.computed(() => {
          var _a;
          return ((_a = panel.value) == null ? void 0 : _a.checkedNodes) || [];
        });
        const clearBtnVisible = vue.computed(() => {
          if (!props.clearable || isDisabled.value || filtering.value || !inputHover.value)
            return false;
          return !!checkedNodes.value.length;
        });
        const presentText = vue.computed(() => {
          const { showAllLevels, separator } = props;
          const nodes = checkedNodes.value;
          return nodes.length ? multiple.value ? "" : nodes[0].calcText(showAllLevels, separator) : "";
        });
        const checkedValue = vue.computed({
          get() {
            return cloneDeep(props.modelValue);
          },
          set(val) {
            emit(UPDATE_MODEL_EVENT, val);
            emit(CHANGE_EVENT, val);
            if (props.validateEvent) {
              formItem == null ? void 0 : formItem.validate("change").catch((err) => debugWarn());
            }
          }
        });
        const popperPaneRef = vue.computed(() => {
          var _a, _b;
          return (_b = (_a = tooltipRef.value) == null ? void 0 : _a.popperRef) == null ? void 0 : _b.contentRef;
        });
        const togglePopperVisible = (visible) => {
          var _a, _b, _c;
          if (isDisabled.value)
            return;
          visible = visible != null ? visible : !popperVisible.value;
          if (visible !== popperVisible.value) {
            popperVisible.value = visible;
            (_b = (_a = input.value) == null ? void 0 : _a.input) == null ? void 0 : _b.setAttribute("aria-expanded", `${visible}`);
            if (visible) {
              updatePopperPosition();
              vue.nextTick((_c = panel.value) == null ? void 0 : _c.scrollToExpandingNode);
            } else if (props.filterable) {
              syncPresentTextValue();
            }
            emit("visible-change", visible);
          }
        };
        const updatePopperPosition = () => {
          vue.nextTick(() => {
            var _a;
            (_a = tooltipRef.value) == null ? void 0 : _a.updatePopper();
          });
        };
        const hideSuggestionPanel = () => {
          filtering.value = false;
        };
        const genTag = (node) => {
          const { showAllLevels, separator } = props;
          return {
            node,
            key: node.uid,
            text: node.calcText(showAllLevels, separator),
            hitState: false,
            closable: !isDisabled.value && !node.isDisabled,
            isCollapseTag: false
          };
        };
        const deleteTag = (tag) => {
          var _a;
          const node = tag.node;
          node.doCheck(false);
          (_a = panel.value) == null ? void 0 : _a.calculateCheckedValue();
          emit("remove-tag", node.valueByOption);
        };
        const calculatePresentTags = () => {
          if (!multiple.value)
            return;
          const nodes = checkedNodes.value;
          const tags = [];
          const allTags = [];
          nodes.forEach((node) => allTags.push(genTag(node)));
          allPresentTags.value = allTags;
          if (nodes.length) {
            const [first, ...rest] = nodes;
            const restCount = rest.length;
            tags.push(genTag(first));
            if (restCount) {
              if (props.collapseTags) {
                tags.push({
                  key: -1,
                  text: `+ ${restCount}`,
                  closable: false,
                  isCollapseTag: true
                });
              } else {
                rest.forEach((node) => tags.push(genTag(node)));
              }
            }
          }
          presentTags.value = tags;
        };
        const calculateSuggestions = () => {
          var _a, _b;
          const { filterMethod, showAllLevels, separator } = props;
          const res = (_b = (_a = panel.value) == null ? void 0 : _a.getFlattedNodes(!props.props.checkStrictly)) == null ? void 0 : _b.filter((node) => {
            if (node.isDisabled)
              return false;
            node.calcText(showAllLevels, separator);
            return filterMethod(node, searchKeyword.value);
          });
          if (multiple.value) {
            presentTags.value.forEach((tag) => {
              tag.hitState = false;
            });
            allPresentTags.value.forEach((tag) => {
              tag.hitState = false;
            });
          }
          filtering.value = true;
          suggestions.value = res;
          updatePopperPosition();
        };
        const focusFirstNode = () => {
          var _a;
          let firstNode;
          if (filtering.value && suggestionPanel.value) {
            firstNode = suggestionPanel.value.$el.querySelector(`.${nsCascader.e("suggestion-item")}`);
          } else {
            firstNode = (_a = panel.value) == null ? void 0 : _a.$el.querySelector(`.${nsCascader.b("node")}[tabindex="-1"]`);
          }
          if (firstNode) {
            firstNode.focus();
            !filtering.value && firstNode.click();
          }
        };
        const updateStyle = () => {
          var _a, _b;
          const inputInner = (_a = input.value) == null ? void 0 : _a.input;
          const tagWrapperEl = tagWrapper.value;
          const suggestionPanelEl = (_b = suggestionPanel.value) == null ? void 0 : _b.$el;
          if (!isClient || !inputInner)
            return;
          if (suggestionPanelEl) {
            const suggestionList = suggestionPanelEl.querySelector(`.${nsCascader.e("suggestion-list")}`);
            suggestionList.style.minWidth = `${inputInner.offsetWidth}px`;
          }
          if (tagWrapperEl) {
            const { offsetHeight } = tagWrapperEl;
            const height = presentTags.value.length > 0 ? `${Math.max(offsetHeight + 6, inputInitialHeight)}px` : `${inputInitialHeight}px`;
            inputInner.style.height = height;
            updatePopperPosition();
          }
        };
        const getCheckedNodes = (leafOnly) => {
          var _a;
          return (_a = panel.value) == null ? void 0 : _a.getCheckedNodes(leafOnly);
        };
        const handleExpandChange = (value) => {
          updatePopperPosition();
          emit("expand-change", value);
        };
        const handleComposition = (event) => {
          var _a;
          const text = (_a = event.target) == null ? void 0 : _a.value;
          if (event.type === "compositionend") {
            isOnComposition.value = false;
            vue.nextTick(() => handleInput(text));
          } else {
            const lastCharacter = text[text.length - 1] || "";
            isOnComposition.value = !isKorean(lastCharacter);
          }
        };
        const handleKeyDown = (e) => {
          if (isOnComposition.value)
            return;
          switch (e.code) {
            case EVENT_CODE.enter:
              togglePopperVisible();
              break;
            case EVENT_CODE.down:
              togglePopperVisible(true);
              vue.nextTick(focusFirstNode);
              e.preventDefault();
              break;
            case EVENT_CODE.esc:
              if (popperVisible.value === true) {
                e.preventDefault();
                e.stopPropagation();
                togglePopperVisible(false);
              }
              break;
            case EVENT_CODE.tab:
              togglePopperVisible(false);
              break;
          }
        };
        const handleClear = () => {
          var _a;
          (_a = panel.value) == null ? void 0 : _a.clearCheckedNodes();
          if (!popperVisible.value && props.filterable) {
            syncPresentTextValue();
          }
          togglePopperVisible(false);
        };
        const syncPresentTextValue = () => {
          const { value } = presentText;
          inputValue.value = value;
          searchInputValue.value = value;
        };
        const handleSuggestionClick = (node) => {
          var _a, _b;
          const { checked } = node;
          if (multiple.value) {
            (_a = panel.value) == null ? void 0 : _a.handleCheckChange(node, !checked, false);
          } else {
            !checked && ((_b = panel.value) == null ? void 0 : _b.handleCheckChange(node, true, false));
            togglePopperVisible(false);
          }
        };
        const handleSuggestionKeyDown = (e) => {
          const target = e.target;
          const { code } = e;
          switch (code) {
            case EVENT_CODE.up:
            case EVENT_CODE.down: {
              const distance = code === EVENT_CODE.up ? -1 : 1;
              focusNode(getSibling(target, distance, `.${nsCascader.e("suggestion-item")}[tabindex="-1"]`));
              break;
            }
            case EVENT_CODE.enter:
              target.click();
              break;
          }
        };
        const handleDelete = () => {
          const tags = presentTags.value;
          const lastTag = tags[tags.length - 1];
          pressDeleteCount = searchInputValue.value ? 0 : pressDeleteCount + 1;
          if (!lastTag || !pressDeleteCount || props.collapseTags && tags.length > 1)
            return;
          if (lastTag.hitState) {
            deleteTag(lastTag);
          } else {
            lastTag.hitState = true;
          }
        };
        const handleFilter = debounce(() => {
          const { value } = searchKeyword;
          if (!value)
            return;
          const passed = props.beforeFilter(value);
          if (isPromise(passed)) {
            passed.then(calculateSuggestions).catch(() => {
            });
          } else if (passed !== false) {
            calculateSuggestions();
          } else {
            hideSuggestionPanel();
          }
        }, props.debounce);
        const handleInput = (val, e) => {
          !popperVisible.value && togglePopperVisible(true);
          if (e == null ? void 0 : e.isComposing)
            return;
          val ? handleFilter() : hideSuggestionPanel();
        };
        vue.watch(filtering, updatePopperPosition);
        vue.watch([checkedNodes, isDisabled], calculatePresentTags);
        vue.watch(presentTags, () => {
          vue.nextTick(() => updateStyle());
        });
        vue.watch(presentText, syncPresentTextValue, { immediate: true });
        vue.onMounted(() => {
          const inputInner = input.value.input;
          const inputInnerHeight = Number.parseFloat(useCssVar(nsInput.cssVarName("input-height"), inputInner).value) - 2;
          inputInitialHeight = inputInner.offsetHeight || inputInnerHeight;
          useResizeObserver(inputInner, updateStyle);
        });
        return {
          popperOptions,
          tooltipRef,
          popperPaneRef,
          input,
          tagWrapper,
          panel,
          suggestionPanel,
          popperVisible,
          inputHover,
          inputPlaceholder,
          currentPlaceholder,
          filtering,
          presentText,
          checkedValue,
          inputValue,
          searchInputValue,
          presentTags,
          allPresentTags,
          suggestions,
          isDisabled,
          isOnComposition,
          realSize,
          tagSize,
          multiple,
          readonly,
          clearBtnVisible,
          nsCascader,
          nsInput,
          t,
          togglePopperVisible,
          hideSuggestionPanel,
          deleteTag,
          focusFirstNode,
          getCheckedNodes,
          handleExpandChange,
          handleKeyDown,
          handleComposition,
          handleClear,
          handleSuggestionClick,
          handleSuggestionKeyDown,
          handleDelete,
          handleInput
        };
      }
    });
    const _hoisted_1$O = { key: 0 };
    const _hoisted_2$w = ["placeholder"];
    const _hoisted_3$h = ["onClick"];
    function _sfc_render$u(_ctx, _cache, $props, $setup, $data, $options) {
      const _component_circle_close = vue.resolveComponent("circle-close");
      const _component_el_icon = vue.resolveComponent("el-icon");
      const _component_arrow_down = vue.resolveComponent("arrow-down");
      const _component_el_input = vue.resolveComponent("el-input");
      const _component_el_tag = vue.resolveComponent("el-tag");
      const _component_el_tooltip = vue.resolveComponent("el-tooltip");
      const _component_el_cascader_panel = vue.resolveComponent("el-cascader-panel");
      const _component_check = vue.resolveComponent("check");
      const _component_el_scrollbar = vue.resolveComponent("el-scrollbar");
      const _directive_clickoutside = vue.resolveDirective("clickoutside");
      return vue.openBlock(), vue.createBlock(_component_el_tooltip, {
        ref: "tooltipRef",
        visible: _ctx.popperVisible,
        teleported: _ctx.teleported,
        "popper-class": [_ctx.nsCascader.e("dropdown"), _ctx.popperClass],
        "popper-options": _ctx.popperOptions,
        "fallback-placements": [
          "bottom-start",
          "bottom",
          "top-start",
          "top",
          "right",
          "left"
        ],
        "stop-popper-mouse-event": false,
        "gpu-acceleration": false,
        placement: "bottom-start",
        transition: `${_ctx.nsCascader.namespace.value}-zoom-in-top`,
        effect: "light",
        pure: "",
        persistent: "",
        onHide: _ctx.hideSuggestionPanel
      }, {
        default: vue.withCtx(() => [
          vue.withDirectives((vue.openBlock(), vue.createElementBlock("div", {
            class: vue.normalizeClass([
              _ctx.nsCascader.b(),
              _ctx.nsCascader.m(_ctx.realSize),
              _ctx.nsCascader.is("disabled", _ctx.isDisabled),
              _ctx.$attrs.class
            ]),
            style: vue.normalizeStyle(_ctx.$attrs.style),
            onClick: _cache[11] || (_cache[11] = () => _ctx.togglePopperVisible(_ctx.readonly ? void 0 : true)),
            onKeydown: _cache[12] || (_cache[12] = (...args) => _ctx.handleKeyDown && _ctx.handleKeyDown(...args)),
            onMouseenter: _cache[13] || (_cache[13] = ($event) => _ctx.inputHover = true),
            onMouseleave: _cache[14] || (_cache[14] = ($event) => _ctx.inputHover = false)
          }, [
            vue.createVNode(_component_el_input, {
              ref: "input",
              modelValue: _ctx.inputValue,
              "onUpdate:modelValue": _cache[1] || (_cache[1] = ($event) => _ctx.inputValue = $event),
              placeholder: _ctx.currentPlaceholder,
              readonly: _ctx.readonly,
              disabled: _ctx.isDisabled,
              "validate-event": false,
              size: _ctx.realSize,
              class: vue.normalizeClass(_ctx.nsCascader.is("focus", _ctx.popperVisible)),
              onCompositionstart: _ctx.handleComposition,
              onCompositionupdate: _ctx.handleComposition,
              onCompositionend: _ctx.handleComposition,
              onFocus: _cache[2] || (_cache[2] = (e) => _ctx.$emit("focus", e)),
              onBlur: _cache[3] || (_cache[3] = (e) => _ctx.$emit("blur", e)),
              onInput: _ctx.handleInput
            }, {
              suffix: vue.withCtx(() => [
                _ctx.clearBtnVisible ? (vue.openBlock(), vue.createBlock(_component_el_icon, {
                  key: "clear",
                  class: vue.normalizeClass([_ctx.nsInput.e("icon"), "icon-circle-close"]),
                  onClick: vue.withModifiers(_ctx.handleClear, ["stop"])
                }, {
                  default: vue.withCtx(() => [
                    vue.createVNode(_component_circle_close)
                  ]),
                  _: 1
                }, 8, ["class", "onClick"])) : (vue.openBlock(), vue.createBlock(_component_el_icon, {
                  key: "arrow-down",
                  class: vue.normalizeClass([
                    _ctx.nsInput.e("icon"),
                    "icon-arrow-down",
                    _ctx.nsCascader.is("reverse", _ctx.popperVisible)
                  ]),
                  onClick: _cache[0] || (_cache[0] = vue.withModifiers(($event) => _ctx.togglePopperVisible(), ["stop"]))
                }, {
                  default: vue.withCtx(() => [
                    vue.createVNode(_component_arrow_down)
                  ]),
                  _: 1
                }, 8, ["class"]))
              ]),
              _: 1
            }, 8, ["modelValue", "placeholder", "readonly", "disabled", "size", "class", "onCompositionstart", "onCompositionupdate", "onCompositionend", "onInput"]),
            _ctx.multiple ? (vue.openBlock(), vue.createElementBlock("div", {
              key: 0,
              ref: "tagWrapper",
              class: vue.normalizeClass(_ctx.nsCascader.e("tags"))
            }, [
              (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(_ctx.presentTags, (tag) => {
                return vue.openBlock(), vue.createBlock(_component_el_tag, {
                  key: tag.key,
                  type: _ctx.tagType,
                  size: _ctx.tagSize,
                  hit: tag.hitState,
                  closable: tag.closable,
                  "disable-transitions": "",
                  onClose: ($event) => _ctx.deleteTag(tag)
                }, {
                  default: vue.withCtx(() => [
                    tag.isCollapseTag === false ? (vue.openBlock(), vue.createElementBlock("span", _hoisted_1$O, vue.toDisplayString(tag.text), 1)) : (vue.openBlock(), vue.createBlock(_component_el_tooltip, {
                      key: 1,
                      teleported: false,
                      disabled: _ctx.popperVisible || !_ctx.collapseTagsTooltip,
                      "fallback-placements": ["bottom", "top", "right", "left"],
                      placement: "bottom",
                      effect: "light"
                    }, {
                      default: vue.withCtx(() => [
                        vue.createElementVNode("span", null, vue.toDisplayString(tag.text), 1)
                      ]),
                      content: vue.withCtx(() => [
                        vue.createElementVNode("div", {
                          class: vue.normalizeClass(_ctx.nsCascader.e("collapse-tags"))
                        }, [
                          (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(_ctx.allPresentTags.slice(1), (tag2, idx) => {
                            return vue.openBlock(), vue.createElementBlock("div", {
                              key: idx,
                              class: vue.normalizeClass(_ctx.nsCascader.e("collapse-tag"))
                            }, [
                              (vue.openBlock(), vue.createBlock(_component_el_tag, {
                                key: tag2.key,
                                class: "in-tooltip",
                                type: _ctx.tagType,
                                size: _ctx.tagSize,
                                hit: tag2.hitState,
                                closable: tag2.closable,
                                "disable-transitions": "",
                                onClose: ($event) => _ctx.deleteTag(tag2)
                              }, {
                                default: vue.withCtx(() => [
                                  vue.createElementVNode("span", null, vue.toDisplayString(tag2.text), 1)
                                ]),
                                _: 2
                              }, 1032, ["type", "size", "hit", "closable", "onClose"]))
                            ], 2);
                          }), 128))
                        ], 2)
                      ]),
                      _: 2
                    }, 1032, ["disabled"]))
                  ]),
                  _: 2
                }, 1032, ["type", "size", "hit", "closable", "onClose"]);
              }), 128)),
              _ctx.filterable && !_ctx.isDisabled ? vue.withDirectives((vue.openBlock(), vue.createElementBlock("input", {
                key: 0,
                "onUpdate:modelValue": _cache[4] || (_cache[4] = ($event) => _ctx.searchInputValue = $event),
                type: "text",
                class: vue.normalizeClass(_ctx.nsCascader.e("search-input")),
                placeholder: _ctx.presentText ? "" : _ctx.inputPlaceholder,
                onInput: _cache[5] || (_cache[5] = (e) => _ctx.handleInput(_ctx.searchInputValue, e)),
                onClick: _cache[6] || (_cache[6] = vue.withModifiers(($event) => _ctx.togglePopperVisible(true), ["stop"])),
                onKeydown: _cache[7] || (_cache[7] = vue.withKeys((...args) => _ctx.handleDelete && _ctx.handleDelete(...args), ["delete"])),
                onCompositionstart: _cache[8] || (_cache[8] = (...args) => _ctx.handleComposition && _ctx.handleComposition(...args)),
                onCompositionupdate: _cache[9] || (_cache[9] = (...args) => _ctx.handleComposition && _ctx.handleComposition(...args)),
                onCompositionend: _cache[10] || (_cache[10] = (...args) => _ctx.handleComposition && _ctx.handleComposition(...args))
              }, null, 42, _hoisted_2$w)), [
                [vue.vModelText, _ctx.searchInputValue]
              ]) : vue.createCommentVNode("v-if", true)
            ], 2)) : vue.createCommentVNode("v-if", true)
          ], 38)), [
            [_directive_clickoutside, () => _ctx.togglePopperVisible(false), _ctx.popperPaneRef]
          ])
        ]),
        content: vue.withCtx(() => [
          vue.withDirectives(vue.createVNode(_component_el_cascader_panel, {
            ref: "panel",
            modelValue: _ctx.checkedValue,
            "onUpdate:modelValue": _cache[15] || (_cache[15] = ($event) => _ctx.checkedValue = $event),
            options: _ctx.options,
            props: _ctx.props,
            border: false,
            "render-label": _ctx.$slots.default,
            onExpandChange: _ctx.handleExpandChange,
            onClose: _cache[16] || (_cache[16] = ($event) => _ctx.$nextTick(() => _ctx.togglePopperVisible(false)))
          }, null, 8, ["modelValue", "options", "props", "render-label", "onExpandChange"]), [
            [vue.vShow, !_ctx.filtering]
          ]),
          _ctx.filterable ? vue.withDirectives((vue.openBlock(), vue.createBlock(_component_el_scrollbar, {
            key: 0,
            ref: "suggestionPanel",
            tag: "ul",
            class: vue.normalizeClass(_ctx.nsCascader.e("suggestion-panel")),
            "view-class": _ctx.nsCascader.e("suggestion-list"),
            onKeydown: _ctx.handleSuggestionKeyDown
          }, {
            default: vue.withCtx(() => [
              _ctx.suggestions.length ? (vue.openBlock(true), vue.createElementBlock(vue.Fragment, { key: 0 }, vue.renderList(_ctx.suggestions, (item) => {
                return vue.openBlock(), vue.createElementBlock("li", {
                  key: item.uid,
                  class: vue.normalizeClass([
                    _ctx.nsCascader.e("suggestion-item"),
                    _ctx.nsCascader.is("checked", item.checked)
                  ]),
                  tabindex: -1,
                  onClick: ($event) => _ctx.handleSuggestionClick(item)
                }, [
                  vue.createElementVNode("span", null, vue.toDisplayString(item.text), 1),
                  item.checked ? (vue.openBlock(), vue.createBlock(_component_el_icon, { key: 0 }, {
                    default: vue.withCtx(() => [
                      vue.createVNode(_component_check)
                    ]),
                    _: 1
                  })) : vue.createCommentVNode("v-if", true)
                ], 10, _hoisted_3$h);
              }), 128)) : vue.renderSlot(_ctx.$slots, "empty", { key: 1 }, () => [
                vue.createElementVNode("li", {
                  class: vue.normalizeClass(_ctx.nsCascader.e("empty-text"))
                }, vue.toDisplayString(_ctx.t("el.cascader.noMatch")), 3)
              ])
            ]),
            _: 3
          }, 8, ["class", "view-class", "onKeydown"])), [
            [vue.vShow, _ctx.filtering]
          ]) : vue.createCommentVNode("v-if", true)
        ]),
        _: 3
      }, 8, ["visible", "teleported", "popper-class", "popper-options", "transition", "onHide"]);
    }
    var Cascader = /* @__PURE__ */ _export_sfc(_sfc_main$1B, [["render", _sfc_render$u], ["__file", "index.vue"]]);
  
    Cascader.install = (app) => {
      app.component(Cascader.name, Cascader);
    };
    const _Cascader = Cascader;
    const ElCascader = _Cascader;
  
    const checkTagProps = buildProps({
      checked: {
        type: Boolean,
        default: false
      }
    });
    const checkTagEmits = {
      "update:checked": (value) => isBoolean(value),
      [CHANGE_EVENT]: (value) => isBoolean(value)
    };
  
    const __default__$$ = vue.defineComponent({
      name: "ElCheckTag"
    });
    const _sfc_main$1A = /* @__PURE__ */ vue.defineComponent({
      ...__default__$$,
      props: checkTagProps,
      emits: checkTagEmits,
      setup(__props, { emit }) {
        const props = __props;
        const ns = useNamespace("check-tag");
        const handleChange = () => {
          const checked = !props.checked;
          emit(CHANGE_EVENT, checked);
          emit("update:checked", checked);
        };
        return (_ctx, _cache) => {
          return vue.openBlock(), vue.createElementBlock("span", {
            class: vue.normalizeClass([vue.unref(ns).b(), vue.unref(ns).is("checked", _ctx.checked)]),
            onClick: handleChange
          }, [
            vue.renderSlot(_ctx.$slots, "default")
          ], 2);
        };
      }
    });
    var CheckTag = /* @__PURE__ */ _export_sfc(_sfc_main$1A, [["__file", "check-tag.vue"]]);
  
    const ElCheckTag = withInstall(CheckTag);
  
    const colProps = buildProps({
      tag: {
        type: String,
        default: "div"
      },
      span: {
        type: Number,
        default: 24
      },
      offset: {
        type: Number,
        default: 0
      },
      pull: {
        type: Number,
        default: 0
      },
      push: {
        type: Number,
        default: 0
      },
      xs: {
        type: definePropType([Number, Object]),
        default: () => mutable({})
      },
      sm: {
        type: definePropType([Number, Object]),
        default: () => mutable({})
      },
      md: {
        type: definePropType([Number, Object]),
        default: () => mutable({})
      },
      lg: {
        type: definePropType([Number, Object]),
        default: () => mutable({})
      },
      xl: {
        type: definePropType([Number, Object]),
        default: () => mutable({})
      }
    });
  
    const __default__$_ = vue.defineComponent({
      name: "ElCol"
    });
    const _sfc_main$1z = /* @__PURE__ */ vue.defineComponent({
      ...__default__$_,
      props: colProps,
      setup(__props) {
        const props = __props;
        const { gutter } = vue.inject(rowContextKey, { gutter: vue.computed(() => 0) });
        const ns = useNamespace("col");
        const style = vue.computed(() => {
          const styles = {};
          if (gutter.value) {
            styles.paddingLeft = styles.paddingRight = `${gutter.value / 2}px`;
          }
          return styles;
        });
        const classes = vue.computed(() => {
          const classes2 = [];
          const pos = ["span", "offset", "pull", "push"];
          pos.forEach((prop) => {
            const size = props[prop];
            if (isNumber(size)) {
              if (prop === "span")
                classes2.push(ns.b(`${props[prop]}`));
              else if (size > 0)
                classes2.push(ns.b(`${prop}-${props[prop]}`));
            }
          });
          const sizes = ["xs", "sm", "md", "lg", "xl"];
          sizes.forEach((size) => {
            if (isNumber(props[size])) {
              classes2.push(ns.b(`${size}-${props[size]}`));
            } else if (isObject$1(props[size])) {
              Object.entries(props[size]).forEach(([prop, sizeProp]) => {
                classes2.push(prop !== "span" ? ns.b(`${size}-${prop}-${sizeProp}`) : ns.b(`${size}-${sizeProp}`));
              });
            }
          });
          if (gutter.value) {
            classes2.push(ns.is("guttered"));
          }
          return classes2;
        });
        return (_ctx, _cache) => {
          return vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(_ctx.tag), {
            class: vue.normalizeClass([vue.unref(ns).b(), vue.unref(classes)]),
            style: vue.normalizeStyle(vue.unref(style))
          }, {
            default: vue.withCtx(() => [
              vue.renderSlot(_ctx.$slots, "default")
            ]),
            _: 3
          }, 8, ["class", "style"]);
        };
      }
    });
    var Col = /* @__PURE__ */ _export_sfc(_sfc_main$1z, [["__file", "col.vue"]]);
  
    const ElCol = withInstall(Col);
  
    const emitChangeFn = (value) => typeof isNumber(value);
    const collapseProps = buildProps({
      accordion: Boolean,
      modelValue: {
        type: definePropType([Array, String, Number]),
        default: () => mutable([])
      }
    });
    const collapseEmits = {
      [UPDATE_MODEL_EVENT]: emitChangeFn,
      [CHANGE_EVENT]: emitChangeFn
    };
  
    const useCollapse = (props, emit) => {
      const activeNames = vue.ref(castArray$1(props.modelValue));
      const setActiveNames = (_activeNames) => {
        activeNames.value = _activeNames;
        const value = props.accordion ? activeNames.value[0] : activeNames.value;
        emit(UPDATE_MODEL_EVENT, value);
        emit(CHANGE_EVENT, value);
      };
      const handleItemClick = (name) => {
        if (props.accordion) {
          setActiveNames([activeNames.value[0] === name ? "" : name]);
        } else {
          const _activeNames = [...activeNames.value];
          const index = _activeNames.indexOf(name);
          if (index > -1) {
            _activeNames.splice(index, 1);
          } else {
            _activeNames.push(name);
          }
          setActiveNames(_activeNames);
        }
      };
      vue.watch(() => props.modelValue, () => activeNames.value = castArray$1(props.modelValue), { deep: true });
      vue.provide(collapseContextKey, {
        activeNames,
        handleItemClick
      });
      return {
        activeNames,
        setActiveNames
      };
    };
    const useCollapseDOM = () => {
      const ns = useNamespace("collapse");
      const rootKls = vue.computed(() => ns.b());
      return {
        rootKls
      };
    };
  
    const __default__$Z = vue.defineComponent({
      name: "ElCollapse"
    });
    const _sfc_main$1y = /* @__PURE__ */ vue.defineComponent({
      ...__default__$Z,
      props: collapseProps,
      emits: collapseEmits,
      setup(__props, { expose, emit }) {
        const props = __props;
        const { activeNames, setActiveNames } = useCollapse(props, emit);
        const { rootKls } = useCollapseDOM();
        expose({
          activeNames,
          setActiveNames
        });
        return (_ctx, _cache) => {
          return vue.openBlock(), vue.createElementBlock("div", {
            class: vue.normalizeClass(vue.unref(rootKls)),
            role: "tablist",
            "aria-multiselectable": "true"
          }, [
            vue.renderSlot(_ctx.$slots, "default")
          ], 2);
        };
      }
    });
    var Collapse = /* @__PURE__ */ _export_sfc(_sfc_main$1y, [["__file", "collapse.vue"]]);
  
    const __default__$Y = vue.defineComponent({
      name: "ElCollapseTransition"
    });
    const _sfc_main$1x = /* @__PURE__ */ vue.defineComponent({
      ...__default__$Y,
      setup(__props) {
        const ns = useNamespace("collapse-transition");
        const on = {
          beforeEnter(el) {
            if (!el.dataset)
              el.dataset = {};
            el.dataset.oldPaddingTop = el.style.paddingTop;
            el.dataset.oldPaddingBottom = el.style.paddingBottom;
            el.style.maxHeight = 0;
            el.style.paddingTop = 0;
            el.style.paddingBottom = 0;
          },
          enter(el) {
            el.dataset.oldOverflow = el.style.overflow;
            if (el.scrollHeight !== 0) {
              el.style.maxHeight = `${el.scrollHeight}px`;
              el.style.paddingTop = el.dataset.oldPaddingTop;
              el.style.paddingBottom = el.dataset.oldPaddingBottom;
            } else {
              el.style.maxHeight = 0;
              el.style.paddingTop = el.dataset.oldPaddingTop;
              el.style.paddingBottom = el.dataset.oldPaddingBottom;
            }
            el.style.overflow = "hidden";
          },
          afterEnter(el) {
            el.style.maxHeight = "";
            el.style.overflow = el.dataset.oldOverflow;
          },
          beforeLeave(el) {
            if (!el.dataset)
              el.dataset = {};
            el.dataset.oldPaddingTop = el.style.paddingTop;
            el.dataset.oldPaddingBottom = el.style.paddingBottom;
            el.dataset.oldOverflow = el.style.overflow;
            el.style.maxHeight = `${el.scrollHeight}px`;
            el.style.overflow = "hidden";
          },
          leave(el) {
            if (el.scrollHeight !== 0) {
              el.style.maxHeight = 0;
              el.style.paddingTop = 0;
              el.style.paddingBottom = 0;
            }
          },
          afterLeave(el) {
            el.style.maxHeight = "";
            el.style.overflow = el.dataset.oldOverflow;
            el.style.paddingTop = el.dataset.oldPaddingTop;
            el.style.paddingBottom = el.dataset.oldPaddingBottom;
          }
        };
        return (_ctx, _cache) => {
          return vue.openBlock(), vue.createBlock(vue.Transition, vue.mergeProps({
            name: vue.unref(ns).b()
          }, vue.toHandlers(on)), {
            default: vue.withCtx(() => [
              vue.renderSlot(_ctx.$slots, "default")
            ]),
            _: 3
          }, 16, ["name"]);
        };
      }
    });
    var CollapseTransition = /* @__PURE__ */ _export_sfc(_sfc_main$1x, [["__file", "collapse-transition.vue"]]);
  
    CollapseTransition.install = (app) => {
      app.component(CollapseTransition.name, CollapseTransition);
    };
    const _CollapseTransition = CollapseTransition;
    const ElCollapseTransition = _CollapseTransition;
  
    const collapseItemProps = buildProps({
      title: {
        type: String,
        default: ""
      },
      name: {
        type: definePropType([String, Number]),
        default: () => generateId()
      },
      disabled: Boolean
    });
  
    const useCollapseItem = (props) => {
      const collapse = vue.inject(collapseContextKey);
      const focusing = vue.ref(false);
      const isClick = vue.ref(false);
      const id = vue.ref(generateId());
      const isActive = vue.computed(() => collapse == null ? void 0 : collapse.activeNames.value.includes(props.name));
      const handleFocus = () => {
        setTimeout(() => {
          if (!isClick.value) {
            focusing.value = true;
          } else {
            isClick.value = false;
          }
        }, 50);
      };
      const handleHeaderClick = () => {
        if (props.disabled)
          return;
        collapse == null ? void 0 : collapse.handleItemClick(props.name);
        focusing.value = false;
        isClick.value = true;
      };
      const handleEnterClick = () => {
        collapse == null ? void 0 : collapse.handleItemClick(props.name);
      };
      return {
        focusing,
        id,
        isActive,
        handleFocus,
        handleHeaderClick,
        handleEnterClick
      };
    };
    const useCollapseItemDOM = (props, { focusing, isActive, id }) => {
      const ns = useNamespace("collapse");
      const rootKls = vue.computed(() => [
        ns.b("item"),
        ns.is("active", vue.unref(isActive)),
        ns.is("disabled", props.disabled)
      ]);
      const headKls = vue.computed(() => [
        ns.be("item", "header"),
        ns.is("active", vue.unref(isActive)),
        { focusing: vue.unref(focusing) && !props.disabled }
      ]);
      const arrowKls = vue.computed(() => [
        ns.be("item", "arrow"),
        ns.is("active", vue.unref(isActive))
      ]);
      const itemWrapperKls = vue.computed(() => ns.be("item", "wrap"));
      const itemContentKls = vue.computed(() => ns.be("item", "content"));
      const scopedContentId = vue.computed(() => ns.b(`content-${vue.unref(id)}`));
      const scopedHeadId = vue.computed(() => ns.b(`head-${vue.unref(id)}`));
      return {
        arrowKls,
        headKls,
        rootKls,
        itemWrapperKls,
        itemContentKls,
        scopedContentId,
        scopedHeadId
      };
    };
  
    const _hoisted_1$N = ["aria-expanded", "aria-controls", "aria-describedby"];
    const _hoisted_2$v = ["id", "tabindex"];
    const _hoisted_3$g = ["id", "aria-hidden", "aria-labelledby"];
    const __default__$X = vue.defineComponent({
      name: "ElCollapseItem"
    });
    const _sfc_main$1w = /* @__PURE__ */ vue.defineComponent({
      ...__default__$X,
      props: collapseItemProps,
      setup(__props, { expose }) {
        const props = __props;
        const {
          focusing,
          id,
          isActive,
          handleFocus,
          handleHeaderClick,
          handleEnterClick
        } = useCollapseItem(props);
        const {
          arrowKls,
          headKls,
          rootKls,
          itemWrapperKls,
          itemContentKls,
          scopedContentId,
          scopedHeadId
        } = useCollapseItemDOM(props, { focusing, isActive, id });
        expose({
          isActive
        });
        return (_ctx, _cache) => {
          return vue.openBlock(), vue.createElementBlock("div", {
            class: vue.normalizeClass(vue.unref(rootKls))
          }, [
            vue.createElementVNode("div", {
              role: "tab",
              "aria-expanded": vue.unref(isActive),
              "aria-controls": vue.unref(scopedContentId),
              "aria-describedby": vue.unref(scopedContentId)
            }, [
              vue.createElementVNode("div", {
                id: vue.unref(scopedHeadId),
                class: vue.normalizeClass(vue.unref(headKls)),
                role: "button",
                tabindex: _ctx.disabled ? -1 : 0,
                onClick: _cache[0] || (_cache[0] = (...args) => vue.unref(handleHeaderClick) && vue.unref(handleHeaderClick)(...args)),
                onKeypress: _cache[1] || (_cache[1] = vue.withKeys(vue.withModifiers((...args) => vue.unref(handleEnterClick) && vue.unref(handleEnterClick)(...args), ["stop", "prevent"]), ["space", "enter"])),
                onFocus: _cache[2] || (_cache[2] = (...args) => vue.unref(handleFocus) && vue.unref(handleFocus)(...args)),
                onBlur: _cache[3] || (_cache[3] = ($event) => focusing.value = false)
              }, [
                vue.renderSlot(_ctx.$slots, "title", {}, () => [
                  vue.createTextVNode(vue.toDisplayString(_ctx.title), 1)
                ]),
                vue.createVNode(vue.unref(ElIcon), {
                  class: vue.normalizeClass(vue.unref(arrowKls))
                }, {
                  default: vue.withCtx(() => [
                    vue.createVNode(vue.unref(arrow_right_default))
                  ]),
                  _: 1
                }, 8, ["class"])
              ], 42, _hoisted_2$v)
            ], 8, _hoisted_1$N),
            vue.createVNode(vue.unref(_CollapseTransition), null, {
              default: vue.withCtx(() => [
                vue.withDirectives(vue.createElementVNode("div", {
                  id: vue.unref(scopedContentId),
                  class: vue.normalizeClass(vue.unref(itemWrapperKls)),
                  role: "tabpanel",
                  "aria-hidden": !vue.unref(isActive),
                  "aria-labelledby": vue.unref(scopedHeadId)
                }, [
                  vue.createElementVNode("div", {
                    class: vue.normalizeClass(vue.unref(itemContentKls))
                  }, [
                    vue.renderSlot(_ctx.$slots, "default")
                  ], 2)
                ], 10, _hoisted_3$g), [
                  [vue.vShow, vue.unref(isActive)]
                ])
              ]),
              _: 3
            })
          ], 2);
        };
      }
    });
    var CollapseItem = /* @__PURE__ */ _export_sfc(_sfc_main$1w, [["__file", "collapse-item.vue"]]);
  
    const ElCollapse = withInstall(Collapse, {
      CollapseItem
    });
    const ElCollapseItem = withNoopInstall(CollapseItem);
  
    let isDragging = false;
    function draggable(element, options) {
      if (!isClient)
        return;
      const moveFn = function(event) {
        var _a;
        (_a = options.drag) == null ? void 0 : _a.call(options, event);
      };
      const upFn = function(event) {
        var _a;
        document.removeEventListener("mousemove", moveFn);
        document.removeEventListener("mouseup", upFn);
        document.removeEventListener("touchmove", moveFn);
        document.removeEventListener("touchend", upFn);
        document.onselectstart = null;
        document.ondragstart = null;
        isDragging = false;
        (_a = options.end) == null ? void 0 : _a.call(options, event);
      };
      const downFn = function(event) {
        var _a;
        if (isDragging)
          return;
        event.preventDefault();
        document.onselectstart = () => false;
        document.ondragstart = () => false;
        document.addEventListener("mousemove", moveFn);
        document.addEventListener("mouseup", upFn);
        document.addEventListener("touchmove", moveFn);
        document.addEventListener("touchend", upFn);
        isDragging = true;
        (_a = options.start) == null ? void 0 : _a.call(options, event);
      };
      element.addEventListener("mousedown", downFn);
      element.addEventListener("touchstart", downFn);
    }
  
    const _sfc_main$1v = vue.defineComponent({
      name: "ElColorAlphaSlider",
      props: {
        color: {
          type: Object,
          required: true
        },
        vertical: {
          type: Boolean,
          default: false
        }
      },
      setup(props) {
        const ns = useNamespace("color-alpha-slider");
        const instance = vue.getCurrentInstance();
        const thumb = vue.shallowRef();
        const bar = vue.shallowRef();
        const thumbLeft = vue.ref(0);
        const thumbTop = vue.ref(0);
        const background = vue.ref();
        vue.watch(() => props.color.get("alpha"), () => {
          update();
        });
        vue.watch(() => props.color.value, () => {
          update();
        });
        function getThumbLeft() {
          if (!thumb.value)
            return 0;
          if (props.vertical)
            return 0;
          const el = instance.vnode.el;
          const alpha = props.color.get("alpha");
          if (!el)
            return 0;
          return Math.round(alpha * (el.offsetWidth - thumb.value.offsetWidth / 2) / 100);
        }
        function getThumbTop() {
          if (!thumb.value)
            return 0;
          const el = instance.vnode.el;
          if (!props.vertical)
            return 0;
          const alpha = props.color.get("alpha");
          if (!el)
            return 0;
          return Math.round(alpha * (el.offsetHeight - thumb.value.offsetHeight / 2) / 100);
        }
        function getBackground() {
          if (props.color && props.color.value) {
            const { r, g, b } = props.color.toRgb();
            return `linear-gradient(to right, rgba(${r}, ${g}, ${b}, 0) 0%, rgba(${r}, ${g}, ${b}, 1) 100%)`;
          }
          return "";
        }
        function handleClick(event) {
          const target = event.target;
          if (target !== thumb.value) {
            handleDrag(event);
          }
        }
        function handleDrag(event) {
          if (!bar.value || !thumb.value)
            return;
          const el = instance.vnode.el;
          const rect = el.getBoundingClientRect();
          const { clientX, clientY } = getClientXY(event);
          if (!props.vertical) {
            let left = clientX - rect.left;
            left = Math.max(thumb.value.offsetWidth / 2, left);
            left = Math.min(left, rect.width - thumb.value.offsetWidth / 2);
            props.color.set("alpha", Math.round((left - thumb.value.offsetWidth / 2) / (rect.width - thumb.value.offsetWidth) * 100));
          } else {
            let top = clientY - rect.top;
            top = Math.max(thumb.value.offsetHeight / 2, top);
            top = Math.min(top, rect.height - thumb.value.offsetHeight / 2);
            props.color.set("alpha", Math.round((top - thumb.value.offsetHeight / 2) / (rect.height - thumb.value.offsetHeight) * 100));
          }
        }
        function update() {
          thumbLeft.value = getThumbLeft();
          thumbTop.value = getThumbTop();
          background.value = getBackground();
        }
        vue.onMounted(() => {
          if (!bar.value || !thumb.value)
            return;
          const dragConfig = {
            drag: (event) => {
              handleDrag(event);
            },
            end: (event) => {
              handleDrag(event);
            }
          };
          draggable(bar.value, dragConfig);
          draggable(thumb.value, dragConfig);
          update();
        });
        return {
          thumb,
          bar,
          thumbLeft,
          thumbTop,
          background,
          handleClick,
          update,
          ns
        };
      }
    });
    function _sfc_render$t(_ctx, _cache, $props, $setup, $data, $options) {
      return vue.openBlock(), vue.createElementBlock("div", {
        class: vue.normalizeClass([_ctx.ns.b(), _ctx.ns.is("vertical", _ctx.vertical)])
      }, [
        vue.createElementVNode("div", {
          ref: "bar",
          class: vue.normalizeClass(_ctx.ns.e("bar")),
          style: vue.normalizeStyle({
            background: _ctx.background
          }),
          onClick: _cache[0] || (_cache[0] = (...args) => _ctx.handleClick && _ctx.handleClick(...args))
        }, null, 6),
        vue.createElementVNode("div", {
          ref: "thumb",
          class: vue.normalizeClass(_ctx.ns.e("thumb")),
          style: vue.normalizeStyle({
            left: _ctx.thumbLeft + "px",
            top: _ctx.thumbTop + "px"
          })
        }, null, 6)
      ], 2);
    }
    var AlphaSlider = /* @__PURE__ */ _export_sfc(_sfc_main$1v, [["render", _sfc_render$t], ["__file", "alpha-slider.vue"]]);
  
    const _sfc_main$1u = vue.defineComponent({
      name: "ElColorHueSlider",
      props: {
        color: {
          type: Object,
          required: true
        },
        vertical: Boolean
      },
      setup(props) {
        const ns = useNamespace("color-hue-slider");
        const instance = vue.getCurrentInstance();
        const thumb = vue.ref();
        const bar = vue.ref();
        const thumbLeft = vue.ref(0);
        const thumbTop = vue.ref(0);
        const hueValue = vue.computed(() => {
          return props.color.get("hue");
        });
        vue.watch(() => hueValue.value, () => {
          update();
        });
        function handleClick(event) {
          const target = event.target;
          if (target !== thumb.value) {
            handleDrag(event);
          }
        }
        function handleDrag(event) {
          if (!bar.value || !thumb.value)
            return;
          const el = instance.vnode.el;
          const rect = el.getBoundingClientRect();
          const { clientX, clientY } = getClientXY(event);
          let hue;
          if (!props.vertical) {
            let left = clientX - rect.left;
            left = Math.min(left, rect.width - thumb.value.offsetWidth / 2);
            left = Math.max(thumb.value.offsetWidth / 2, left);
            hue = Math.round((left - thumb.value.offsetWidth / 2) / (rect.width - thumb.value.offsetWidth) * 360);
          } else {
            let top = clientY - rect.top;
            top = Math.min(top, rect.height - thumb.value.offsetHeight / 2);
            top = Math.max(thumb.value.offsetHeight / 2, top);
            hue = Math.round((top - thumb.value.offsetHeight / 2) / (rect.height - thumb.value.offsetHeight) * 360);
          }
          props.color.set("hue", hue);
        }
        function getThumbLeft() {
          if (!thumb.value)
            return 0;
          const el = instance.vnode.el;
          if (props.vertical)
            return 0;
          const hue = props.color.get("hue");
          if (!el)
            return 0;
          return Math.round(hue * (el.offsetWidth - thumb.value.offsetWidth / 2) / 360);
        }
        function getThumbTop() {
          if (!thumb.value)
            return 0;
          const el = instance.vnode.el;
          if (!props.vertical)
            return 0;
          const hue = props.color.get("hue");
          if (!el)
            return 0;
          return Math.round(hue * (el.offsetHeight - thumb.value.offsetHeight / 2) / 360);
        }
        function update() {
          thumbLeft.value = getThumbLeft();
          thumbTop.value = getThumbTop();
        }
        vue.onMounted(() => {
          if (!bar.value || !thumb.value)
            return;
          const dragConfig = {
            drag: (event) => {
              handleDrag(event);
            },
            end: (event) => {
              handleDrag(event);
            }
          };
          draggable(bar.value, dragConfig);
          draggable(thumb.value, dragConfig);
          update();
        });
        return {
          bar,
          thumb,
          thumbLeft,
          thumbTop,
          hueValue,
          handleClick,
          update,
          ns
        };
      }
    });
    function _sfc_render$s(_ctx, _cache, $props, $setup, $data, $options) {
      return vue.openBlock(), vue.createElementBlock("div", {
        class: vue.normalizeClass([_ctx.ns.b(), _ctx.ns.is("vertical", _ctx.vertical)])
      }, [
        vue.createElementVNode("div", {
          ref: "bar",
          class: vue.normalizeClass(_ctx.ns.e("bar")),
          onClick: _cache[0] || (_cache[0] = (...args) => _ctx.handleClick && _ctx.handleClick(...args))
        }, null, 2),
        vue.createElementVNode("div", {
          ref: "thumb",
          class: vue.normalizeClass(_ctx.ns.e("thumb")),
          style: vue.normalizeStyle({
            left: _ctx.thumbLeft + "px",
            top: _ctx.thumbTop + "px"
          })
        }, null, 6)
      ], 2);
    }
    var HueSlider = /* @__PURE__ */ _export_sfc(_sfc_main$1u, [["render", _sfc_render$s], ["__file", "hue-slider.vue"]]);
  
    const colorPickerProps = buildProps({
      modelValue: String,
      id: String,
      showAlpha: Boolean,
      colorFormat: String,
      disabled: Boolean,
      size: useSizeProp,
      popperClass: {
        type: String,
        default: ""
      },
      label: {
        type: String,
        default: void 0
      },
      tabindex: {
        type: [String, Number],
        default: 0
      },
      predefine: {
        type: definePropType(Array)
      },
      validateEvent: {
        type: Boolean,
        default: true
      }
    });
    const colorPickerEmits = {
      [UPDATE_MODEL_EVENT]: (val) => isString(val) || isNil(val),
      [CHANGE_EVENT]: (val) => isString(val) || isNil(val),
      activeChange: (val) => isString(val) || isNil(val)
    };
    const colorPickerContextKey = Symbol("colorPickerContextKey");
  
    const hsv2hsl = function(hue, sat, val) {
      return [
        hue,
        sat * val / ((hue = (2 - sat) * val) < 1 ? hue : 2 - hue) || 0,
        hue / 2
      ];
    };
    const isOnePointZero = function(n) {
      return typeof n === "string" && n.includes(".") && Number.parseFloat(n) === 1;
    };
    const isPercentage = function(n) {
      return typeof n === "string" && n.includes("%");
    };
    const bound01 = function(value, max) {
      if (isOnePointZero(value))
        value = "100%";
      const processPercent = isPercentage(value);
      value = Math.min(max, Math.max(0, Number.parseFloat(`${value}`)));
      if (processPercent) {
        value = Number.parseInt(`${value * max}`, 10) / 100;
      }
      if (Math.abs(value - max) < 1e-6) {
        return 1;
      }
      return value % max / Number.parseFloat(max);
    };
    const INT_HEX_MAP = {
      10: "A",
      11: "B",
      12: "C",
      13: "D",
      14: "E",
      15: "F"
    };
    const hexOne = (value) => {
      value = Math.min(Math.round(value), 255);
      const high = Math.floor(value / 16);
      const low = value % 16;
      return `${INT_HEX_MAP[high] || high}${INT_HEX_MAP[low] || low}`;
    };
    const toHex = function({ r, g, b }) {
      if (Number.isNaN(+r) || Number.isNaN(+g) || Number.isNaN(+b))
        return "";
      return `#${hexOne(r)}${hexOne(g)}${hexOne(b)}`;
    };
    const HEX_INT_MAP = {
      A: 10,
      B: 11,
      C: 12,
      D: 13,
      E: 14,
      F: 15
    };
    const parseHexChannel = function(hex) {
      if (hex.length === 2) {
        return (HEX_INT_MAP[hex[0].toUpperCase()] || +hex[0]) * 16 + (HEX_INT_MAP[hex[1].toUpperCase()] || +hex[1]);
      }
      return HEX_INT_MAP[hex[1].toUpperCase()] || +hex[1];
    };
    const hsl2hsv = function(hue, sat, light) {
      sat = sat / 100;
      light = light / 100;
      let smin = sat;
      const lmin = Math.max(light, 0.01);
      light *= 2;
      sat *= light <= 1 ? light : 2 - light;
      smin *= lmin <= 1 ? lmin : 2 - lmin;
      const v = (light + sat) / 2;
      const sv = light === 0 ? 2 * smin / (lmin + smin) : 2 * sat / (light + sat);
      return {
        h: hue,
        s: sv * 100,
        v: v * 100
      };
    };
    const rgb2hsv = (r, g, b) => {
      r = bound01(r, 255);
      g = bound01(g, 255);
      b = bound01(b, 255);
      const max = Math.max(r, g, b);
      const min = Math.min(r, g, b);
      let h;
      const v = max;
      const d = max - min;
      const s = max === 0 ? 0 : d / max;
      if (max === min) {
        h = 0;
      } else {
        switch (max) {
          case r: {
            h = (g - b) / d + (g < b ? 6 : 0);
            break;
          }
          case g: {
            h = (b - r) / d + 2;
            break;
          }
          case b: {
            h = (r - g) / d + 4;
            break;
          }
        }
        h /= 6;
      }
      return { h: h * 360, s: s * 100, v: v * 100 };
    };
    const hsv2rgb = function(h, s, v) {
      h = bound01(h, 360) * 6;
      s = bound01(s, 100);
      v = bound01(v, 100);
      const i = Math.floor(h);
      const f = h - i;
      const p = v * (1 - s);
      const q = v * (1 - f * s);
      const t = v * (1 - (1 - f) * s);
      const mod = i % 6;
      const r = [v, q, p, p, t, v][mod];
      const g = [t, v, v, q, p, p][mod];
      const b = [p, p, t, v, v, q][mod];
      return {
        r: Math.round(r * 255),
        g: Math.round(g * 255),
        b: Math.round(b * 255)
      };
    };
    class Color {
      constructor(options = {}) {
        this._hue = 0;
        this._saturation = 100;
        this._value = 100;
        this._alpha = 100;
        this.enableAlpha = false;
        this.format = "hex";
        this.value = "";
        for (const option in options) {
          if (hasOwn(options, option)) {
            this[option] = options[option];
          }
        }
        if (options.value) {
          this.fromString(options.value);
        } else {
          this.doOnChange();
        }
      }
      set(prop, value) {
        if (arguments.length === 1 && typeof prop === "object") {
          for (const p in prop) {
            if (hasOwn(prop, p)) {
              this.set(p, prop[p]);
            }
          }
          return;
        }
        this[`_${prop}`] = value;
        this.doOnChange();
      }
      get(prop) {
        if (prop === "alpha") {
          return Math.floor(this[`_${prop}`]);
        }
        return this[`_${prop}`];
      }
      toRgb() {
        return hsv2rgb(this._hue, this._saturation, this._value);
      }
      fromString(value) {
        if (!value) {
          this._hue = 0;
          this._saturation = 100;
          this._value = 100;
          this.doOnChange();
          return;
        }
        const fromHSV = (h, s, v) => {
          this._hue = Math.max(0, Math.min(360, h));
          this._saturation = Math.max(0, Math.min(100, s));
          this._value = Math.max(0, Math.min(100, v));
          this.doOnChange();
        };
        if (value.includes("hsl")) {
          const parts = value.replace(/hsla|hsl|\(|\)/gm, "").split(/\s|,/g).filter((val) => val !== "").map((val, index) => index > 2 ? Number.parseFloat(val) : Number.parseInt(val, 10));
          if (parts.length === 4) {
            this._alpha = Number.parseFloat(parts[3]) * 100;
          } else if (parts.length === 3) {
            this._alpha = 100;
          }
          if (parts.length >= 3) {
            const { h, s, v } = hsl2hsv(parts[0], parts[1], parts[2]);
            fromHSV(h, s, v);
          }
        } else if (value.includes("hsv")) {
          const parts = value.replace(/hsva|hsv|\(|\)/gm, "").split(/\s|,/g).filter((val) => val !== "").map((val, index) => index > 2 ? Number.parseFloat(val) : Number.parseInt(val, 10));
          if (parts.length === 4) {
            this._alpha = Number.parseFloat(parts[3]) * 100;
          } else if (parts.length === 3) {
            this._alpha = 100;
          }
          if (parts.length >= 3) {
            fromHSV(parts[0], parts[1], parts[2]);
          }
        } else if (value.includes("rgb")) {
          const parts = value.replace(/rgba|rgb|\(|\)/gm, "").split(/\s|,/g).filter((val) => val !== "").map((val, index) => index > 2 ? Number.parseFloat(val) : Number.parseInt(val, 10));
          if (parts.length === 4) {
            this._alpha = Number.parseFloat(parts[3]) * 100;
          } else if (parts.length === 3) {
            this._alpha = 100;
          }
          if (parts.length >= 3) {
            const { h, s, v } = rgb2hsv(parts[0], parts[1], parts[2]);
            fromHSV(h, s, v);
          }
        } else if (value.includes("#")) {
          const hex = value.replace("#", "").trim();
          if (!/^[0-9a-fA-F]{3}$|^[0-9a-fA-F]{6}$|^[0-9a-fA-F]{8}$/.test(hex))
            return;
          let r, g, b;
          if (hex.length === 3) {
            r = parseHexChannel(hex[0] + hex[0]);
            g = parseHexChannel(hex[1] + hex[1]);
            b = parseHexChannel(hex[2] + hex[2]);
          } else if (hex.length === 6 || hex.length === 8) {
            r = parseHexChannel(hex.slice(0, 2));
            g = parseHexChannel(hex.slice(2, 4));
            b = parseHexChannel(hex.slice(4, 6));
          }
          if (hex.length === 8) {
            this._alpha = parseHexChannel(hex.slice(6)) / 255 * 100;
          } else if (hex.length === 3 || hex.length === 6) {
            this._alpha = 100;
          }
          const { h, s, v } = rgb2hsv(r, g, b);
          fromHSV(h, s, v);
        }
      }
      compare(color) {
        return Math.abs(color._hue - this._hue) < 2 && Math.abs(color._saturation - this._saturation) < 1 && Math.abs(color._value - this._value) < 1 && Math.abs(color._alpha - this._alpha) < 1;
      }
      doOnChange() {
        const { _hue, _saturation, _value, _alpha, format } = this;
        if (this.enableAlpha) {
          switch (format) {
            case "hsl": {
              const hsl = hsv2hsl(_hue, _saturation / 100, _value / 100);
              this.value = `hsla(${_hue}, ${Math.round(hsl[1] * 100)}%, ${Math.round(hsl[2] * 100)}%, ${this.get("alpha") / 100})`;
              break;
            }
            case "hsv": {
              this.value = `hsva(${_hue}, ${Math.round(_saturation)}%, ${Math.round(_value)}%, ${this.get("alpha") / 100})`;
              break;
            }
            case "hex": {
              this.value = `${toHex(hsv2rgb(_hue, _saturation, _value))}${hexOne(_alpha * 255 / 100)}`;
              break;
            }
            default: {
              const { r, g, b } = hsv2rgb(_hue, _saturation, _value);
              this.value = `rgba(${r}, ${g}, ${b}, ${this.get("alpha") / 100})`;
            }
          }
        } else {
          switch (format) {
            case "hsl": {
              const hsl = hsv2hsl(_hue, _saturation / 100, _value / 100);
              this.value = `hsl(${_hue}, ${Math.round(hsl[1] * 100)}%, ${Math.round(hsl[2] * 100)}%)`;
              break;
            }
            case "hsv": {
              this.value = `hsv(${_hue}, ${Math.round(_saturation)}%, ${Math.round(_value)}%)`;
              break;
            }
            case "rgb": {
              const { r, g, b } = hsv2rgb(_hue, _saturation, _value);
              this.value = `rgb(${r}, ${g}, ${b})`;
              break;
            }
            default: {
              this.value = toHex(hsv2rgb(_hue, _saturation, _value));
            }
          }
        }
      }
    }
  
    const _sfc_main$1t = vue.defineComponent({
      props: {
        colors: {
          type: Array,
          required: true
        },
        color: {
          type: Object,
          required: true
        }
      },
      setup(props) {
        const ns = useNamespace("color-predefine");
        const { currentColor } = vue.inject(colorPickerContextKey);
        const rgbaColors = vue.ref(parseColors(props.colors, props.color));
        vue.watch(() => currentColor.value, (val) => {
          const color = new Color();
          color.fromString(val);
          rgbaColors.value.forEach((item) => {
            item.selected = color.compare(item);
          });
        });
        vue.watchEffect(() => {
          rgbaColors.value = parseColors(props.colors, props.color);
        });
        function handleSelect(index) {
          props.color.fromString(props.colors[index]);
        }
        function parseColors(colors, color) {
          return colors.map((value) => {
            const c = new Color();
            c.enableAlpha = true;
            c.format = "rgba";
            c.fromString(value);
            c.selected = c.value === color.value;
            return c;
          });
        }
        return {
          rgbaColors,
          handleSelect,
          ns
        };
      }
    });
    const _hoisted_1$M = ["onClick"];
    function _sfc_render$r(_ctx, _cache, $props, $setup, $data, $options) {
      return vue.openBlock(), vue.createElementBlock("div", {
        class: vue.normalizeClass(_ctx.ns.b())
      }, [
        vue.createElementVNode("div", {
          class: vue.normalizeClass(_ctx.ns.e("colors"))
        }, [
          (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(_ctx.rgbaColors, (item, index) => {
            return vue.openBlock(), vue.createElementBlock("div", {
              key: _ctx.colors[index],
              class: vue.normalizeClass([
                _ctx.ns.e("color-selector"),
                _ctx.ns.is("alpha", item._alpha < 100),
                { selected: item.selected }
              ]),
              onClick: ($event) => _ctx.handleSelect(index)
            }, [
              vue.createElementVNode("div", {
                style: vue.normalizeStyle({ backgroundColor: item.value })
              }, null, 4)
            ], 10, _hoisted_1$M);
          }), 128))
        ], 2)
      ], 2);
    }
    var Predefine = /* @__PURE__ */ _export_sfc(_sfc_main$1t, [["render", _sfc_render$r], ["__file", "predefine.vue"]]);
  
    const _sfc_main$1s = vue.defineComponent({
      name: "ElSlPanel",
      props: {
        color: {
          type: Object,
          required: true
        }
      },
      setup(props) {
        const ns = useNamespace("color-svpanel");
        const instance = vue.getCurrentInstance();
        const cursorTop = vue.ref(0);
        const cursorLeft = vue.ref(0);
        const background = vue.ref("hsl(0, 100%, 50%)");
        const colorValue = vue.computed(() => {
          const hue = props.color.get("hue");
          const value = props.color.get("value");
          return { hue, value };
        });
        function update() {
          const saturation = props.color.get("saturation");
          const value = props.color.get("value");
          const el = instance.vnode.el;
          const { clientWidth: width, clientHeight: height } = el;
          cursorLeft.value = saturation * width / 100;
          cursorTop.value = (100 - value) * height / 100;
          background.value = `hsl(${props.color.get("hue")}, 100%, 50%)`;
        }
        function handleDrag(event) {
          const el = instance.vnode.el;
          const rect = el.getBoundingClientRect();
          const { clientX, clientY } = getClientXY(event);
          let left = clientX - rect.left;
          let top = clientY - rect.top;
          left = Math.max(0, left);
          left = Math.min(left, rect.width);
          top = Math.max(0, top);
          top = Math.min(top, rect.height);
          cursorLeft.value = left;
          cursorTop.value = top;
          props.color.set({
            saturation: left / rect.width * 100,
            value: 100 - top / rect.height * 100
          });
        }
        vue.watch(() => colorValue.value, () => {
          update();
        });
        vue.onMounted(() => {
          draggable(instance.vnode.el, {
            drag: (event) => {
              handleDrag(event);
            },
            end: (event) => {
              handleDrag(event);
            }
          });
          update();
        });
        return {
          cursorTop,
          cursorLeft,
          background,
          colorValue,
          handleDrag,
          update,
          ns
        };
      }
    });
    const _hoisted_1$L = /* @__PURE__ */ vue.createElementVNode("div", null, null, -1);
    const _hoisted_2$u = [
      _hoisted_1$L
    ];
    function _sfc_render$q(_ctx, _cache, $props, $setup, $data, $options) {
      return vue.openBlock(), vue.createElementBlock("div", {
        class: vue.normalizeClass(_ctx.ns.b()),
        style: vue.normalizeStyle({
          backgroundColor: _ctx.background
        })
      }, [
        vue.createElementVNode("div", {
          class: vue.normalizeClass(_ctx.ns.e("white"))
        }, null, 2),
        vue.createElementVNode("div", {
          class: vue.normalizeClass(_ctx.ns.e("black"))
        }, null, 2),
        vue.createElementVNode("div", {
          class: vue.normalizeClass(_ctx.ns.e("cursor")),
          style: vue.normalizeStyle({
            top: _ctx.cursorTop + "px",
            left: _ctx.cursorLeft + "px"
          })
        }, _hoisted_2$u, 6)
      ], 6);
    }
    var SvPanel = /* @__PURE__ */ _export_sfc(_sfc_main$1s, [["render", _sfc_render$q], ["__file", "sv-panel.vue"]]);
  
    const _hoisted_1$K = ["id", "aria-label", "aria-labelledby", "aria-description", "tabindex", "onKeydown"];
    const __default__$W = vue.defineComponent({
      name: "ElColorPicker"
    });
    const _sfc_main$1r = /* @__PURE__ */ vue.defineComponent({
      ...__default__$W,
      props: colorPickerProps,
      emits: colorPickerEmits,
      setup(__props, { expose, emit }) {
        const props = __props;
        const { t } = useLocale();
        const ns = useNamespace("color");
        const { formItem } = useFormItem();
        const colorSize = useSize();
        const colorDisabled = useDisabled();
        const { inputId: buttonId, isLabeledByFormItem } = useFormItemInputId(props, {
          formItemContext: formItem
        });
        const hue = vue.ref();
        const sv = vue.ref();
        const alpha = vue.ref();
        const popper = vue.ref();
        let shouldActiveChange = true;
        const color = vue.reactive(new Color({
          enableAlpha: props.showAlpha,
          format: props.colorFormat || "",
          value: props.modelValue
        }));
        const showPicker = vue.ref(false);
        const showPanelColor = vue.ref(false);
        const customInput = vue.ref("");
        const displayedColor = vue.computed(() => {
          if (!props.modelValue && !showPanelColor.value) {
            return "transparent";
          }
          return displayedRgb(color, props.showAlpha);
        });
        const currentColor = vue.computed(() => {
          return !props.modelValue && !showPanelColor.value ? "" : color.value;
        });
        const buttonAriaLabel = vue.computed(() => {
          return !isLabeledByFormItem.value ? props.label || t("el.colorpicker.defaultLabel") : void 0;
        });
        const buttonAriaLabelledby = vue.computed(() => {
          return isLabeledByFormItem.value ? formItem == null ? void 0 : formItem.labelId : void 0;
        });
        function displayedRgb(color2, showAlpha) {
          if (!(color2 instanceof Color)) {
            throw new TypeError("color should be instance of _color Class");
          }
          const { r, g, b } = color2.toRgb();
          return showAlpha ? `rgba(${r}, ${g}, ${b}, ${color2.get("alpha") / 100})` : `rgb(${r}, ${g}, ${b})`;
        }
        function setShowPicker(value) {
          showPicker.value = value;
        }
        const debounceSetShowPicker = debounce(setShowPicker, 100);
        function hide() {
          debounceSetShowPicker(false);
          resetColor();
        }
        function resetColor() {
          vue.nextTick(() => {
            if (props.modelValue) {
              color.fromString(props.modelValue);
            } else {
              color.value = "";
              vue.nextTick(() => {
                showPanelColor.value = false;
              });
            }
          });
        }
        function handleTrigger() {
          if (colorDisabled.value)
            return;
          debounceSetShowPicker(!showPicker.value);
        }
        function handleConfirm() {
          color.fromString(customInput.value);
        }
        function confirmValue() {
          const value = color.value;
          emit(UPDATE_MODEL_EVENT, value);
          emit("change", value);
          if (props.validateEvent) {
            formItem == null ? void 0 : formItem.validate("change").catch((err) => debugWarn());
          }
          debounceSetShowPicker(false);
          vue.nextTick(() => {
            const newColor = new Color({
              enableAlpha: props.showAlpha,
              format: props.colorFormat || "",
              value: props.modelValue
            });
            if (!color.compare(newColor)) {
              resetColor();
            }
          });
        }
        function clear() {
          debounceSetShowPicker(false);
          emit(UPDATE_MODEL_EVENT, null);
          emit("change", null);
          if (props.modelValue !== null && props.validateEvent) {
            formItem == null ? void 0 : formItem.validate("change").catch((err) => debugWarn());
          }
          resetColor();
        }
        vue.onMounted(() => {
          if (props.modelValue) {
            customInput.value = currentColor.value;
          }
        });
        vue.watch(() => props.modelValue, (newVal) => {
          if (!newVal) {
            showPanelColor.value = false;
          } else if (newVal && newVal !== color.value) {
            shouldActiveChange = false;
            color.fromString(newVal);
          }
        });
        vue.watch(() => currentColor.value, (val) => {
          customInput.value = val;
          shouldActiveChange && emit("activeChange", val);
          shouldActiveChange = true;
        });
        vue.watch(() => color.value, () => {
          if (!props.modelValue && !showPanelColor.value) {
            showPanelColor.value = true;
          }
        });
        vue.watch(() => showPicker.value, () => {
          vue.nextTick(() => {
            var _a, _b, _c;
            (_a = hue.value) == null ? void 0 : _a.update();
            (_b = sv.value) == null ? void 0 : _b.update();
            (_c = alpha.value) == null ? void 0 : _c.update();
          });
        });
        vue.provide(colorPickerContextKey, {
          currentColor
        });
        expose({
          color
        });
        return (_ctx, _cache) => {
          return vue.openBlock(), vue.createBlock(vue.unref(ElTooltip), {
            ref_key: "popper",
            ref: popper,
            visible: showPicker.value,
            "show-arrow": false,
            "fallback-placements": ["bottom", "top", "right", "left"],
            offset: 0,
            "gpu-acceleration": false,
            "popper-class": [vue.unref(ns).be("picker", "panel"), vue.unref(ns).b("dropdown"), _ctx.popperClass],
            "stop-popper-mouse-event": false,
            effect: "light",
            trigger: "click",
            transition: `${vue.unref(ns).namespace.value}-zoom-in-top`,
            persistent: ""
          }, {
            content: vue.withCtx(() => [
              vue.withDirectives((vue.openBlock(), vue.createElementBlock("div", null, [
                vue.createElementVNode("div", {
                  class: vue.normalizeClass(vue.unref(ns).be("dropdown", "main-wrapper"))
                }, [
                  vue.createVNode(HueSlider, {
                    ref_key: "hue",
                    ref: hue,
                    class: "hue-slider",
                    color: vue.unref(color),
                    vertical: ""
                  }, null, 8, ["color"]),
                  vue.createVNode(SvPanel, {
                    ref: "svPanel",
                    color: vue.unref(color)
                  }, null, 8, ["color"])
                ], 2),
                _ctx.showAlpha ? (vue.openBlock(), vue.createBlock(AlphaSlider, {
                  key: 0,
                  ref_key: "alpha",
                  ref: alpha,
                  color: vue.unref(color)
                }, null, 8, ["color"])) : vue.createCommentVNode("v-if", true),
                _ctx.predefine ? (vue.openBlock(), vue.createBlock(Predefine, {
                  key: 1,
                  ref: "predefine",
                  color: vue.unref(color),
                  colors: _ctx.predefine
                }, null, 8, ["color", "colors"])) : vue.createCommentVNode("v-if", true),
                vue.createElementVNode("div", {
                  class: vue.normalizeClass(vue.unref(ns).be("dropdown", "btns"))
                }, [
                  vue.createElementVNode("span", {
                    class: vue.normalizeClass(vue.unref(ns).be("dropdown", "value"))
                  }, [
                    vue.createVNode(vue.unref(ElInput), {
                      modelValue: customInput.value,
                      "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => customInput.value = $event),
                      "validate-event": false,
                      size: "small",
                      onKeyup: vue.withKeys(handleConfirm, ["enter"]),
                      onBlur: handleConfirm
                    }, null, 8, ["modelValue", "onKeyup"])
                  ], 2),
                  vue.createVNode(vue.unref(ElButton), {
                    class: vue.normalizeClass(vue.unref(ns).be("dropdown", "link-btn")),
                    text: "",
                    size: "small",
                    onClick: clear
                  }, {
                    default: vue.withCtx(() => [
                      vue.createTextVNode(vue.toDisplayString(vue.unref(t)("el.colorpicker.clear")), 1)
                    ]),
                    _: 1
                  }, 8, ["class"]),
                  vue.createVNode(vue.unref(ElButton), {
                    plain: "",
                    size: "small",
                    class: vue.normalizeClass(vue.unref(ns).be("dropdown", "btn")),
                    onClick: confirmValue
                  }, {
                    default: vue.withCtx(() => [
                      vue.createTextVNode(vue.toDisplayString(vue.unref(t)("el.colorpicker.confirm")), 1)
                    ]),
                    _: 1
                  }, 8, ["class"])
                ], 2)
              ])), [
                [vue.unref(ClickOutside), hide]
              ])
            ]),
            default: vue.withCtx(() => [
              vue.createElementVNode("div", {
                id: vue.unref(buttonId),
                class: vue.normalizeClass([
                  vue.unref(ns).b("picker"),
                  vue.unref(ns).is("disabled", vue.unref(colorDisabled)),
                  vue.unref(ns).bm("picker", vue.unref(colorSize))
                ]),
                role: "button",
                "aria-label": vue.unref(buttonAriaLabel),
                "aria-labelledby": vue.unref(buttonAriaLabelledby),
                "aria-description": vue.unref(t)("el.colorpicker.description", { color: _ctx.modelValue || "" }),
                tabindex: _ctx.tabindex,
                onKeydown: vue.withKeys(handleTrigger, ["enter"])
              }, [
                vue.unref(colorDisabled) ? (vue.openBlock(), vue.createElementBlock("div", {
                  key: 0,
                  class: vue.normalizeClass(vue.unref(ns).be("picker", "mask"))
                }, null, 2)) : vue.createCommentVNode("v-if", true),
                vue.createElementVNode("div", {
                  class: vue.normalizeClass(vue.unref(ns).be("picker", "trigger")),
                  onClick: handleTrigger
                }, [
                  vue.createElementVNode("span", {
                    class: vue.normalizeClass([vue.unref(ns).be("picker", "color"), vue.unref(ns).is("alpha", _ctx.showAlpha)])
                  }, [
                    vue.createElementVNode("span", {
                      class: vue.normalizeClass(vue.unref(ns).be("picker", "color-inner")),
                      style: vue.normalizeStyle({
                        backgroundColor: vue.unref(displayedColor)
                      })
                    }, [
                      vue.withDirectives(vue.createVNode(vue.unref(ElIcon), {
                        class: vue.normalizeClass([vue.unref(ns).be("picker", "icon"), vue.unref(ns).is("icon-arrow-down")])
                      }, {
                        default: vue.withCtx(() => [
                          vue.createVNode(vue.unref(arrow_down_default))
                        ]),
                        _: 1
                      }, 8, ["class"]), [
                        [vue.vShow, _ctx.modelValue || showPanelColor.value]
                      ]),
                      !_ctx.modelValue && !showPanelColor.value ? (vue.openBlock(), vue.createBlock(vue.unref(ElIcon), {
                        key: 0,
                        class: vue.normalizeClass([vue.unref(ns).be("picker", "empty"), vue.unref(ns).is("icon-close")])
                      }, {
                        default: vue.withCtx(() => [
                          vue.createVNode(vue.unref(close_default))
                        ]),
                        _: 1
                      }, 8, ["class"])) : vue.createCommentVNode("v-if", true)
                    ], 6)
                  ], 2)
                ], 2)
              ], 42, _hoisted_1$K)
            ]),
            _: 1
          }, 8, ["visible", "popper-class", "transition"]);
        };
      }
    });
    var ColorPicker = /* @__PURE__ */ _export_sfc(_sfc_main$1r, [["__file", "color-picker.vue"]]);
  
    const ElColorPicker = withInstall(ColorPicker);
  
    const messageConfig = {};
    const configProviderProps = buildProps({
      a11y: {
        type: Boolean,
        default: true
      },
      locale: {
        type: definePropType(Object)
      },
      size: useSizeProp,
      button: {
        type: definePropType(Object)
      },
      experimentalFeatures: {
        type: definePropType(Object)
      },
      keyboardNavigation: {
        type: Boolean,
        default: true
      },
      message: {
        type: definePropType(Object)
      },
      zIndex: Number,
      namespace: {
        type: String,
        default: "el"
      }
    });
    const ConfigProvider = vue.defineComponent({
      name: "ElConfigProvider",
      props: configProviderProps,
      setup(props, { slots }) {
        vue.watch(() => props.message, (val) => {
          Object.assign(messageConfig, val != null ? val : {});
        }, { immediate: true, deep: true });
        const config = provideGlobalConfig(props);
        return () => vue.renderSlot(slots, "default", { config: config == null ? void 0 : config.value });
      }
    });
  
    const ElConfigProvider = withInstall(ConfigProvider);
  
    const __default__$V = vue.defineComponent({
      name: "ElContainer"
    });
    const _sfc_main$1q = /* @__PURE__ */ vue.defineComponent({
      ...__default__$V,
      props: {
        direction: {
          type: String
        }
      },
      setup(__props) {
        const props = __props;
        const slots = vue.useSlots();
        const ns = useNamespace("container");
        const isVertical = vue.computed(() => {
          if (props.direction === "vertical") {
            return true;
          } else if (props.direction === "horizontal") {
            return false;
          }
          if (slots && slots.default) {
            const vNodes = slots.default();
            return vNodes.some((vNode) => {
              const tag = vNode.type.name;
              return tag === "ElHeader" || tag === "ElFooter";
            });
          } else {
            return false;
          }
        });
        return (_ctx, _cache) => {
          return vue.openBlock(), vue.createElementBlock("section", {
            class: vue.normalizeClass([vue.unref(ns).b(), vue.unref(ns).is("vertical", vue.unref(isVertical))])
          }, [
            vue.renderSlot(_ctx.$slots, "default")
          ], 2);
        };
      }
    });
    var Container = /* @__PURE__ */ _export_sfc(_sfc_main$1q, [["__file", "container.vue"]]);
  
    const __default__$U = vue.defineComponent({
      name: "ElAside"
    });
    const _sfc_main$1p = /* @__PURE__ */ vue.defineComponent({
      ...__default__$U,
      props: {
        width: {
          type: String,
          default: null
        }
      },
      setup(__props) {
        const props = __props;
        const ns = useNamespace("aside");
        const style = vue.computed(() => props.width ? ns.cssVarBlock({ width: props.width }) : {});
        return (_ctx, _cache) => {
          return vue.openBlock(), vue.createElementBlock("aside", {
            class: vue.normalizeClass(vue.unref(ns).b()),
            style: vue.normalizeStyle(vue.unref(style))
          }, [
            vue.renderSlot(_ctx.$slots, "default")
          ], 6);
        };
      }
    });
    var Aside = /* @__PURE__ */ _export_sfc(_sfc_main$1p, [["__file", "aside.vue"]]);
  
    const __default__$T = vue.defineComponent({
      name: "ElFooter"
    });
    const _sfc_main$1o = /* @__PURE__ */ vue.defineComponent({
      ...__default__$T,
      props: {
        height: {
          type: String,
          default: null
        }
      },
      setup(__props) {
        const props = __props;
        const ns = useNamespace("footer");
        const style = vue.computed(() => props.height ? ns.cssVarBlock({ height: props.height }) : {});
        return (_ctx, _cache) => {
          return vue.openBlock(), vue.createElementBlock("footer", {
            class: vue.normalizeClass(vue.unref(ns).b()),
            style: vue.normalizeStyle(vue.unref(style))
          }, [
            vue.renderSlot(_ctx.$slots, "default")
          ], 6);
        };
      }
    });
    var Footer$2 = /* @__PURE__ */ _export_sfc(_sfc_main$1o, [["__file", "footer.vue"]]);
  
    const __default__$S = vue.defineComponent({
      name: "ElHeader"
    });
    const _sfc_main$1n = /* @__PURE__ */ vue.defineComponent({
      ...__default__$S,
      props: {
        height: {
          type: String,
          default: null
        }
      },
      setup(__props) {
        const props = __props;
        const ns = useNamespace("header");
        const style = vue.computed(() => {
          return props.height ? ns.cssVarBlock({
            height: props.height
          }) : {};
        });
        return (_ctx, _cache) => {
          return vue.openBlock(), vue.createElementBlock("header", {
            class: vue.normalizeClass(vue.unref(ns).b()),
            style: vue.normalizeStyle(vue.unref(style))
          }, [
            vue.renderSlot(_ctx.$slots, "default")
          ], 6);
        };
      }
    });
    var Header$1 = /* @__PURE__ */ _export_sfc(_sfc_main$1n, [["__file", "header.vue"]]);
  
    const __default__$R = vue.defineComponent({
      name: "ElMain"
    });
    const _sfc_main$1m = /* @__PURE__ */ vue.defineComponent({
      ...__default__$R,
      setup(__props) {
        const ns = useNamespace("main");
        return (_ctx, _cache) => {
          return vue.openBlock(), vue.createElementBlock("main", {
            class: vue.normalizeClass(vue.unref(ns).b())
          }, [
            vue.renderSlot(_ctx.$slots, "default")
          ], 2);
        };
      }
    });
    var Main = /* @__PURE__ */ _export_sfc(_sfc_main$1m, [["__file", "main.vue"]]);
  
    const ElContainer = withInstall(Container, {
      Aside,
      Footer: Footer$2,
      Header: Header$1,
      Main
    });
    const ElAside = withNoopInstall(Aside);
    const ElFooter = withNoopInstall(Footer$2);
    const ElHeader = withNoopInstall(Header$1);
    const ElMain = withNoopInstall(Main);
  
    var advancedFormat$1 = {exports: {}};
  
    (function(module, exports) {
      !function(e, t) {
        module.exports = t() ;
      }(commonjsGlobal, function() {
        return function(e, t, r) {
          var n = t.prototype, s = n.format;
          r.en.ordinal = function(e2) {
            var t2 = ["th", "st", "nd", "rd"], r2 = e2 % 100;
            return "[" + e2 + (t2[(r2 - 20) % 10] || t2[r2] || t2[0]) + "]";
          }, n.format = function(e2) {
            var t2 = this, r2 = this.$locale();
            if (!this.isValid())
              return s.bind(this)(e2);
            var n2 = this.$utils(), a = (e2 || "YYYY-MM-DDTHH:mm:ssZ").replace(/\[([^\]]+)]|Q|wo|ww|w|WW|W|zzz|z|gggg|GGGG|Do|X|x|k{1,2}|S/g, function(e3) {
              switch (e3) {
                case "Q":
                  return Math.ceil((t2.$M + 1) / 3);
                case "Do":
                  return r2.ordinal(t2.$D);
                case "gggg":
                  return t2.weekYear();
                case "GGGG":
                  return t2.isoWeekYear();
                case "wo":
                  return r2.ordinal(t2.week(), "W");
                case "w":
                case "ww":
                  return n2.s(t2.week(), e3 === "w" ? 1 : 2, "0");
                case "W":
                case "WW":
                  return n2.s(t2.isoWeek(), e3 === "W" ? 1 : 2, "0");
                case "k":
                case "kk":
                  return n2.s(String(t2.$H === 0 ? 24 : t2.$H), e3 === "k" ? 1 : 2, "0");
                case "X":
                  return Math.floor(t2.$d.getTime() / 1e3);
                case "x":
                  return t2.$d.getTime();
                case "z":
                  return "[" + t2.offsetName() + "]";
                case "zzz":
                  return "[" + t2.offsetName("long") + "]";
                default:
                  return e3;
              }
            });
            return s.bind(this)(a);
          };
        };
      });
    })(advancedFormat$1);
    var advancedFormat = advancedFormat$1.exports;
  
    var weekOfYear$1 = {exports: {}};
  
    (function(module, exports) {
      !function(e, t) {
        module.exports = t() ;
      }(commonjsGlobal, function() {
        var e = "week", t = "year";
        return function(i, n, r) {
          var f = n.prototype;
          f.week = function(i2) {
            if (i2 === void 0 && (i2 = null), i2 !== null)
              return this.add(7 * (i2 - this.week()), "day");
            var n2 = this.$locale().yearStart || 1;
            if (this.month() === 11 && this.date() > 25) {
              var f2 = r(this).startOf(t).add(1, t).date(n2), s = r(this).endOf(e);
              if (f2.isBefore(s))
                return 1;
            }
            var a = r(this).startOf(t).date(n2).startOf(e).subtract(1, "millisecond"), o = this.diff(a, e, true);
            return o < 0 ? r(this).startOf("week").week() : Math.ceil(o);
          }, f.weeks = function(e2) {
            return e2 === void 0 && (e2 = null), this.week(e2);
          };
        };
      });
    })(weekOfYear$1);
    var weekOfYear = weekOfYear$1.exports;
  
    var weekYear$1 = {exports: {}};
  
    (function(module, exports) {
      !function(e, t) {
        module.exports = t() ;
      }(commonjsGlobal, function() {
        return function(e, t) {
          t.prototype.weekYear = function() {
            var e2 = this.month(), t2 = this.week(), n = this.year();
            return t2 === 1 && e2 === 11 ? n + 1 : e2 === 0 && t2 >= 52 ? n - 1 : n;
          };
        };
      });
    })(weekYear$1);
    var weekYear = weekYear$1.exports;
  
    var dayOfYear$1 = {exports: {}};
  
    (function(module, exports) {
      !function(e, t) {
        module.exports = t() ;
      }(commonjsGlobal, function() {
        return function(e, t, n) {
          t.prototype.dayOfYear = function(e2) {
            var t2 = Math.round((n(this).startOf("day") - n(this).startOf("year")) / 864e5) + 1;
            return e2 == null ? t2 : this.add(e2 - t2, "day");
          };
        };
      });
    })(dayOfYear$1);
    var dayOfYear = dayOfYear$1.exports;
  
    var isSameOrAfter$1 = {exports: {}};
  
    (function(module, exports) {
      !function(e, t) {
        module.exports = t() ;
      }(commonjsGlobal, function() {
        return function(e, t) {
          t.prototype.isSameOrAfter = function(e2, t2) {
            return this.isSame(e2, t2) || this.isAfter(e2, t2);
          };
        };
      });
    })(isSameOrAfter$1);
    var isSameOrAfter = isSameOrAfter$1.exports;
  
    var isSameOrBefore$1 = {exports: {}};
  
    (function(module, exports) {
      !function(e, i) {
        module.exports = i() ;
      }(commonjsGlobal, function() {
        return function(e, i) {
          i.prototype.isSameOrBefore = function(e2, i2) {
            return this.isSame(e2, i2) || this.isBefore(e2, i2);
          };
        };
      });
    })(isSameOrBefore$1);
    var isSameOrBefore = isSameOrBefore$1.exports;
  
    const datePickerProps = buildProps({
      type: {
        type: definePropType(String),
        default: "date"
      }
    });
  
    const selectionModes = ["date", "dates", "year", "month", "week", "range"];
    const datePickerSharedProps = buildProps({
      disabledDate: {
        type: definePropType(Function)
      },
      date: {
        type: definePropType(Object),
        required: true
      },
      minDate: {
        type: definePropType(Object)
      },
      maxDate: {
        type: definePropType(Object)
      },
      parsedValue: {
        type: definePropType([Object, Array])
      },
      rangeState: {
        type: definePropType(Object),
        default: () => ({
          endDate: null,
          selecting: false
        })
      }
    });
    const panelSharedProps = buildProps({
      type: {
        type: definePropType(String),
        required: true,
        values: datePickTypes
      }
    });
    const panelRangeSharedProps = buildProps({
      unlinkPanels: Boolean,
      parsedValue: {
        type: definePropType(Array)
      }
    });
    const selectionModeWithDefault = (mode) => {
      return {
        type: String,
        values: selectionModes,
        default: mode
      };
    };
  
    const panelDatePickProps = buildProps({
      ...panelSharedProps,
      parsedValue: {
        type: definePropType([Object, Array])
      },
      visible: {
        type: Boolean
      },
      format: {
        type: String,
        default: ""
      }
    });
  
    const basicDateTableProps = buildProps({
      ...datePickerSharedProps,
      cellClassName: {
        type: definePropType(Function)
      },
      showWeekNumber: Boolean,
      selectionMode: selectionModeWithDefault("date")
    });
  
    const isValidRange = (range) => {
      if (!isArray(range))
        return false;
      const [left, right] = range;
      return dayjs.isDayjs(left) && dayjs.isDayjs(right) && left.isSameOrBefore(right);
    };
    const getDefaultValue = (defaultValue, { lang, unit, unlinkPanels }) => {
      let start;
      if (isArray(defaultValue)) {
        let [left, right] = defaultValue.map((d) => dayjs(d).locale(lang));
        if (!unlinkPanels) {
          right = left.add(1, unit);
        }
        return [left, right];
      } else if (defaultValue) {
        start = dayjs(defaultValue);
      } else {
        start = dayjs();
      }
      start = start.locale(lang);
      return [start, start.add(1, unit)];
    };
    const buildPickerTable = (dimension, rows, {
      columnIndexOffset,
      startDate,
      nextEndDate,
      now,
      unit,
      relativeDateGetter,
      setCellMetadata,
      setRowMetadata
    }) => {
      for (let rowIndex = 0; rowIndex < dimension.row; rowIndex++) {
        const row = rows[rowIndex];
        for (let columnIndex = 0; columnIndex < dimension.column; columnIndex++) {
          let cell = row[columnIndex + columnIndexOffset];
          if (!cell) {
            cell = {
              row: rowIndex,
              column: columnIndex,
              type: "normal",
              inRange: false,
              start: false,
              end: false
            };
          }
          const index = rowIndex * dimension.column + columnIndex;
          const nextStartDate = relativeDateGetter(index);
          cell.dayjs = nextStartDate;
          cell.date = nextStartDate.toDate();
          cell.timestamp = nextStartDate.valueOf();
          cell.type = "normal";
          cell.inRange = !!(startDate && nextStartDate.isSameOrAfter(startDate, unit) && nextEndDate && nextStartDate.isSameOrBefore(nextEndDate, unit)) || !!(startDate && nextStartDate.isSameOrBefore(startDate, unit) && nextEndDate && nextStartDate.isSameOrAfter(nextEndDate, unit));
          if (startDate == null ? void 0 : startDate.isSameOrAfter(nextEndDate)) {
            cell.start = !!nextEndDate && nextStartDate.isSame(nextEndDate, unit);
            cell.end = startDate && nextStartDate.isSame(startDate, unit);
          } else {
            cell.start = !!startDate && nextStartDate.isSame(startDate, unit);
            cell.end = !!nextEndDate && nextStartDate.isSame(nextEndDate, unit);
          }
          const isToday = nextStartDate.isSame(now, unit);
          if (isToday) {
            cell.type = "today";
          }
          setCellMetadata == null ? void 0 : setCellMetadata(cell, { rowIndex, columnIndex });
          row[columnIndex + columnIndexOffset] = cell;
        }
        setRowMetadata == null ? void 0 : setRowMetadata(row);
      }
    };
  
    const basicCellProps = buildProps({
      cell: {
        type: definePropType(Object)
      }
    });
  
    var ElDatePickerCell = vue.defineComponent({
      name: "ElDatePickerCell",
      props: basicCellProps,
      setup(props) {
        const ns = useNamespace("date-table-cell");
        const {
          slots
        } = vue.inject(ROOT_PICKER_INJECTION_KEY);
        return () => {
          const {
            cell
          } = props;
          if (slots.default) {
            const list = slots.default(cell).filter((item) => {
              return item.patchFlag !== -2 && item.type.toString() !== "Symbol(Comment)";
            });
            if (list.length) {
              return list;
            }
          }
          return vue.createVNode("div", {
            "class": ns.b()
          }, [vue.createVNode("span", {
            "class": ns.e("text")
          }, [cell == null ? void 0 : cell.text])]);
        };
      }
    });
  
    const _hoisted_1$J = ["aria-label"];
    const _hoisted_2$t = {
      key: 0,
      scope: "col"
    };
    const _hoisted_3$f = ["aria-label"];
    const _hoisted_4$b = ["aria-current", "aria-selected", "tabindex"];
    const _sfc_main$1l = /* @__PURE__ */ vue.defineComponent({
      __name: "basic-date-table",
      props: basicDateTableProps,
      emits: ["changerange", "pick", "select"],
      setup(__props, { expose, emit }) {
        const props = __props;
        const ns = useNamespace("date-table");
        const { t, lang } = useLocale();
        const tbodyRef = vue.ref();
        const currentCellRef = vue.ref();
        const lastRow = vue.ref();
        const lastColumn = vue.ref();
        const tableRows = vue.ref([[], [], [], [], [], []]);
        let focusWithClick = false;
        const firstDayOfWeek = props.date.$locale().weekStart || 7;
        const WEEKS_CONSTANT = props.date.locale("en").localeData().weekdaysShort().map((_) => _.toLowerCase());
        const offsetDay = vue.computed(() => {
          return firstDayOfWeek > 3 ? 7 - firstDayOfWeek : -firstDayOfWeek;
        });
        const startDate = vue.computed(() => {
          const startDayOfMonth = props.date.startOf("month");
          return startDayOfMonth.subtract(startDayOfMonth.day() || 7, "day");
        });
        const WEEKS = vue.computed(() => {
          return WEEKS_CONSTANT.concat(WEEKS_CONSTANT).slice(firstDayOfWeek, firstDayOfWeek + 7);
        });
        const hasCurrent = vue.computed(() => {
          return flatten(rows.value).some((row) => {
            return row.isCurrent;
          });
        });
        const days = vue.computed(() => {
          const startOfMonth = props.date.startOf("month");
          const startOfMonthDay = startOfMonth.day() || 7;
          const dateCountOfMonth = startOfMonth.daysInMonth();
          const dateCountOfLastMonth = startOfMonth.subtract(1, "month").daysInMonth();
          return {
            startOfMonthDay,
            dateCountOfMonth,
            dateCountOfLastMonth
          };
        });
        const selectedDate = vue.computed(() => {
          return props.selectionMode === "dates" ? castArray(props.parsedValue) : [];
        });
        const setDateText = (cell, {
          count,
          rowIndex,
          columnIndex
        }) => {
          const { startOfMonthDay, dateCountOfMonth, dateCountOfLastMonth } = vue.unref(days);
          const offset = vue.unref(offsetDay);
          if (rowIndex >= 0 && rowIndex <= 1) {
            const numberOfDaysFromPreviousMonth = startOfMonthDay + offset < 0 ? 7 + startOfMonthDay + offset : startOfMonthDay + offset;
            if (columnIndex + rowIndex * 7 >= numberOfDaysFromPreviousMonth) {
              cell.text = count;
              return true;
            } else {
              cell.text = dateCountOfLastMonth - (numberOfDaysFromPreviousMonth - columnIndex % 7) + 1 + rowIndex * 7;
              cell.type = "prev-month";
            }
          } else {
            if (count <= dateCountOfMonth) {
              cell.text = count;
            } else {
              cell.text = count - dateCountOfMonth;
              cell.type = "next-month";
            }
            return true;
          }
          return false;
        };
        const setCellMetadata = (cell, {
          columnIndex,
          rowIndex
        }, count) => {
          const { disabledDate, cellClassName } = props;
          const _selectedDate = vue.unref(selectedDate);
          const shouldIncrement = setDateText(cell, { count, rowIndex, columnIndex });
          const cellDate = cell.dayjs.toDate();
          cell.selected = _selectedDate.find((d) => d.valueOf() === cell.dayjs.valueOf());
          cell.isSelected = !!cell.selected;
          cell.isCurrent = isCurrent(cell);
          cell.disabled = disabledDate == null ? void 0 : disabledDate(cellDate);
          cell.customClass = cellClassName == null ? void 0 : cellClassName(cellDate);
          return shouldIncrement;
        };
        const setRowMetadata = (row) => {
          if (props.selectionMode === "week") {
            const [start, end] = props.showWeekNumber ? [1, 7] : [0, 6];
            const isActive = isWeekActive(row[start + 1]);
            row[start].inRange = isActive;
            row[start].start = isActive;
            row[end].inRange = isActive;
            row[end].end = isActive;
          }
        };
        const rows = vue.computed(() => {
          const { minDate, maxDate, rangeState, showWeekNumber } = props;
          const offset = offsetDay.value;
          const rows_ = tableRows.value;
          const dateUnit = "day";
          let count = 1;
          if (showWeekNumber) {
            for (let rowIndex = 0; rowIndex < 6; rowIndex++) {
              if (!rows_[rowIndex][0]) {
                rows_[rowIndex][0] = {
                  type: "week",
                  text: startDate.value.add(rowIndex * 7 + 1, dateUnit).week()
                };
              }
            }
          }
          buildPickerTable({ row: 6, column: 7 }, rows_, {
            startDate: minDate,
            columnIndexOffset: showWeekNumber ? 1 : 0,
            nextEndDate: rangeState.endDate || maxDate || rangeState.selecting && minDate || null,
            now: dayjs().locale(vue.unref(lang)).startOf(dateUnit),
            unit: dateUnit,
            relativeDateGetter: (idx) => startDate.value.add(idx - offset, dateUnit),
            setCellMetadata: (...args) => {
              if (setCellMetadata(...args, count)) {
                count += 1;
              }
            },
            setRowMetadata
          });
          return rows_;
        });
        vue.watch(() => props.date, async () => {
          var _a, _b;
          if ((_a = tbodyRef.value) == null ? void 0 : _a.contains(document.activeElement)) {
            await vue.nextTick();
            (_b = currentCellRef.value) == null ? void 0 : _b.focus();
          }
        });
        const focus = async () => {
          var _a;
          (_a = currentCellRef.value) == null ? void 0 : _a.focus();
        };
        const isNormalDay = (type = "") => {
          return ["normal", "today"].includes(type);
        };
        const isCurrent = (cell) => {
          return props.selectionMode === "date" && isNormalDay(cell.type) && cellMatchesDate(cell, props.parsedValue);
        };
        const cellMatchesDate = (cell, date) => {
          if (!date)
            return false;
          return dayjs(date).locale(lang.value).isSame(props.date.date(Number(cell.text)), "day");
        };
        const getCellClasses = (cell) => {
          const classes = [];
          if (isNormalDay(cell.type) && !cell.disabled) {
            classes.push("available");
            if (cell.type === "today") {
              classes.push("today");
            }
          } else {
            classes.push(cell.type);
          }
          if (isCurrent(cell)) {
            classes.push("current");
          }
          if (cell.inRange && (isNormalDay(cell.type) || props.selectionMode === "week")) {
            classes.push("in-range");
            if (cell.start) {
              classes.push("start-date");
            }
            if (cell.end) {
              classes.push("end-date");
            }
          }
          if (cell.disabled) {
            classes.push("disabled");
          }
          if (cell.selected) {
            classes.push("selected");
          }
          if (cell.customClass) {
            classes.push(cell.customClass);
          }
          return classes.join(" ");
        };
        const getDateOfCell = (row, column) => {
          const offsetFromStart = row * 7 + (column - (props.showWeekNumber ? 1 : 0)) - offsetDay.value;
          return startDate.value.add(offsetFromStart, "day");
        };
        const handleMouseMove = (event) => {
          var _a;
          if (!props.rangeState.selecting)
            return;
          let target = event.target;
          if (target.tagName === "SPAN") {
            target = (_a = target.parentNode) == null ? void 0 : _a.parentNode;
          }
          if (target.tagName === "DIV") {
            target = target.parentNode;
          }
          if (target.tagName !== "TD")
            return;
          const row = target.parentNode.rowIndex - 1;
          const column = target.cellIndex;
          if (rows.value[row][column].disabled)
            return;
          if (row !== lastRow.value || column !== lastColumn.value) {
            lastRow.value = row;
            lastColumn.value = column;
            emit("changerange", {
              selecting: true,
              endDate: getDateOfCell(row, column)
            });
          }
        };
        const isSelectedCell = (cell) => {
          return !hasCurrent.value && (cell == null ? void 0 : cell.text) === 1 && cell.type === "normal" || cell.isCurrent;
        };
        const handleFocus = (event) => {
          if (focusWithClick || hasCurrent.value || props.selectionMode !== "date")
            return;
          handlePickDate(event, true);
        };
        const handleMouseDown = (event) => {
          const target = event.target.closest("td");
          if (!target)
            return;
          focusWithClick = true;
        };
        const handleMouseUp = (event) => {
          const target = event.target.closest("td");
          if (!target)
            return;
          focusWithClick = false;
        };
        const handlePickDate = (event, isKeyboardMovement = false) => {
          const target = event.target.closest("td");
          if (!target)
            return;
          const row = target.parentNode.rowIndex - 1;
          const column = target.cellIndex;
          const cell = rows.value[row][column];
          if (cell.disabled || cell.type === "week")
            return;
          const newDate = getDateOfCell(row, column);
          if (props.selectionMode === "range") {
            if (!props.rangeState.selecting || !props.minDate) {
              emit("pick", { minDate: newDate, maxDate: null });
              emit("select", true);
            } else {
              if (newDate >= props.minDate) {
                emit("pick", { minDate: props.minDate, maxDate: newDate });
              } else {
                emit("pick", { minDate: newDate, maxDate: props.minDate });
              }
              emit("select", false);
            }
          } else if (props.selectionMode === "date") {
            emit("pick", newDate, isKeyboardMovement);
          } else if (props.selectionMode === "week") {
            const weekNumber = newDate.week();
            const value = `${newDate.year()}w${weekNumber}`;
            emit("pick", {
              year: newDate.year(),
              week: weekNumber,
              value,
              date: newDate.startOf("week")
            });
          } else if (props.selectionMode === "dates") {
            const newValue = cell.selected ? castArray(props.parsedValue).filter((d) => (d == null ? void 0 : d.valueOf()) !== newDate.valueOf()) : castArray(props.parsedValue).concat([newDate]);
            emit("pick", newValue);
          }
        };
        const isWeekActive = (cell) => {
          if (props.selectionMode !== "week")
            return false;
          let newDate = props.date.startOf("day");
          if (cell.type === "prev-month") {
            newDate = newDate.subtract(1, "month");
          }
          if (cell.type === "next-month") {
            newDate = newDate.add(1, "month");
          }
          newDate = newDate.date(Number.parseInt(cell.text, 10));
          if (props.parsedValue && !Array.isArray(props.parsedValue)) {
            const dayOffset = (props.parsedValue.day() - firstDayOfWeek + 7) % 7 - 1;
            const weekDate = props.parsedValue.subtract(dayOffset, "day");
            return weekDate.isSame(newDate, "day");
          }
          return false;
        };
        expose({
          focus
        });
        return (_ctx, _cache) => {
          return vue.openBlock(), vue.createElementBlock("table", {
            role: "grid",
            "aria-label": vue.unref(t)("el.datepicker.dateTablePrompt"),
            cellspacing: "0",
            cellpadding: "0",
            class: vue.normalizeClass([vue.unref(ns).b(), { "is-week-mode": _ctx.selectionMode === "week" }]),
            onClick: handlePickDate,
            onMousemove: handleMouseMove,
            onMousedown: handleMouseDown,
            onMouseup: handleMouseUp
          }, [
            vue.createElementVNode("tbody", {
              ref_key: "tbodyRef",
              ref: tbodyRef
            }, [
              vue.createElementVNode("tr", null, [
                _ctx.showWeekNumber ? (vue.openBlock(), vue.createElementBlock("th", _hoisted_2$t, vue.toDisplayString(vue.unref(t)("el.datepicker.week")), 1)) : vue.createCommentVNode("v-if", true),
                (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(vue.unref(WEEKS), (week, key) => {
                  return vue.openBlock(), vue.createElementBlock("th", {
                    key,
                    scope: "col",
                    "aria-label": vue.unref(t)("el.datepicker.weeksFull." + week)
                  }, vue.toDisplayString(vue.unref(t)("el.datepicker.weeks." + week)), 9, _hoisted_3$f);
                }), 128))
              ]),
              (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(vue.unref(rows), (row, rowKey) => {
                return vue.openBlock(), vue.createElementBlock("tr", {
                  key: rowKey,
                  class: vue.normalizeClass([vue.unref(ns).e("row"), { current: isWeekActive(row[1]) }])
                }, [
                  (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(row, (cell, columnKey) => {
                    return vue.openBlock(), vue.createElementBlock("td", {
                      key: `${rowKey}.${columnKey}`,
                      ref_for: true,
                      ref: (el) => isSelectedCell(cell) && (currentCellRef.value = el),
                      class: vue.normalizeClass(getCellClasses(cell)),
                      "aria-current": cell.isCurrent ? "date" : void 0,
                      "aria-selected": cell.isCurrent,
                      tabindex: isSelectedCell(cell) ? 0 : -1,
                      onFocus: handleFocus
                    }, [
                      vue.createVNode(vue.unref(ElDatePickerCell), { cell }, null, 8, ["cell"])
                    ], 42, _hoisted_4$b);
                  }), 128))
                ], 2);
              }), 128))
            ], 512)
          ], 42, _hoisted_1$J);
        };
      }
    });
    var DateTable = /* @__PURE__ */ _export_sfc(_sfc_main$1l, [["__file", "basic-date-table.vue"]]);
  
    const basicMonthTableProps = buildProps({
      ...datePickerSharedProps,
      selectionMode: selectionModeWithDefault("month")
    });
  
    const _hoisted_1$I = ["aria-label"];
    const _hoisted_2$s = ["aria-selected", "aria-label", "tabindex", "onKeydown"];
    const _hoisted_3$e = { class: "cell" };
    const _sfc_main$1k = /* @__PURE__ */ vue.defineComponent({
      __name: "basic-month-table",
      props: basicMonthTableProps,
      emits: ["changerange", "pick", "select"],
      setup(__props, { expose, emit }) {
        const props = __props;
        const datesInMonth = (year, month, lang2) => {
          const firstDay = dayjs().locale(lang2).startOf("month").month(month).year(year);
          const numOfDays = firstDay.daysInMonth();
          return rangeArr(numOfDays).map((n) => firstDay.add(n, "day").toDate());
        };
        const ns = useNamespace("month-table");
        const { t, lang } = useLocale();
        const tbodyRef = vue.ref();
        const currentCellRef = vue.ref();
        const months = vue.ref(props.date.locale("en").localeData().monthsShort().map((_) => _.toLowerCase()));
        const tableRows = vue.ref([
          [],
          [],
          []
        ]);
        const lastRow = vue.ref();
        const lastColumn = vue.ref();
        const rows = vue.computed(() => {
          var _a, _b;
          const rows2 = tableRows.value;
          const now = dayjs().locale(lang.value).startOf("month");
          for (let i = 0; i < 3; i++) {
            const row = rows2[i];
            for (let j = 0; j < 4; j++) {
              const cell = row[j] || (row[j] = {
                row: i,
                column: j,
                type: "normal",
                inRange: false,
                start: false,
                end: false,
                text: -1,
                disabled: false
              });
              cell.type = "normal";
              const index = i * 4 + j;
              const calTime = props.date.startOf("year").month(index);
              const calEndDate = props.rangeState.endDate || props.maxDate || props.rangeState.selecting && props.minDate || null;
              cell.inRange = !!(props.minDate && calTime.isSameOrAfter(props.minDate, "month") && calEndDate && calTime.isSameOrBefore(calEndDate, "month")) || !!(props.minDate && calTime.isSameOrBefore(props.minDate, "month") && calEndDate && calTime.isSameOrAfter(calEndDate, "month"));
              if ((_a = props.minDate) == null ? void 0 : _a.isSameOrAfter(calEndDate)) {
                cell.start = !!(calEndDate && calTime.isSame(calEndDate, "month"));
                cell.end = props.minDate && calTime.isSame(props.minDate, "month");
              } else {
                cell.start = !!(props.minDate && calTime.isSame(props.minDate, "month"));
                cell.end = !!(calEndDate && calTime.isSame(calEndDate, "month"));
              }
              const isToday = now.isSame(calTime);
              if (isToday) {
                cell.type = "today";
              }
              cell.text = index;
              cell.disabled = ((_b = props.disabledDate) == null ? void 0 : _b.call(props, calTime.toDate())) || false;
            }
          }
          return rows2;
        });
        const focus = () => {
          var _a;
          (_a = currentCellRef.value) == null ? void 0 : _a.focus();
        };
        const getCellStyle = (cell) => {
          const style = {};
          const year = props.date.year();
          const today = new Date();
          const month = cell.text;
          style.disabled = props.disabledDate ? datesInMonth(year, month, lang.value).every(props.disabledDate) : false;
          style.current = castArray(props.parsedValue).findIndex((date) => dayjs.isDayjs(date) && date.year() === year && date.month() === month) >= 0;
          style.today = today.getFullYear() === year && today.getMonth() === month;
          if (cell.inRange) {
            style["in-range"] = true;
            if (cell.start) {
              style["start-date"] = true;
            }
            if (cell.end) {
              style["end-date"] = true;
            }
          }
          return style;
        };
        const isSelectedCell = (cell) => {
          const year = props.date.year();
          const month = cell.text;
          return castArray(props.date).findIndex((date) => date.year() === year && date.month() === month) >= 0;
        };
        const handleMouseMove = (event) => {
          var _a;
          if (!props.rangeState.selecting)
            return;
          let target = event.target;
          if (target.tagName === "A") {
            target = (_a = target.parentNode) == null ? void 0 : _a.parentNode;
          }
          if (target.tagName === "DIV") {
            target = target.parentNode;
          }
          if (target.tagName !== "TD")
            return;
          const row = target.parentNode.rowIndex;
          const column = target.cellIndex;
          if (rows.value[row][column].disabled)
            return;
          if (row !== lastRow.value || column !== lastColumn.value) {
            lastRow.value = row;
            lastColumn.value = column;
            emit("changerange", {
              selecting: true,
              endDate: props.date.startOf("year").month(row * 4 + column)
            });
          }
        };
        const handleMonthTableClick = (event) => {
          var _a;
          const target = (_a = event.target) == null ? void 0 : _a.closest("td");
          if ((target == null ? void 0 : target.tagName) !== "TD")
            return;
          if (hasClass(target, "disabled"))
            return;
          const column = target.cellIndex;
          const row = target.parentNode.rowIndex;
          const month = row * 4 + column;
          const newDate = props.date.startOf("year").month(month);
          if (props.selectionMode === "range") {
            if (!props.rangeState.selecting) {
              emit("pick", { minDate: newDate, maxDate: null });
              emit("select", true);
            } else {
              if (props.minDate && newDate >= props.minDate) {
                emit("pick", { minDate: props.minDate, maxDate: newDate });
              } else {
                emit("pick", { minDate: newDate, maxDate: props.minDate });
              }
              emit("select", false);
            }
          } else {
            emit("pick", month);
          }
        };
        vue.watch(() => props.date, async () => {
          var _a, _b;
          if ((_a = tbodyRef.value) == null ? void 0 : _a.contains(document.activeElement)) {
            await vue.nextTick();
            (_b = currentCellRef.value) == null ? void 0 : _b.focus();
          }
        });
        expose({
          focus
        });
        return (_ctx, _cache) => {
          return vue.openBlock(), vue.createElementBlock("table", {
            role: "grid",
            "aria-label": vue.unref(t)("el.datepicker.monthTablePrompt"),
            class: vue.normalizeClass(vue.unref(ns).b()),
            onClick: handleMonthTableClick,
            onMousemove: handleMouseMove
          }, [
            vue.createElementVNode("tbody", {
              ref_key: "tbodyRef",
              ref: tbodyRef
            }, [
              (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(vue.unref(rows), (row, key) => {
                return vue.openBlock(), vue.createElementBlock("tr", { key }, [
                  (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(row, (cell, key_) => {
                    return vue.openBlock(), vue.createElementBlock("td", {
                      key: key_,
                      ref_for: true,
                      ref: (el) => isSelectedCell(cell) && (currentCellRef.value = el),
                      class: vue.normalizeClass(getCellStyle(cell)),
                      "aria-selected": `${isSelectedCell(cell)}`,
                      "aria-label": vue.unref(t)(`el.datepicker.month${+cell.text + 1}`),
                      tabindex: isSelectedCell(cell) ? 0 : -1,
                      onKeydown: [
                        vue.withKeys(vue.withModifiers(handleMonthTableClick, ["prevent", "stop"]), ["space"]),
                        vue.withKeys(vue.withModifiers(handleMonthTableClick, ["prevent", "stop"]), ["enter"])
                      ]
                    }, [
                      vue.createElementVNode("div", null, [
                        vue.createElementVNode("span", _hoisted_3$e, vue.toDisplayString(vue.unref(t)("el.datepicker.months." + months.value[cell.text])), 1)
                      ])
                    ], 42, _hoisted_2$s);
                  }), 128))
                ]);
              }), 128))
            ], 512)
          ], 42, _hoisted_1$I);
        };
      }
    });
    var MonthTable = /* @__PURE__ */ _export_sfc(_sfc_main$1k, [["__file", "basic-month-table.vue"]]);
  
    const { date, disabledDate, parsedValue } = datePickerSharedProps;
    const basicYearTableProps = buildProps({
      date,
      disabledDate,
      parsedValue
    });
  
    const _hoisted_1$H = ["aria-label"];
    const _hoisted_2$r = ["aria-selected", "tabindex", "onKeydown"];
    const _hoisted_3$d = { class: "cell" };
    const _hoisted_4$a = { key: 1 };
    const _sfc_main$1j = /* @__PURE__ */ vue.defineComponent({
      __name: "basic-year-table",
      props: basicYearTableProps,
      emits: ["pick"],
      setup(__props, { expose, emit }) {
        const props = __props;
        const datesInYear = (year, lang2) => {
          const firstDay = dayjs(String(year)).locale(lang2).startOf("year");
          const lastDay = firstDay.endOf("year");
          const numOfDays = lastDay.dayOfYear();
          return rangeArr(numOfDays).map((n) => firstDay.add(n, "day").toDate());
        };
        const ns = useNamespace("year-table");
        const { t, lang } = useLocale();
        const tbodyRef = vue.ref();
        const currentCellRef = vue.ref();
        const startYear = vue.computed(() => {
          return Math.floor(props.date.year() / 10) * 10;
        });
        const focus = () => {
          var _a;
          (_a = currentCellRef.value) == null ? void 0 : _a.focus();
        };
        const getCellKls = (year) => {
          const kls = {};
          const today = dayjs().locale(lang.value);
          kls.disabled = props.disabledDate ? datesInYear(year, lang.value).every(props.disabledDate) : false;
          kls.current = castArray(props.parsedValue).findIndex((d) => d.year() === year) >= 0;
          kls.today = today.year() === year;
          return kls;
        };
        const isSelectedCell = (year) => {
          return year === startYear.value && props.date.year() < startYear.value && props.date.year() > startYear.value + 9 || castArray(props.date).findIndex((date) => date.year() === year) >= 0;
        };
        const handleYearTableClick = (event) => {
          const clickTarget = event.target;
          const target = clickTarget.closest("td");
          if (target && target.textContent) {
            if (hasClass(target, "disabled"))
              return;
            const year = target.textContent || target.innerText;
            emit("pick", Number(year));
          }
        };
        vue.watch(() => props.date, async () => {
          var _a, _b;
          if ((_a = tbodyRef.value) == null ? void 0 : _a.contains(document.activeElement)) {
            await vue.nextTick();
            (_b = currentCellRef.value) == null ? void 0 : _b.focus();
          }
        });
        expose({
          focus
        });
        return (_ctx, _cache) => {
          return vue.openBlock(), vue.createElementBlock("table", {
            role: "grid",
            "aria-label": vue.unref(t)("el.datepicker.yearTablePrompt"),
            class: vue.normalizeClass(vue.unref(ns).b()),
            onClick: handleYearTableClick
          }, [
            vue.createElementVNode("tbody", {
              ref_key: "tbodyRef",
              ref: tbodyRef
            }, [
              (vue.openBlock(), vue.createElementBlock(vue.Fragment, null, vue.renderList(3, (_, i) => {
                return vue.createElementVNode("tr", { key: i }, [
                  (vue.openBlock(), vue.createElementBlock(vue.Fragment, null, vue.renderList(4, (__, j) => {
                    return vue.openBlock(), vue.createElementBlock(vue.Fragment, {
                      key: i + "_" + j
                    }, [
                      i * 4 + j < 10 ? (vue.openBlock(), vue.createElementBlock("td", {
                        key: 0,
                        ref_for: true,
                        ref: (el) => isSelectedCell(vue.unref(startYear) + i * 4 + j) && (currentCellRef.value = el),
                        class: vue.normalizeClass(["available", getCellKls(vue.unref(startYear) + i * 4 + j)]),
                        "aria-selected": `${isSelectedCell(vue.unref(startYear) + i * 4 + j)}`,
                        tabindex: isSelectedCell(vue.unref(startYear) + i * 4 + j) ? 0 : -1,
                        onKeydown: [
                          vue.withKeys(vue.withModifiers(handleYearTableClick, ["prevent", "stop"]), ["space"]),
                          vue.withKeys(vue.withModifiers(handleYearTableClick, ["prevent", "stop"]), ["enter"])
                        ]
                      }, [
                        vue.createElementVNode("span", _hoisted_3$d, vue.toDisplayString(vue.unref(startYear) + i * 4 + j), 1)
                      ], 42, _hoisted_2$r)) : (vue.openBlock(), vue.createElementBlock("td", _hoisted_4$a))
                    ], 64);
                  }), 64))
                ]);
              }), 64))
            ], 512)
          ], 10, _hoisted_1$H);
        };
      }
    });
    var YearTable = /* @__PURE__ */ _export_sfc(_sfc_main$1j, [["__file", "basic-year-table.vue"]]);
  
    const _hoisted_1$G = ["onClick"];
    const _hoisted_2$q = ["aria-label"];
    const _hoisted_3$c = ["aria-label"];
    const _hoisted_4$9 = ["aria-label"];
    const _hoisted_5$7 = ["aria-label"];
    const _sfc_main$1i = /* @__PURE__ */ vue.defineComponent({
      __name: "panel-date-pick",
      props: panelDatePickProps,
      emits: ["pick", "set-picker-option", "panel-change"],
      setup(__props, { emit: contextEmit }) {
        const props = __props;
        const timeWithinRange = (_, __, ___) => true;
        const ppNs = useNamespace("picker-panel");
        const dpNs = useNamespace("date-picker");
        const attrs = vue.useAttrs();
        const slots = vue.useSlots();
        const { t, lang } = useLocale();
        const pickerBase = vue.inject("EP_PICKER_BASE");
        const popper = vue.inject(TOOLTIP_INJECTION_KEY);
        const { shortcuts, disabledDate, cellClassName, defaultTime, arrowControl } = pickerBase.props;
        const defaultValue = vue.toRef(pickerBase.props, "defaultValue");
        const currentViewRef = vue.ref();
        const innerDate = vue.ref(dayjs().locale(lang.value));
        const defaultTimeD = vue.computed(() => {
          return dayjs(defaultTime).locale(lang.value);
        });
        const month = vue.computed(() => {
          return innerDate.value.month();
        });
        const year = vue.computed(() => {
          return innerDate.value.year();
        });
        const selectableRange = vue.ref([]);
        const userInputDate = vue.ref(null);
        const userInputTime = vue.ref(null);
        const checkDateWithinRange = (date) => {
          return selectableRange.value.length > 0 ? timeWithinRange(date, selectableRange.value, props.format || "HH:mm:ss") : true;
        };
        const formatEmit = (emitDayjs) => {
          if (defaultTime && !visibleTime.value) {
            return defaultTimeD.value.year(emitDayjs.year()).month(emitDayjs.month()).date(emitDayjs.date());
          }
          if (showTime.value)
            return emitDayjs.millisecond(0);
          return emitDayjs.startOf("day");
        };
        const emit = (value, ...args) => {
          if (!value) {
            contextEmit("pick", value, ...args);
          } else if (isArray(value)) {
            const dates = value.map(formatEmit);
            contextEmit("pick", dates, ...args);
          } else {
            contextEmit("pick", formatEmit(value), ...args);
          }
          userInputDate.value = null;
          userInputTime.value = null;
        };
        const handleDatePick = (value, keepOpen) => {
          if (selectionMode.value === "date") {
            value = value;
            let newDate = props.parsedValue ? props.parsedValue.year(value.year()).month(value.month()).date(value.date()) : value;
            if (!checkDateWithinRange(newDate)) {
              newDate = selectableRange.value[0][0].year(value.year()).month(value.month()).date(value.date());
            }
            innerDate.value = newDate;
            emit(newDate, showTime.value || keepOpen);
          } else if (selectionMode.value === "week") {
            emit(value.date);
          } else if (selectionMode.value === "dates") {
            emit(value, true);
          }
        };
        const moveByMonth = (forward) => {
          const action = forward ? "add" : "subtract";
          innerDate.value = innerDate.value[action](1, "month");
          handlePanelChange("month");
        };
        const moveByYear = (forward) => {
          const currentDate = innerDate.value;
          const action = forward ? "add" : "subtract";
          innerDate.value = currentView.value === "year" ? currentDate[action](10, "year") : currentDate[action](1, "year");
          handlePanelChange("year");
        };
        const currentView = vue.ref("date");
        const yearLabel = vue.computed(() => {
          const yearTranslation = t("el.datepicker.year");
          if (currentView.value === "year") {
            const startYear = Math.floor(year.value / 10) * 10;
            if (yearTranslation) {
              return `${startYear} ${yearTranslation} - ${startYear + 9} ${yearTranslation}`;
            }
            return `${startYear} - ${startYear + 9}`;
          }
          return `${year.value} ${yearTranslation}`;
        });
        const handleShortcutClick = (shortcut) => {
          const shortcutValue = isFunction(shortcut.value) ? shortcut.value() : shortcut.value;
          if (shortcutValue) {
            emit(dayjs(shortcutValue).locale(lang.value));
            return;
          }
          if (shortcut.onClick) {
            shortcut.onClick({
              attrs,
              slots,
              emit: contextEmit
            });
          }
        };
        const selectionMode = vue.computed(() => {
          const { type } = props;
          if (["week", "month", "year", "dates"].includes(type))
            return type;
          return "date";
        });
        const keyboardMode = vue.computed(() => {
          return selectionMode.value === "date" ? currentView.value : selectionMode.value;
        });
        const hasShortcuts = vue.computed(() => !!shortcuts.length);
        const handleMonthPick = async (month2) => {
          innerDate.value = innerDate.value.startOf("month").month(month2);
          if (selectionMode.value === "month") {
            emit(innerDate.value, false);
          } else {
            currentView.value = "date";
            if (["month", "year", "date", "week"].includes(selectionMode.value)) {
              emit(innerDate.value, true);
              await vue.nextTick();
              handleFocusPicker();
            }
          }
          handlePanelChange("month");
        };
        const handleYearPick = async (year2) => {
          if (selectionMode.value === "year") {
            innerDate.value = innerDate.value.startOf("year").year(year2);
            emit(innerDate.value, false);
          } else {
            innerDate.value = innerDate.value.year(year2);
            currentView.value = "month";
            if (["month", "year", "date", "week"].includes(selectionMode.value)) {
              emit(innerDate.value, true);
              await vue.nextTick();
              handleFocusPicker();
            }
          }
          handlePanelChange("year");
        };
        const showPicker = async (view) => {
          currentView.value = view;
          await vue.nextTick();
          handleFocusPicker();
        };
        const showTime = vue.computed(() => props.type === "datetime" || props.type === "datetimerange");
        const footerVisible = vue.computed(() => {
          return showTime.value || selectionMode.value === "dates";
        });
        const onConfirm = () => {
          if (selectionMode.value === "dates") {
            emit(props.parsedValue);
          } else {
            let result = props.parsedValue;
            if (!result) {
              const defaultTimeD2 = dayjs(defaultTime).locale(lang.value);
              const defaultValueD = getDefaultValue();
              result = defaultTimeD2.year(defaultValueD.year()).month(defaultValueD.month()).date(defaultValueD.date());
            }
            innerDate.value = result;
            emit(result);
          }
        };
        const changeToNow = () => {
          const now = dayjs().locale(lang.value);
          const nowDate = now.toDate();
          if ((!disabledDate || !disabledDate(nowDate)) && checkDateWithinRange(nowDate)) {
            innerDate.value = dayjs().locale(lang.value);
            emit(innerDate.value);
          }
        };
        const timeFormat = vue.computed(() => {
          return extractTimeFormat(props.format);
        });
        const dateFormat = vue.computed(() => {
          return extractDateFormat(props.format);
        });
        const visibleTime = vue.computed(() => {
          if (userInputTime.value)
            return userInputTime.value;
          if (!props.parsedValue && !defaultValue.value)
            return;
          return (props.parsedValue || innerDate.value).format(timeFormat.value);
        });
        const visibleDate = vue.computed(() => {
          if (userInputDate.value)
            return userInputDate.value;
          if (!props.parsedValue && !defaultValue.value)
            return;
          return (props.parsedValue || innerDate.value).format(dateFormat.value);
        });
        const timePickerVisible = vue.ref(false);
        const onTimePickerInputFocus = () => {
          timePickerVisible.value = true;
        };
        const handleTimePickClose = () => {
          timePickerVisible.value = false;
        };
        const getUnits = (date) => {
          return {
            hour: date.hour(),
            minute: date.minute(),
            second: date.second(),
            year: date.year(),
            month: date.month(),
            date: date.date()
          };
        };
        const handleTimePick = (value, visible, first) => {
          const { hour, minute, second } = getUnits(value);
          const newDate = props.parsedValue ? props.parsedValue.hour(hour).minute(minute).second(second) : value;
          innerDate.value = newDate;
          emit(innerDate.value, true);
          if (!first) {
            timePickerVisible.value = visible;
          }
        };
        const handleVisibleTimeChange = (value) => {
          const newDate = dayjs(value, timeFormat.value).locale(lang.value);
          if (newDate.isValid() && checkDateWithinRange(newDate)) {
            const { year: year2, month: month2, date } = getUnits(innerDate.value);
            innerDate.value = newDate.year(year2).month(month2).date(date);
            userInputTime.value = null;
            timePickerVisible.value = false;
            emit(innerDate.value, true);
          }
        };
        const handleVisibleDateChange = (value) => {
          const newDate = dayjs(value, dateFormat.value).locale(lang.value);
          if (newDate.isValid()) {
            if (disabledDate && disabledDate(newDate.toDate())) {
              return;
            }
            const { hour, minute, second } = getUnits(innerDate.value);
            innerDate.value = newDate.hour(hour).minute(minute).second(second);
            userInputDate.value = null;
            emit(innerDate.value, true);
          }
        };
        const isValidValue = (date) => {
          return dayjs.isDayjs(date) && date.isValid() && (disabledDate ? !disabledDate(date.toDate()) : true);
        };
        const formatToString = (value) => {
          if (selectionMode.value === "dates") {
            return value.map((_) => _.format(props.format));
          }
          return value.format(props.format);
        };
        const parseUserInput = (value) => {
          return dayjs(value, props.format).locale(lang.value);
        };
        const getDefaultValue = () => {
          const parseDate = dayjs(defaultValue.value).locale(lang.value);
          if (!defaultValue.value) {
            const defaultTimeDValue = defaultTimeD.value;
            return dayjs().hour(defaultTimeDValue.hour()).minute(defaultTimeDValue.minute()).second(defaultTimeDValue.second()).locale(lang.value);
          }
          return parseDate;
        };
        const handleFocusPicker = async () => {
          var _a;
          if (["week", "month", "year", "date"].includes(selectionMode.value)) {
            (_a = currentViewRef.value) == null ? void 0 : _a.focus();
            if (selectionMode.value === "week") {
              handleKeyControl(EVENT_CODE.down);
            }
          }
        };
        const handleKeydownTable = (event) => {
          const { code } = event;
          const validCode = [
            EVENT_CODE.up,
            EVENT_CODE.down,
            EVENT_CODE.left,
            EVENT_CODE.right,
            EVENT_CODE.home,
            EVENT_CODE.end,
            EVENT_CODE.pageUp,
            EVENT_CODE.pageDown
          ];
          if (validCode.includes(code)) {
            handleKeyControl(code);
            event.stopPropagation();
            event.preventDefault();
          }
          if ([EVENT_CODE.enter, EVENT_CODE.space].includes(code) && userInputDate.value === null && userInputTime.value === null) {
            event.preventDefault();
            emit(innerDate.value, false);
          }
        };
        const handleKeyControl = (code) => {
          var _a;
          const { up, down, left, right, home, end, pageUp, pageDown } = EVENT_CODE;
          const mapping = {
            year: {
              [up]: -4,
              [down]: 4,
              [left]: -1,
              [right]: 1,
              offset: (date, step) => date.setFullYear(date.getFullYear() + step)
            },
            month: {
              [up]: -4,
              [down]: 4,
              [left]: -1,
              [right]: 1,
              offset: (date, step) => date.setMonth(date.getMonth() + step)
            },
            week: {
              [up]: -1,
              [down]: 1,
              [left]: -1,
              [right]: 1,
              offset: (date, step) => date.setDate(date.getDate() + step * 7)
            },
            date: {
              [up]: -7,
              [down]: 7,
              [left]: -1,
              [right]: 1,
              [home]: (date) => -date.getDay(),
              [end]: (date) => -date.getDay() + 6,
              [pageUp]: (date) => -new Date(date.getFullYear(), date.getMonth(), 0).getDate(),
              [pageDown]: (date) => new Date(date.getFullYear(), date.getMonth() + 1, 0).getDate(),
              offset: (date, step) => date.setDate(date.getDate() + step)
            }
          };
          const newDate = innerDate.value.toDate();
          while (Math.abs(innerDate.value.diff(newDate, "year", true)) < 1) {
            const map = mapping[keyboardMode.value];
            if (!map)
              return;
            map.offset(newDate, isFunction(map[code]) ? map[code](newDate) : (_a = map[code]) != null ? _a : 0);
            if (disabledDate && disabledDate(newDate)) {
              break;
            }
            const result = dayjs(newDate).locale(lang.value);
            innerDate.value = result;
            contextEmit("pick", result, true);
            break;
          }
        };
        const handlePanelChange = (mode) => {
          contextEmit("panel-change", innerDate.value.toDate(), mode, currentView.value);
        };
        vue.watch(() => selectionMode.value, (val) => {
          if (["month", "year"].includes(val)) {
            currentView.value = val;
            return;
          }
          currentView.value = "date";
        }, { immediate: true });
        vue.watch(() => currentView.value, () => {
          popper == null ? void 0 : popper.updatePopper();
        });
        vue.watch(() => defaultValue.value, (val) => {
          if (val) {
            innerDate.value = getDefaultValue();
          }
        }, { immediate: true });
        vue.watch(() => props.parsedValue, (val) => {
          if (val) {
            if (selectionMode.value === "dates")
              return;
            if (Array.isArray(val))
              return;
            innerDate.value = val;
          } else {
            innerDate.value = getDefaultValue();
          }
        }, { immediate: true });
        contextEmit("set-picker-option", ["isValidValue", isValidValue]);
        contextEmit("set-picker-option", ["formatToString", formatToString]);
        contextEmit("set-picker-option", ["parseUserInput", parseUserInput]);
        contextEmit("set-picker-option", ["handleFocusPicker", handleFocusPicker]);
        return (_ctx, _cache) => {
          return vue.openBlock(), vue.createElementBlock("div", {
            class: vue.normalizeClass([
              vue.unref(ppNs).b(),
              vue.unref(dpNs).b(),
              {
                "has-sidebar": _ctx.$slots.sidebar || vue.unref(hasShortcuts),
                "has-time": vue.unref(showTime)
              }
            ])
          }, [
            vue.createElementVNode("div", {
              class: vue.normalizeClass(vue.unref(ppNs).e("body-wrapper"))
            }, [
              vue.renderSlot(_ctx.$slots, "sidebar", {
                class: vue.normalizeClass(vue.unref(ppNs).e("sidebar"))
              }),
              vue.unref(hasShortcuts) ? (vue.openBlock(), vue.createElementBlock("div", {
                key: 0,
                class: vue.normalizeClass(vue.unref(ppNs).e("sidebar"))
              }, [
                (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(vue.unref(shortcuts), (shortcut, key) => {
                  return vue.openBlock(), vue.createElementBlock("button", {
                    key,
                    type: "button",
                    class: vue.normalizeClass(vue.unref(ppNs).e("shortcut")),
                    onClick: ($event) => handleShortcutClick(shortcut)
                  }, vue.toDisplayString(shortcut.text), 11, _hoisted_1$G);
                }), 128))
              ], 2)) : vue.createCommentVNode("v-if", true),
              vue.createElementVNode("div", {
                class: vue.normalizeClass(vue.unref(ppNs).e("body"))
              }, [
                vue.unref(showTime) ? (vue.openBlock(), vue.createElementBlock("div", {
                  key: 0,
                  class: vue.normalizeClass(vue.unref(dpNs).e("time-header"))
                }, [
                  vue.createElementVNode("span", {
                    class: vue.normalizeClass(vue.unref(dpNs).e("editor-wrap"))
                  }, [
                    vue.createVNode(vue.unref(ElInput), {
                      placeholder: vue.unref(t)("el.datepicker.selectDate"),
                      "model-value": vue.unref(visibleDate),
                      size: "small",
                      "validate-event": false,
                      onInput: _cache[0] || (_cache[0] = (val) => userInputDate.value = val),
                      onChange: handleVisibleDateChange
                    }, null, 8, ["placeholder", "model-value"])
                  ], 2),
                  vue.withDirectives((vue.openBlock(), vue.createElementBlock("span", {
                    class: vue.normalizeClass(vue.unref(dpNs).e("editor-wrap"))
                  }, [
                    vue.createVNode(vue.unref(ElInput), {
                      placeholder: vue.unref(t)("el.datepicker.selectTime"),
                      "model-value": vue.unref(visibleTime),
                      size: "small",
                      "validate-event": false,
                      onFocus: onTimePickerInputFocus,
                      onInput: _cache[1] || (_cache[1] = (val) => userInputTime.value = val),
                      onChange: handleVisibleTimeChange
                    }, null, 8, ["placeholder", "model-value"]),
                    vue.createVNode(vue.unref(TimePickPanel), {
                      visible: timePickerVisible.value,
                      format: vue.unref(timeFormat),
                      "time-arrow-control": vue.unref(arrowControl),
                      "parsed-value": innerDate.value,
                      onPick: handleTimePick
                    }, null, 8, ["visible", "format", "time-arrow-control", "parsed-value"])
                  ], 2)), [
                    [vue.unref(ClickOutside), handleTimePickClose]
                  ])
                ], 2)) : vue.createCommentVNode("v-if", true),
                vue.withDirectives(vue.createElementVNode("div", {
                  class: vue.normalizeClass([
                    vue.unref(dpNs).e("header"),
                    (currentView.value === "year" || currentView.value === "month") && vue.unref(dpNs).e("header--bordered")
                  ])
                }, [
                  vue.createElementVNode("span", {
                    class: vue.normalizeClass(vue.unref(dpNs).e("prev-btn"))
                  }, [
                    vue.createElementVNode("button", {
                      type: "button",
                      "aria-label": vue.unref(t)(`el.datepicker.prevYear`),
                      class: vue.normalizeClass(["d-arrow-left", vue.unref(ppNs).e("icon-btn")]),
                      onClick: _cache[2] || (_cache[2] = ($event) => moveByYear(false))
                    }, [
                      vue.createVNode(vue.unref(ElIcon), null, {
                        default: vue.withCtx(() => [
                          vue.createVNode(vue.unref(d_arrow_left_default))
                        ]),
                        _: 1
                      })
                    ], 10, _hoisted_2$q),
                    vue.withDirectives(vue.createElementVNode("button", {
                      type: "button",
                      "aria-label": vue.unref(t)(`el.datepicker.prevMonth`),
                      class: vue.normalizeClass([vue.unref(ppNs).e("icon-btn"), "arrow-left"]),
                      onClick: _cache[3] || (_cache[3] = ($event) => moveByMonth(false))
                    }, [
                      vue.createVNode(vue.unref(ElIcon), null, {
                        default: vue.withCtx(() => [
                          vue.createVNode(vue.unref(arrow_left_default))
                        ]),
                        _: 1
                      })
                    ], 10, _hoisted_3$c), [
                      [vue.vShow, currentView.value === "date"]
                    ])
                  ], 2),
                  vue.createElementVNode("span", {
                    role: "button",
                    class: vue.normalizeClass(vue.unref(dpNs).e("header-label")),
                    "aria-live": "polite",
                    tabindex: "0",
                    onKeydown: _cache[4] || (_cache[4] = vue.withKeys(($event) => showPicker("year"), ["enter"])),
                    onClick: _cache[5] || (_cache[5] = ($event) => showPicker("year"))
                  }, vue.toDisplayString(vue.unref(yearLabel)), 35),
                  vue.withDirectives(vue.createElementVNode("span", {
                    role: "button",
                    "aria-live": "polite",
                    tabindex: "0",
                    class: vue.normalizeClass([
                      vue.unref(dpNs).e("header-label"),
                      { active: currentView.value === "month" }
                    ]),
                    onKeydown: _cache[6] || (_cache[6] = vue.withKeys(($event) => showPicker("month"), ["enter"])),
                    onClick: _cache[7] || (_cache[7] = ($event) => showPicker("month"))
                  }, vue.toDisplayString(vue.unref(t)(`el.datepicker.month${vue.unref(month) + 1}`)), 35), [
                    [vue.vShow, currentView.value === "date"]
                  ]),
                  vue.createElementVNode("span", {
                    class: vue.normalizeClass(vue.unref(dpNs).e("next-btn"))
                  }, [
                    vue.withDirectives(vue.createElementVNode("button", {
                      type: "button",
                      "aria-label": vue.unref(t)(`el.datepicker.nextMonth`),
                      class: vue.normalizeClass([vue.unref(ppNs).e("icon-btn"), "arrow-right"]),
                      onClick: _cache[8] || (_cache[8] = ($event) => moveByMonth(true))
                    }, [
                      vue.createVNode(vue.unref(ElIcon), null, {
                        default: vue.withCtx(() => [
                          vue.createVNode(vue.unref(arrow_right_default))
                        ]),
                        _: 1
                      })
                    ], 10, _hoisted_4$9), [
                      [vue.vShow, currentView.value === "date"]
                    ]),
                    vue.createElementVNode("button", {
                      type: "button",
                      "aria-label": vue.unref(t)(`el.datepicker.nextYear`),
                      class: vue.normalizeClass([vue.unref(ppNs).e("icon-btn"), "d-arrow-right"]),
                      onClick: _cache[9] || (_cache[9] = ($event) => moveByYear(true))
                    }, [
                      vue.createVNode(vue.unref(ElIcon), null, {
                        default: vue.withCtx(() => [
                          vue.createVNode(vue.unref(d_arrow_right_default))
                        ]),
                        _: 1
                      })
                    ], 10, _hoisted_5$7)
                  ], 2)
                ], 2), [
                  [vue.vShow, currentView.value !== "time"]
                ]),
                vue.createElementVNode("div", {
                  class: vue.normalizeClass(vue.unref(ppNs).e("content")),
                  onKeydown: handleKeydownTable
                }, [
                  currentView.value === "date" ? (vue.openBlock(), vue.createBlock(DateTable, {
                    key: 0,
                    ref_key: "currentViewRef",
                    ref: currentViewRef,
                    "selection-mode": vue.unref(selectionMode),
                    date: innerDate.value,
                    "parsed-value": _ctx.parsedValue,
                    "disabled-date": vue.unref(disabledDate),
                    "cell-class-name": vue.unref(cellClassName),
                    onPick: handleDatePick
                  }, null, 8, ["selection-mode", "date", "parsed-value", "disabled-date", "cell-class-name"])) : vue.createCommentVNode("v-if", true),
                  currentView.value === "year" ? (vue.openBlock(), vue.createBlock(YearTable, {
                    key: 1,
                    ref_key: "currentViewRef",
                    ref: currentViewRef,
                    date: innerDate.value,
                    "disabled-date": vue.unref(disabledDate),
                    "parsed-value": _ctx.parsedValue,
                    onPick: handleYearPick
                  }, null, 8, ["date", "disabled-date", "parsed-value"])) : vue.createCommentVNode("v-if", true),
                  currentView.value === "month" ? (vue.openBlock(), vue.createBlock(MonthTable, {
                    key: 2,
                    ref_key: "currentViewRef",
                    ref: currentViewRef,
                    date: innerDate.value,
                    "parsed-value": _ctx.parsedValue,
                    "disabled-date": vue.unref(disabledDate),
                    onPick: handleMonthPick
                  }, null, 8, ["date", "parsed-value", "disabled-date"])) : vue.createCommentVNode("v-if", true)
                ], 34)
              ], 2)
            ], 2),
            vue.withDirectives(vue.createElementVNode("div", {
              class: vue.normalizeClass(vue.unref(ppNs).e("footer"))
            }, [
              vue.withDirectives(vue.createVNode(vue.unref(ElButton), {
                text: "",
                size: "small",
                class: vue.normalizeClass(vue.unref(ppNs).e("link-btn")),
                onClick: changeToNow
              }, {
                default: vue.withCtx(() => [
                  vue.createTextVNode(vue.toDisplayString(vue.unref(t)("el.datepicker.now")), 1)
                ]),
                _: 1
              }, 8, ["class"]), [
                [vue.vShow, vue.unref(selectionMode) !== "dates"]
              ]),
              vue.createVNode(vue.unref(ElButton), {
                plain: "",
                size: "small",
                class: vue.normalizeClass(vue.unref(ppNs).e("link-btn")),
                onClick: onConfirm
              }, {
                default: vue.withCtx(() => [
                  vue.createTextVNode(vue.toDisplayString(vue.unref(t)("el.datepicker.confirm")), 1)
                ]),
                _: 1
              }, 8, ["class"])
            ], 2), [
              [vue.vShow, vue.unref(footerVisible) && currentView.value === "date"]
            ])
          ], 2);
        };
      }
    });
    var DatePickPanel = /* @__PURE__ */ _export_sfc(_sfc_main$1i, [["__file", "panel-date-pick.vue"]]);
  
    const panelDateRangeProps = buildProps({
      ...panelSharedProps,
      ...panelRangeSharedProps
    });
  
    const useShortcut = (lang) => {
      const { emit } = vue.getCurrentInstance();
      const attrs = vue.useAttrs();
      const slots = vue.useSlots();
      const handleShortcutClick = (shortcut) => {
        const shortcutValues = isFunction(shortcut.value) ? shortcut.value() : shortcut.value;
        if (shortcutValues) {
          emit("pick", [
            dayjs(shortcutValues[0]).locale(lang.value),
            dayjs(shortcutValues[1]).locale(lang.value)
          ]);
          return;
        }
        if (shortcut.onClick) {
          shortcut.onClick({
            attrs,
            slots,
            emit
          });
        }
      };
      return handleShortcutClick;
    };
  
    const useRangePicker = (props, {
      defaultValue,
      leftDate,
      rightDate,
      unit,
      onParsedValueChanged
    }) => {
      const { emit } = vue.getCurrentInstance();
      const { pickerNs } = vue.inject(ROOT_PICKER_INJECTION_KEY);
      const drpNs = useNamespace("date-range-picker");
      const { t, lang } = useLocale();
      const handleShortcutClick = useShortcut(lang);
      const minDate = vue.ref();
      const maxDate = vue.ref();
      const rangeState = vue.ref({
        endDate: null,
        selecting: false
      });
      const handleChangeRange = (val) => {
        rangeState.value = val;
      };
      const handleRangeConfirm = (visible = false) => {
        const _minDate = vue.unref(minDate);
        const _maxDate = vue.unref(maxDate);
        if (isValidRange([_minDate, _maxDate])) {
          emit("pick", [_minDate, _maxDate], visible);
        }
      };
      const onSelect = (selecting) => {
        rangeState.value.selecting = selecting;
        if (!selecting) {
          rangeState.value.endDate = null;
        }
      };
      const restoreDefault = () => {
        const [start, end] = getDefaultValue(vue.unref(defaultValue), {
          lang: vue.unref(lang),
          unit,
          unlinkPanels: props.unlinkPanels
        });
        minDate.value = void 0;
        maxDate.value = void 0;
        leftDate.value = start;
        rightDate.value = end;
      };
      vue.watch(defaultValue, (val) => {
        if (val) {
          restoreDefault();
        }
      }, { immediate: true });
      vue.watch(() => props.parsedValue, (parsedValue) => {
        if (isArray(parsedValue) && parsedValue.length === 2) {
          const [start, end] = parsedValue;
          minDate.value = start;
          leftDate.value = start;
          maxDate.value = end;
          onParsedValueChanged(vue.unref(minDate), vue.unref(maxDate));
        } else {
          restoreDefault();
        }
      }, { immediate: true });
      return {
        minDate,
        maxDate,
        rangeState,
        lang,
        ppNs: pickerNs,
        drpNs,
        handleChangeRange,
        handleRangeConfirm,
        handleShortcutClick,
        onSelect,
        t
      };
    };
  
    const _hoisted_1$F = ["onClick"];
    const _hoisted_2$p = ["disabled"];
    const _hoisted_3$b = ["disabled"];
    const _hoisted_4$8 = ["disabled"];
    const _hoisted_5$6 = ["disabled"];
    const unit$1 = "month";
    const _sfc_main$1h = /* @__PURE__ */ vue.defineComponent({
      __name: "panel-date-range",
      props: panelDateRangeProps,
      emits: [
        "pick",
        "set-picker-option",
        "calendar-change",
        "panel-change"
      ],
      setup(__props, { emit }) {
        const props = __props;
        const pickerBase = vue.inject("EP_PICKER_BASE");
        const {
          disabledDate,
          cellClassName,
          format,
          defaultTime,
          arrowControl,
          clearable
        } = pickerBase.props;
        const shortcuts = vue.toRef(pickerBase.props, "shortcuts");
        const defaultValue = vue.toRef(pickerBase.props, "defaultValue");
        const { lang } = useLocale();
        const leftDate = vue.ref(dayjs().locale(lang.value));
        const rightDate = vue.ref(dayjs().locale(lang.value).add(1, unit$1));
        const {
          minDate,
          maxDate,
          rangeState,
          ppNs,
          drpNs,
          handleChangeRange,
          handleRangeConfirm,
          handleShortcutClick,
          onSelect,
          t
        } = useRangePicker(props, {
          defaultValue,
          leftDate,
          rightDate,
          unit: unit$1,
          onParsedValueChanged
        });
        const dateUserInput = vue.ref({
          min: null,
          max: null
        });
        const timeUserInput = vue.ref({
          min: null,
          max: null
        });
        const leftLabel = vue.computed(() => {
          return `${leftDate.value.year()} ${t("el.datepicker.year")} ${t(`el.datepicker.month${leftDate.value.month() + 1}`)}`;
        });
        const rightLabel = vue.computed(() => {
          return `${rightDate.value.year()} ${t("el.datepicker.year")} ${t(`el.datepicker.month${rightDate.value.month() + 1}`)}`;
        });
        const leftYear = vue.computed(() => {
          return leftDate.value.year();
        });
        const leftMonth = vue.computed(() => {
          return leftDate.value.month();
        });
        const rightYear = vue.computed(() => {
          return rightDate.value.year();
        });
        const rightMonth = vue.computed(() => {
          return rightDate.value.month();
        });
        const hasShortcuts = vue.computed(() => !!shortcuts.value.length);
        const minVisibleDate = vue.computed(() => {
          if (dateUserInput.value.min !== null)
            return dateUserInput.value.min;
          if (minDate.value)
            return minDate.value.format(dateFormat.value);
          return "";
        });
        const maxVisibleDate = vue.computed(() => {
          if (dateUserInput.value.max !== null)
            return dateUserInput.value.max;
          if (maxDate.value || minDate.value)
            return (maxDate.value || minDate.value).format(dateFormat.value);
          return "";
        });
        const minVisibleTime = vue.computed(() => {
          if (timeUserInput.value.min !== null)
            return timeUserInput.value.min;
          if (minDate.value)
            return minDate.value.format(timeFormat.value);
          return "";
        });
        const maxVisibleTime = vue.computed(() => {
          if (timeUserInput.value.max !== null)
            return timeUserInput.value.max;
          if (maxDate.value || minDate.value)
            return (maxDate.value || minDate.value).format(timeFormat.value);
          return "";
        });
        const timeFormat = vue.computed(() => {
          return extractTimeFormat(format);
        });
        const dateFormat = vue.computed(() => {
          return extractDateFormat(format);
        });
        const leftPrevYear = () => {
          leftDate.value = leftDate.value.subtract(1, "year");
          if (!props.unlinkPanels) {
            rightDate.value = leftDate.value.add(1, "month");
          }
          handlePanelChange("year");
        };
        const leftPrevMonth = () => {
          leftDate.value = leftDate.value.subtract(1, "month");
          if (!props.unlinkPanels) {
            rightDate.value = leftDate.value.add(1, "month");
          }
          handlePanelChange("month");
        };
        const rightNextYear = () => {
          if (!props.unlinkPanels) {
            leftDate.value = leftDate.value.add(1, "year");
            rightDate.value = leftDate.value.add(1, "month");
          } else {
            rightDate.value = rightDate.value.add(1, "year");
          }
          handlePanelChange("year");
        };
        const rightNextMonth = () => {
          if (!props.unlinkPanels) {
            leftDate.value = leftDate.value.add(1, "month");
            rightDate.value = leftDate.value.add(1, "month");
          } else {
            rightDate.value = rightDate.value.add(1, "month");
          }
          handlePanelChange("month");
        };
        const leftNextYear = () => {
          leftDate.value = leftDate.value.add(1, "year");
          handlePanelChange("year");
        };
        const leftNextMonth = () => {
          leftDate.value = leftDate.value.add(1, "month");
          handlePanelChange("month");
        };
        const rightPrevYear = () => {
          rightDate.value = rightDate.value.subtract(1, "year");
          handlePanelChange("year");
        };
        const rightPrevMonth = () => {
          rightDate.value = rightDate.value.subtract(1, "month");
          handlePanelChange("month");
        };
        const handlePanelChange = (mode) => {
          emit("panel-change", [leftDate.value.toDate(), rightDate.value.toDate()], mode);
        };
        const enableMonthArrow = vue.computed(() => {
          const nextMonth = (leftMonth.value + 1) % 12;
          const yearOffset = leftMonth.value + 1 >= 12 ? 1 : 0;
          return props.unlinkPanels && new Date(leftYear.value + yearOffset, nextMonth) < new Date(rightYear.value, rightMonth.value);
        });
        const enableYearArrow = vue.computed(() => {
          return props.unlinkPanels && rightYear.value * 12 + rightMonth.value - (leftYear.value * 12 + leftMonth.value + 1) >= 12;
        });
        const btnDisabled = vue.computed(() => {
          return !(minDate.value && maxDate.value && !rangeState.value.selecting && isValidRange([minDate.value, maxDate.value]));
        });
        const showTime = vue.computed(() => props.type === "datetime" || props.type === "datetimerange");
        const formatEmit = (emitDayjs, index) => {
          if (!emitDayjs)
            return;
          if (defaultTime) {
            const defaultTimeD = dayjs(defaultTime[index] || defaultTime).locale(lang.value);
            return defaultTimeD.year(emitDayjs.year()).month(emitDayjs.month()).date(emitDayjs.date());
          }
          return emitDayjs;
        };
        const handleRangePick = (val, close = true) => {
          const min_ = val.minDate;
          const max_ = val.maxDate;
          const minDate_ = formatEmit(min_, 0);
          const maxDate_ = formatEmit(max_, 1);
          if (maxDate.value === maxDate_ && minDate.value === minDate_) {
            return;
          }
          emit("calendar-change", [min_.toDate(), max_ && max_.toDate()]);
          maxDate.value = maxDate_;
          minDate.value = minDate_;
          if (!close || showTime.value)
            return;
          handleRangeConfirm();
        };
        const minTimePickerVisible = vue.ref(false);
        const maxTimePickerVisible = vue.ref(false);
        const handleMinTimeClose = () => {
          minTimePickerVisible.value = false;
        };
        const handleMaxTimeClose = () => {
          maxTimePickerVisible.value = false;
        };
        const handleDateInput = (value, type) => {
          dateUserInput.value[type] = value;
          const parsedValueD = dayjs(value, dateFormat.value).locale(lang.value);
          if (parsedValueD.isValid()) {
            if (disabledDate && disabledDate(parsedValueD.toDate())) {
              return;
            }
            if (type === "min") {
              leftDate.value = parsedValueD;
              minDate.value = (minDate.value || leftDate.value).year(parsedValueD.year()).month(parsedValueD.month()).date(parsedValueD.date());
              if (!props.unlinkPanels) {
                rightDate.value = parsedValueD.add(1, "month");
                maxDate.value = minDate.value.add(1, "month");
              }
            } else {
              rightDate.value = parsedValueD;
              maxDate.value = (maxDate.value || rightDate.value).year(parsedValueD.year()).month(parsedValueD.month()).date(parsedValueD.date());
              if (!props.unlinkPanels) {
                leftDate.value = parsedValueD.subtract(1, "month");
                minDate.value = maxDate.value.subtract(1, "month");
              }
            }
          }
        };
        const handleDateChange = (_, type) => {
          dateUserInput.value[type] = null;
        };
        const handleTimeInput = (value, type) => {
          timeUserInput.value[type] = value;
          const parsedValueD = dayjs(value, timeFormat.value).locale(lang.value);
          if (parsedValueD.isValid()) {
            if (type === "min") {
              minTimePickerVisible.value = true;
              minDate.value = (minDate.value || leftDate.value).hour(parsedValueD.hour()).minute(parsedValueD.minute()).second(parsedValueD.second());
              if (!maxDate.value || maxDate.value.isBefore(minDate.value)) {
                maxDate.value = minDate.value;
              }
            } else {
              maxTimePickerVisible.value = true;
              maxDate.value = (maxDate.value || rightDate.value).hour(parsedValueD.hour()).minute(parsedValueD.minute()).second(parsedValueD.second());
              rightDate.value = maxDate.value;
              if (maxDate.value && maxDate.value.isBefore(minDate.value)) {
                minDate.value = maxDate.value;
              }
            }
          }
        };
        const handleTimeChange = (value, type) => {
          timeUserInput.value[type] = null;
          if (type === "min") {
            leftDate.value = minDate.value;
            minTimePickerVisible.value = false;
          } else {
            rightDate.value = maxDate.value;
            maxTimePickerVisible.value = false;
          }
        };
        const handleMinTimePick = (value, visible, first) => {
          if (timeUserInput.value.min)
            return;
          if (value) {
            leftDate.value = value;
            minDate.value = (minDate.value || leftDate.value).hour(value.hour()).minute(value.minute()).second(value.second());
          }
          if (!first) {
            minTimePickerVisible.value = visible;
          }
          if (!maxDate.value || maxDate.value.isBefore(minDate.value)) {
            maxDate.value = minDate.value;
            rightDate.value = value;
          }
        };
        const handleMaxTimePick = (value, visible, first) => {
          if (timeUserInput.value.max)
            return;
          if (value) {
            rightDate.value = value;
            maxDate.value = (maxDate.value || rightDate.value).hour(value.hour()).minute(value.minute()).second(value.second());
          }
          if (!first) {
            maxTimePickerVisible.value = visible;
          }
          if (maxDate.value && maxDate.value.isBefore(minDate.value)) {
            minDate.value = maxDate.value;
          }
        };
        const handleClear = () => {
          leftDate.value = getDefaultValue(vue.unref(defaultValue), {
            lang: vue.unref(lang),
            unit: "month",
            unlinkPanels: props.unlinkPanels
          })[0];
          rightDate.value = leftDate.value.add(1, "month");
          emit("pick", null);
        };
        const formatToString = (value) => {
          return isArray(value) ? value.map((_) => _.format(format)) : value.format(format);
        };
        const parseUserInput = (value) => {
          return isArray(value) ? value.map((_) => dayjs(_, format).locale(lang.value)) : dayjs(value, format).locale(lang.value);
        };
        function onParsedValueChanged(minDate2, maxDate2) {
          if (props.unlinkPanels && maxDate2) {
            const minDateYear = (minDate2 == null ? void 0 : minDate2.year()) || 0;
            const minDateMonth = (minDate2 == null ? void 0 : minDate2.month()) || 0;
            const maxDateYear = maxDate2.year();
            const maxDateMonth = maxDate2.month();
            rightDate.value = minDateYear === maxDateYear && minDateMonth === maxDateMonth ? maxDate2.add(1, unit$1) : maxDate2;
          } else {
            rightDate.value = leftDate.value.add(1, unit$1);
            if (maxDate2) {
              rightDate.value = rightDate.value.hour(maxDate2.hour()).minute(maxDate2.minute()).second(maxDate2.second());
            }
          }
        }
        emit("set-picker-option", ["isValidValue", isValidRange]);
        emit("set-picker-option", ["parseUserInput", parseUserInput]);
        emit("set-picker-option", ["formatToString", formatToString]);
        emit("set-picker-option", ["handleClear", handleClear]);
        return (_ctx, _cache) => {
          return vue.openBlock(), vue.createElementBlock("div", {
            class: vue.normalizeClass([
              vue.unref(ppNs).b(),
              vue.unref(drpNs).b(),
              {
                "has-sidebar": _ctx.$slots.sidebar || vue.unref(hasShortcuts),
                "has-time": vue.unref(showTime)
              }
            ])
          }, [
            vue.createElementVNode("div", {
              class: vue.normalizeClass(vue.unref(ppNs).e("body-wrapper"))
            }, [
              vue.renderSlot(_ctx.$slots, "sidebar", {
                class: vue.normalizeClass(vue.unref(ppNs).e("sidebar"))
              }),
              vue.unref(hasShortcuts) ? (vue.openBlock(), vue.createElementBlock("div", {
                key: 0,
                class: vue.normalizeClass(vue.unref(ppNs).e("sidebar"))
              }, [
                (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(vue.unref(shortcuts), (shortcut, key) => {
                  return vue.openBlock(), vue.createElementBlock("button", {
                    key,
                    type: "button",
                    class: vue.normalizeClass(vue.unref(ppNs).e("shortcut")),
                    onClick: ($event) => vue.unref(handleShortcutClick)(shortcut)
                  }, vue.toDisplayString(shortcut.text), 11, _hoisted_1$F);
                }), 128))
              ], 2)) : vue.createCommentVNode("v-if", true),
              vue.createElementVNode("div", {
                class: vue.normalizeClass(vue.unref(ppNs).e("body"))
              }, [
                vue.unref(showTime) ? (vue.openBlock(), vue.createElementBlock("div", {
                  key: 0,
                  class: vue.normalizeClass(vue.unref(drpNs).e("time-header"))
                }, [
                  vue.createElementVNode("span", {
                    class: vue.normalizeClass(vue.unref(drpNs).e("editors-wrap"))
                  }, [
                    vue.createElementVNode("span", {
                      class: vue.normalizeClass(vue.unref(drpNs).e("time-picker-wrap"))
                    }, [
                      vue.createVNode(vue.unref(ElInput), {
                        size: "small",
                        disabled: vue.unref(rangeState).selecting,
                        placeholder: vue.unref(t)("el.datepicker.startDate"),
                        class: vue.normalizeClass(vue.unref(drpNs).e("editor")),
                        "model-value": vue.unref(minVisibleDate),
                        "validate-event": false,
                        onInput: _cache[0] || (_cache[0] = (val) => handleDateInput(val, "min")),
                        onChange: _cache[1] || (_cache[1] = (val) => handleDateChange(val, "min"))
                      }, null, 8, ["disabled", "placeholder", "class", "model-value"])
                    ], 2),
                    vue.withDirectives((vue.openBlock(), vue.createElementBlock("span", {
                      class: vue.normalizeClass(vue.unref(drpNs).e("time-picker-wrap"))
                    }, [
                      vue.createVNode(vue.unref(ElInput), {
                        size: "small",
                        class: vue.normalizeClass(vue.unref(drpNs).e("editor")),
                        disabled: vue.unref(rangeState).selecting,
                        placeholder: vue.unref(t)("el.datepicker.startTime"),
                        "model-value": vue.unref(minVisibleTime),
                        "validate-event": false,
                        onFocus: _cache[2] || (_cache[2] = ($event) => minTimePickerVisible.value = true),
                        onInput: _cache[3] || (_cache[3] = (val) => handleTimeInput(val, "min")),
                        onChange: _cache[4] || (_cache[4] = (val) => handleTimeChange(val, "min"))
                      }, null, 8, ["class", "disabled", "placeholder", "model-value"]),
                      vue.createVNode(vue.unref(TimePickPanel), {
                        visible: minTimePickerVisible.value,
                        format: vue.unref(timeFormat),
                        "datetime-role": "start",
                        "time-arrow-control": vue.unref(arrowControl),
                        "parsed-value": leftDate.value,
                        onPick: handleMinTimePick
                      }, null, 8, ["visible", "format", "time-arrow-control", "parsed-value"])
                    ], 2)), [
                      [vue.unref(ClickOutside), handleMinTimeClose]
                    ])
                  ], 2),
                  vue.createElementVNode("span", null, [
                    vue.createVNode(vue.unref(ElIcon), null, {
                      default: vue.withCtx(() => [
                        vue.createVNode(vue.unref(arrow_right_default))
                      ]),
                      _: 1
                    })
                  ]),
                  vue.createElementVNode("span", {
                    class: vue.normalizeClass([vue.unref(drpNs).e("editors-wrap"), "is-right"])
                  }, [
                    vue.createElementVNode("span", {
                      class: vue.normalizeClass(vue.unref(drpNs).e("time-picker-wrap"))
                    }, [
                      vue.createVNode(vue.unref(ElInput), {
                        size: "small",
                        class: vue.normalizeClass(vue.unref(drpNs).e("editor")),
                        disabled: vue.unref(rangeState).selecting,
                        placeholder: vue.unref(t)("el.datepicker.endDate"),
                        "model-value": vue.unref(maxVisibleDate),
                        readonly: !vue.unref(minDate),
                        "validate-event": false,
                        onInput: _cache[5] || (_cache[5] = (val) => handleDateInput(val, "max")),
                        onChange: _cache[6] || (_cache[6] = (val) => handleDateChange(val, "max"))
                      }, null, 8, ["class", "disabled", "placeholder", "model-value", "readonly"])
                    ], 2),
                    vue.withDirectives((vue.openBlock(), vue.createElementBlock("span", {
                      class: vue.normalizeClass(vue.unref(drpNs).e("time-picker-wrap"))
                    }, [
                      vue.createVNode(vue.unref(ElInput), {
                        size: "small",
                        class: vue.normalizeClass(vue.unref(drpNs).e("editor")),
                        disabled: vue.unref(rangeState).selecting,
                        placeholder: vue.unref(t)("el.datepicker.endTime"),
                        "model-value": vue.unref(maxVisibleTime),
                        readonly: !vue.unref(minDate),
                        "validate-event": false,
                        onFocus: _cache[7] || (_cache[7] = ($event) => vue.unref(minDate) && (maxTimePickerVisible.value = true)),
                        onInput: _cache[8] || (_cache[8] = (val) => handleTimeInput(val, "max")),
                        onChange: _cache[9] || (_cache[9] = (val) => handleTimeChange(val, "max"))
                      }, null, 8, ["class", "disabled", "placeholder", "model-value", "readonly"]),
                      vue.createVNode(vue.unref(TimePickPanel), {
                        "datetime-role": "end",
                        visible: maxTimePickerVisible.value,
                        format: vue.unref(timeFormat),
                        "time-arrow-control": vue.unref(arrowControl),
                        "parsed-value": rightDate.value,
                        onPick: handleMaxTimePick
                      }, null, 8, ["visible", "format", "time-arrow-control", "parsed-value"])
                    ], 2)), [
                      [vue.unref(ClickOutside), handleMaxTimeClose]
                    ])
                  ], 2)
                ], 2)) : vue.createCommentVNode("v-if", true),
                vue.createElementVNode("div", {
                  class: vue.normalizeClass([[vue.unref(ppNs).e("content"), vue.unref(drpNs).e("content")], "is-left"])
                }, [
                  vue.createElementVNode("div", {
                    class: vue.normalizeClass(vue.unref(drpNs).e("header"))
                  }, [
                    vue.createElementVNode("button", {
                      type: "button",
                      class: vue.normalizeClass([vue.unref(ppNs).e("icon-btn"), "d-arrow-left"]),
                      onClick: leftPrevYear
                    }, [
                      vue.createVNode(vue.unref(ElIcon), null, {
                        default: vue.withCtx(() => [
                          vue.createVNode(vue.unref(d_arrow_left_default))
                        ]),
                        _: 1
                      })
                    ], 2),
                    vue.createElementVNode("button", {
                      type: "button",
                      class: vue.normalizeClass([vue.unref(ppNs).e("icon-btn"), "arrow-left"]),
                      onClick: leftPrevMonth
                    }, [
                      vue.createVNode(vue.unref(ElIcon), null, {
                        default: vue.withCtx(() => [
                          vue.createVNode(vue.unref(arrow_left_default))
                        ]),
                        _: 1
                      })
                    ], 2),
                    _ctx.unlinkPanels ? (vue.openBlock(), vue.createElementBlock("button", {
                      key: 0,
                      type: "button",
                      disabled: !vue.unref(enableYearArrow),
                      class: vue.normalizeClass([[vue.unref(ppNs).e("icon-btn"), { "is-disabled": !vue.unref(enableYearArrow) }], "d-arrow-right"]),
                      onClick: leftNextYear
                    }, [
                      vue.createVNode(vue.unref(ElIcon), null, {
                        default: vue.withCtx(() => [
                          vue.createVNode(vue.unref(d_arrow_right_default))
                        ]),
                        _: 1
                      })
                    ], 10, _hoisted_2$p)) : vue.createCommentVNode("v-if", true),
                    _ctx.unlinkPanels ? (vue.openBlock(), vue.createElementBlock("button", {
                      key: 1,
                      type: "button",
                      disabled: !vue.unref(enableMonthArrow),
                      class: vue.normalizeClass([[
                        vue.unref(ppNs).e("icon-btn"),
                        { "is-disabled": !vue.unref(enableMonthArrow) }
                      ], "arrow-right"]),
                      onClick: leftNextMonth
                    }, [
                      vue.createVNode(vue.unref(ElIcon), null, {
                        default: vue.withCtx(() => [
                          vue.createVNode(vue.unref(arrow_right_default))
                        ]),
                        _: 1
                      })
                    ], 10, _hoisted_3$b)) : vue.createCommentVNode("v-if", true),
                    vue.createElementVNode("div", null, vue.toDisplayString(vue.unref(leftLabel)), 1)
                  ], 2),
                  vue.createVNode(DateTable, {
                    "selection-mode": "range",
                    date: leftDate.value,
                    "min-date": vue.unref(minDate),
                    "max-date": vue.unref(maxDate),
                    "range-state": vue.unref(rangeState),
                    "disabled-date": vue.unref(disabledDate),
                    "cell-class-name": vue.unref(cellClassName),
                    onChangerange: vue.unref(handleChangeRange),
                    onPick: handleRangePick,
                    onSelect: vue.unref(onSelect)
                  }, null, 8, ["date", "min-date", "max-date", "range-state", "disabled-date", "cell-class-name", "onChangerange", "onSelect"])
                ], 2),
                vue.createElementVNode("div", {
                  class: vue.normalizeClass([[vue.unref(ppNs).e("content"), vue.unref(drpNs).e("content")], "is-right"])
                }, [
                  vue.createElementVNode("div", {
                    class: vue.normalizeClass(vue.unref(drpNs).e("header"))
                  }, [
                    _ctx.unlinkPanels ? (vue.openBlock(), vue.createElementBlock("button", {
                      key: 0,
                      type: "button",
                      disabled: !vue.unref(enableYearArrow),
                      class: vue.normalizeClass([[vue.unref(ppNs).e("icon-btn"), { "is-disabled": !vue.unref(enableYearArrow) }], "d-arrow-left"]),
                      onClick: rightPrevYear
                    }, [
                      vue.createVNode(vue.unref(ElIcon), null, {
                        default: vue.withCtx(() => [
                          vue.createVNode(vue.unref(d_arrow_left_default))
                        ]),
                        _: 1
                      })
                    ], 10, _hoisted_4$8)) : vue.createCommentVNode("v-if", true),
                    _ctx.unlinkPanels ? (vue.openBlock(), vue.createElementBlock("button", {
                      key: 1,
                      type: "button",
                      disabled: !vue.unref(enableMonthArrow),
                      class: vue.normalizeClass([[
                        vue.unref(ppNs).e("icon-btn"),
                        { "is-disabled": !vue.unref(enableMonthArrow) }
                      ], "arrow-left"]),
                      onClick: rightPrevMonth
                    }, [
                      vue.createVNode(vue.unref(ElIcon), null, {
                        default: vue.withCtx(() => [
                          vue.createVNode(vue.unref(arrow_left_default))
                        ]),
                        _: 1
                      })
                    ], 10, _hoisted_5$6)) : vue.createCommentVNode("v-if", true),
                    vue.createElementVNode("button", {
                      type: "button",
                      class: vue.normalizeClass([vue.unref(ppNs).e("icon-btn"), "d-arrow-right"]),
                      onClick: rightNextYear
                    }, [
                      vue.createVNode(vue.unref(ElIcon), null, {
                        default: vue.withCtx(() => [
                          vue.createVNode(vue.unref(d_arrow_right_default))
                        ]),
                        _: 1
                      })
                    ], 2),
                    vue.createElementVNode("button", {
                      type: "button",
                      class: vue.normalizeClass([vue.unref(ppNs).e("icon-btn"), "arrow-right"]),
                      onClick: rightNextMonth
                    }, [
                      vue.createVNode(vue.unref(ElIcon), null, {
                        default: vue.withCtx(() => [
                          vue.createVNode(vue.unref(arrow_right_default))
                        ]),
                        _: 1
                      })
                    ], 2),
                    vue.createElementVNode("div", null, vue.toDisplayString(vue.unref(rightLabel)), 1)
                  ], 2),
                  vue.createVNode(DateTable, {
                    "selection-mode": "range",
                    date: rightDate.value,
                    "min-date": vue.unref(minDate),
                    "max-date": vue.unref(maxDate),
                    "range-state": vue.unref(rangeState),
                    "disabled-date": vue.unref(disabledDate),
                    "cell-class-name": vue.unref(cellClassName),
                    onChangerange: vue.unref(handleChangeRange),
                    onPick: handleRangePick,
                    onSelect: vue.unref(onSelect)
                  }, null, 8, ["date", "min-date", "max-date", "range-state", "disabled-date", "cell-class-name", "onChangerange", "onSelect"])
                ], 2)
              ], 2)
            ], 2),
            vue.unref(showTime) ? (vue.openBlock(), vue.createElementBlock("div", {
              key: 0,
              class: vue.normalizeClass(vue.unref(ppNs).e("footer"))
            }, [
              vue.unref(clearable) ? (vue.openBlock(), vue.createBlock(vue.unref(ElButton), {
                key: 0,
                text: "",
                size: "small",
                class: vue.normalizeClass(vue.unref(ppNs).e("link-btn")),
                onClick: handleClear
              }, {
                default: vue.withCtx(() => [
                  vue.createTextVNode(vue.toDisplayString(vue.unref(t)("el.datepicker.clear")), 1)
                ]),
                _: 1
              }, 8, ["class"])) : vue.createCommentVNode("v-if", true),
              vue.createVNode(vue.unref(ElButton), {
                plain: "",
                size: "small",
                class: vue.normalizeClass(vue.unref(ppNs).e("link-btn")),
                disabled: vue.unref(btnDisabled),
                onClick: _cache[10] || (_cache[10] = ($event) => vue.unref(handleRangeConfirm)(false))
              }, {
                default: vue.withCtx(() => [
                  vue.createTextVNode(vue.toDisplayString(vue.unref(t)("el.datepicker.confirm")), 1)
                ]),
                _: 1
              }, 8, ["class", "disabled"])
            ], 2)) : vue.createCommentVNode("v-if", true)
          ], 2);
        };
      }
    });
    var DateRangePickPanel = /* @__PURE__ */ _export_sfc(_sfc_main$1h, [["__file", "panel-date-range.vue"]]);
  
    const panelMonthRangeProps = buildProps({
      ...panelRangeSharedProps
    });
    const panelMonthRangeEmits = ["pick", "set-picker-option"];
  
    const useMonthRangeHeader = ({
      unlinkPanels,
      leftDate,
      rightDate
    }) => {
      const { t } = useLocale();
      const leftPrevYear = () => {
        leftDate.value = leftDate.value.subtract(1, "year");
        if (!unlinkPanels.value) {
          rightDate.value = rightDate.value.subtract(1, "year");
        }
      };
      const rightNextYear = () => {
        if (!unlinkPanels.value) {
          leftDate.value = leftDate.value.add(1, "year");
        }
        rightDate.value = rightDate.value.add(1, "year");
      };
      const leftNextYear = () => {
        leftDate.value = leftDate.value.add(1, "year");
      };
      const rightPrevYear = () => {
        rightDate.value = rightDate.value.subtract(1, "year");
      };
      const leftLabel = vue.computed(() => {
        return `${leftDate.value.year()} ${t("el.datepicker.year")}`;
      });
      const rightLabel = vue.computed(() => {
        return `${rightDate.value.year()} ${t("el.datepicker.year")}`;
      });
      const leftYear = vue.computed(() => {
        return leftDate.value.year();
      });
      const rightYear = vue.computed(() => {
        return rightDate.value.year() === leftDate.value.year() ? leftDate.value.year() + 1 : rightDate.value.year();
      });
      return {
        leftPrevYear,
        rightNextYear,
        leftNextYear,
        rightPrevYear,
        leftLabel,
        rightLabel,
        leftYear,
        rightYear
      };
    };
  
    const _hoisted_1$E = ["onClick"];
    const _hoisted_2$o = ["disabled"];
    const _hoisted_3$a = ["disabled"];
    const unit = "year";
    const __default__$Q = vue.defineComponent({
      name: "DatePickerMonthRange"
    });
    const _sfc_main$1g = /* @__PURE__ */ vue.defineComponent({
      ...__default__$Q,
      props: panelMonthRangeProps,
      emits: panelMonthRangeEmits,
      setup(__props, { emit }) {
        const props = __props;
        const { lang } = useLocale();
        const pickerBase = vue.inject("EP_PICKER_BASE");
        const { shortcuts, disabledDate, format } = pickerBase.props;
        const defaultValue = vue.toRef(pickerBase.props, "defaultValue");
        const leftDate = vue.ref(dayjs().locale(lang.value));
        const rightDate = vue.ref(dayjs().locale(lang.value).add(1, unit));
        const {
          minDate,
          maxDate,
          rangeState,
          ppNs,
          drpNs,
          handleChangeRange,
          handleRangeConfirm,
          handleShortcutClick,
          onSelect
        } = useRangePicker(props, {
          defaultValue,
          leftDate,
          rightDate,
          unit,
          onParsedValueChanged
        });
        const hasShortcuts = vue.computed(() => !!shortcuts.length);
        const {
          leftPrevYear,
          rightNextYear,
          leftNextYear,
          rightPrevYear,
          leftLabel,
          rightLabel,
          leftYear,
          rightYear
        } = useMonthRangeHeader({
          unlinkPanels: vue.toRef(props, "unlinkPanels"),
          leftDate,
          rightDate
        });
        const enableYearArrow = vue.computed(() => {
          return props.unlinkPanels && rightYear.value > leftYear.value + 1;
        });
        const handleRangePick = (val, close = true) => {
          const minDate_ = val.minDate;
          const maxDate_ = val.maxDate;
          if (maxDate.value === maxDate_ && minDate.value === minDate_) {
            return;
          }
          maxDate.value = maxDate_;
          minDate.value = minDate_;
          if (!close)
            return;
          handleRangeConfirm();
        };
        const formatToString = (days) => {
          return days.map((day) => day.format(format));
        };
        function onParsedValueChanged(minDate2, maxDate2) {
          if (props.unlinkPanels && maxDate2) {
            const minDateYear = (minDate2 == null ? void 0 : minDate2.year()) || 0;
            const maxDateYear = maxDate2.year();
            rightDate.value = minDateYear === maxDateYear ? maxDate2.add(1, unit) : maxDate2;
          } else {
            rightDate.value = leftDate.value.add(1, unit);
          }
        }
        emit("set-picker-option", ["formatToString", formatToString]);
        return (_ctx, _cache) => {
          return vue.openBlock(), vue.createElementBlock("div", {
            class: vue.normalizeClass([
              vue.unref(ppNs).b(),
              vue.unref(drpNs).b(),
              {
                "has-sidebar": Boolean(_ctx.$slots.sidebar) || vue.unref(hasShortcuts)
              }
            ])
          }, [
            vue.createElementVNode("div", {
              class: vue.normalizeClass(vue.unref(ppNs).e("body-wrapper"))
            }, [
              vue.renderSlot(_ctx.$slots, "sidebar", {
                class: vue.normalizeClass(vue.unref(ppNs).e("sidebar"))
              }),
              vue.unref(hasShortcuts) ? (vue.openBlock(), vue.createElementBlock("div", {
                key: 0,
                class: vue.normalizeClass(vue.unref(ppNs).e("sidebar"))
              }, [
                (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(vue.unref(shortcuts), (shortcut, key) => {
                  return vue.openBlock(), vue.createElementBlock("button", {
                    key,
                    type: "button",
                    class: vue.normalizeClass(vue.unref(ppNs).e("shortcut")),
                    onClick: ($event) => vue.unref(handleShortcutClick)(shortcut)
                  }, vue.toDisplayString(shortcut.text), 11, _hoisted_1$E);
                }), 128))
              ], 2)) : vue.createCommentVNode("v-if", true),
              vue.createElementVNode("div", {
                class: vue.normalizeClass(vue.unref(ppNs).e("body"))
              }, [
                vue.createElementVNode("div", {
                  class: vue.normalizeClass([[vue.unref(ppNs).e("content"), vue.unref(drpNs).e("content")], "is-left"])
                }, [
                  vue.createElementVNode("div", {
                    class: vue.normalizeClass(vue.unref(drpNs).e("header"))
                  }, [
                    vue.createElementVNode("button", {
                      type: "button",
                      class: vue.normalizeClass([vue.unref(ppNs).e("icon-btn"), "d-arrow-left"]),
                      onClick: _cache[0] || (_cache[0] = (...args) => vue.unref(leftPrevYear) && vue.unref(leftPrevYear)(...args))
                    }, [
                      vue.createVNode(vue.unref(ElIcon), null, {
                        default: vue.withCtx(() => [
                          vue.createVNode(vue.unref(d_arrow_left_default))
                        ]),
                        _: 1
                      })
                    ], 2),
                    _ctx.unlinkPanels ? (vue.openBlock(), vue.createElementBlock("button", {
                      key: 0,
                      type: "button",
                      disabled: !vue.unref(enableYearArrow),
                      class: vue.normalizeClass([[
                        vue.unref(ppNs).e("icon-btn"),
                        { [vue.unref(ppNs).is("disabled")]: !vue.unref(enableYearArrow) }
                      ], "d-arrow-right"]),
                      onClick: _cache[1] || (_cache[1] = (...args) => vue.unref(leftNextYear) && vue.unref(leftNextYear)(...args))
                    }, [
                      vue.createVNode(vue.unref(ElIcon), null, {
                        default: vue.withCtx(() => [
                          vue.createVNode(vue.unref(d_arrow_right_default))
                        ]),
                        _: 1
                      })
                    ], 10, _hoisted_2$o)) : vue.createCommentVNode("v-if", true),
                    vue.createElementVNode("div", null, vue.toDisplayString(vue.unref(leftLabel)), 1)
                  ], 2),
                  vue.createVNode(MonthTable, {
                    "selection-mode": "range",
                    date: leftDate.value,
                    "min-date": vue.unref(minDate),
                    "max-date": vue.unref(maxDate),
                    "range-state": vue.unref(rangeState),
                    "disabled-date": vue.unref(disabledDate),
                    onChangerange: vue.unref(handleChangeRange),
                    onPick: handleRangePick,
                    onSelect: vue.unref(onSelect)
                  }, null, 8, ["date", "min-date", "max-date", "range-state", "disabled-date", "onChangerange", "onSelect"])
                ], 2),
                vue.createElementVNode("div", {
                  class: vue.normalizeClass([[vue.unref(ppNs).e("content"), vue.unref(drpNs).e("content")], "is-right"])
                }, [
                  vue.createElementVNode("div", {
                    class: vue.normalizeClass(vue.unref(drpNs).e("header"))
                  }, [
                    _ctx.unlinkPanels ? (vue.openBlock(), vue.createElementBlock("button", {
                      key: 0,
                      type: "button",
                      disabled: !vue.unref(enableYearArrow),
                      class: vue.normalizeClass([[vue.unref(ppNs).e("icon-btn"), { "is-disabled": !vue.unref(enableYearArrow) }], "d-arrow-left"]),
                      onClick: _cache[2] || (_cache[2] = (...args) => vue.unref(rightPrevYear) && vue.unref(rightPrevYear)(...args))
                    }, [
                      vue.createVNode(vue.unref(ElIcon), null, {
                        default: vue.withCtx(() => [
                          vue.createVNode(vue.unref(d_arrow_left_default))
                        ]),
                        _: 1
                      })
                    ], 10, _hoisted_3$a)) : vue.createCommentVNode("v-if", true),
                    vue.createElementVNode("button", {
                      type: "button",
                      class: vue.normalizeClass([vue.unref(ppNs).e("icon-btn"), "d-arrow-right"]),
                      onClick: _cache[3] || (_cache[3] = (...args) => vue.unref(rightNextYear) && vue.unref(rightNextYear)(...args))
                    }, [
                      vue.createVNode(vue.unref(ElIcon), null, {
                        default: vue.withCtx(() => [
                          vue.createVNode(vue.unref(d_arrow_right_default))
                        ]),
                        _: 1
                      })
                    ], 2),
                    vue.createElementVNode("div", null, vue.toDisplayString(vue.unref(rightLabel)), 1)
                  ], 2),
                  vue.createVNode(MonthTable, {
                    "selection-mode": "range",
                    date: rightDate.value,
                    "min-date": vue.unref(minDate),
                    "max-date": vue.unref(maxDate),
                    "range-state": vue.unref(rangeState),
                    "disabled-date": vue.unref(disabledDate),
                    onChangerange: vue.unref(handleChangeRange),
                    onPick: handleRangePick,
                    onSelect: vue.unref(onSelect)
                  }, null, 8, ["date", "min-date", "max-date", "range-state", "disabled-date", "onChangerange", "onSelect"])
                ], 2)
              ], 2)
            ], 2)
          ], 2);
        };
      }
    });
    var MonthRangePickPanel = /* @__PURE__ */ _export_sfc(_sfc_main$1g, [["__file", "panel-month-range.vue"]]);
  
    const getPanel = function(type) {
      switch (type) {
        case "daterange":
        case "datetimerange": {
          return DateRangePickPanel;
        }
        case "monthrange": {
          return MonthRangePickPanel;
        }
        default: {
          return DatePickPanel;
        }
      }
    };
  
    dayjs.extend(localeData);
    dayjs.extend(advancedFormat);
    dayjs.extend(customParseFormat);
    dayjs.extend(weekOfYear);
    dayjs.extend(weekYear);
    dayjs.extend(dayOfYear);
    dayjs.extend(isSameOrAfter);
    dayjs.extend(isSameOrBefore);
    var DatePicker = vue.defineComponent({
      name: "ElDatePicker",
      install: null,
      props: {
        ...timePickerDefaultProps,
        ...datePickerProps
      },
      emits: ["update:modelValue"],
      setup(props, {
        expose,
        emit,
        slots
      }) {
        const ns = useNamespace("picker-panel");
        vue.provide("ElPopperOptions", vue.reactive(vue.toRef(props, "popperOptions")));
        vue.provide(ROOT_PICKER_INJECTION_KEY, {
          slots,
          pickerNs: ns
        });
        const commonPicker = vue.ref();
        const refProps = {
          focus: (focusStartInput = true) => {
            var _a;
            (_a = commonPicker.value) == null ? void 0 : _a.focus(focusStartInput);
          },
          handleOpen: () => {
            var _a;
            (_a = commonPicker.value) == null ? void 0 : _a.handleOpen();
          },
          handleClose: () => {
            var _a;
            (_a = commonPicker.value) == null ? void 0 : _a.handleClose();
          }
        };
        expose(refProps);
        const onModelValueUpdated = (val) => {
          emit("update:modelValue", val);
        };
        return () => {
          var _a;
          const format = (_a = props.format) != null ? _a : DEFAULT_FORMATS_DATEPICKER[props.type] || DEFAULT_FORMATS_DATE;
          const Component = getPanel(props.type);
          return vue.createVNode(CommonPicker, vue.mergeProps(props, {
            "format": format,
            "type": props.type,
            "ref": commonPicker,
            "onUpdate:modelValue": onModelValueUpdated
          }), {
            default: (scopedProps) => vue.createVNode(Component, scopedProps, null),
            "range-separator": slots["range-separator"]
          });
        };
      }
    });
  
    const _DatePicker = DatePicker;
    _DatePicker.install = (app) => {
      app.component(_DatePicker.name, _DatePicker);
    };
    const ElDatePicker = _DatePicker;
  
    const descriptionsKey = "elDescriptions";
  
    var ElDescriptionsCell = vue.defineComponent({
      name: "ElDescriptionsCell",
      props: {
        cell: {
          type: Object
        },
        tag: {
          type: String
        },
        type: {
          type: String
        }
      },
      setup() {
        const descriptions = vue.inject(descriptionsKey, {});
        return {
          descriptions
        };
      },
      render() {
        var _a, _b, _c, _d, _e, _f;
        const item = getNormalizedProps(this.cell);
        const { border, direction } = this.descriptions;
        const isVertical = direction === "vertical";
        const label = ((_c = (_b = (_a = this.cell) == null ? void 0 : _a.children) == null ? void 0 : _b.label) == null ? void 0 : _c.call(_b)) || item.label;
        const content = (_f = (_e = (_d = this.cell) == null ? void 0 : _d.children) == null ? void 0 : _e.default) == null ? void 0 : _f.call(_e);
        const span = item.span;
        const align = item.align ? `is-${item.align}` : "";
        const labelAlign = item.labelAlign ? `is-${item.labelAlign}` : align;
        const className = item.className;
        const labelClassName = item.labelClassName;
        const style = {
          width: addUnit(item.width),
          minWidth: addUnit(item.minWidth)
        };
        const ns = useNamespace("descriptions");
        switch (this.type) {
          case "label":
            return vue.h(this.tag, {
              style,
              class: [
                ns.e("cell"),
                ns.e("label"),
                ns.is("bordered-label", border),
                ns.is("vertical-label", isVertical),
                labelAlign,
                labelClassName
              ],
              colSpan: isVertical ? span : 1
            }, label);
          case "content":
            return vue.h(this.tag, {
              style,
              class: [
                ns.e("cell"),
                ns.e("content"),
                ns.is("bordered-content", border),
                ns.is("vertical-content", isVertical),
                align,
                className
              ],
              colSpan: isVertical ? span : span * 2 - 1
            }, content);
          default:
            return vue.h("td", {
              style,
              class: [ns.e("cell"), align],
              colSpan: span
            }, [
              vue.h("span", {
                class: [ns.e("label"), labelClassName]
              }, label),
              vue.h("span", {
                class: [ns.e("content"), className]
              }, content)
            ]);
        }
      }
    });
  
    const descriptionsRowProps = buildProps({
      row: {
        type: Array,
        default: () => []
      }
    });
  
    const _hoisted_1$D = { key: 1 };
    const __default__$P = vue.defineComponent({
      name: "ElDescriptionsRow"
    });
    const _sfc_main$1f = /* @__PURE__ */ vue.defineComponent({
      ...__default__$P,
      props: descriptionsRowProps,
      setup(__props) {
        const descriptions = vue.inject(descriptionsKey, {});
        return (_ctx, _cache) => {
          return vue.unref(descriptions).direction === "vertical" ? (vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: 0 }, [
            vue.createElementVNode("tr", null, [
              (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(_ctx.row, (cell, index) => {
                return vue.openBlock(), vue.createBlock(vue.unref(ElDescriptionsCell), {
                  key: `tr1-${index}`,
                  cell,
                  tag: "th",
                  type: "label"
                }, null, 8, ["cell"]);
              }), 128))
            ]),
            vue.createElementVNode("tr", null, [
              (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(_ctx.row, (cell, index) => {
                return vue.openBlock(), vue.createBlock(vue.unref(ElDescriptionsCell), {
                  key: `tr2-${index}`,
                  cell,
                  tag: "td",
                  type: "content"
                }, null, 8, ["cell"]);
              }), 128))
            ])
          ], 64)) : (vue.openBlock(), vue.createElementBlock("tr", _hoisted_1$D, [
            (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(_ctx.row, (cell, index) => {
              return vue.openBlock(), vue.createElementBlock(vue.Fragment, {
                key: `tr3-${index}`
              }, [
                vue.unref(descriptions).border ? (vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: 0 }, [
                  vue.createVNode(vue.unref(ElDescriptionsCell), {
                    cell,
                    tag: "td",
                    type: "label"
                  }, null, 8, ["cell"]),
                  vue.createVNode(vue.unref(ElDescriptionsCell), {
                    cell,
                    tag: "td",
                    type: "content"
                  }, null, 8, ["cell"])
                ], 64)) : (vue.openBlock(), vue.createBlock(vue.unref(ElDescriptionsCell), {
                  key: 1,
                  cell,
                  tag: "td",
                  type: "both"
                }, null, 8, ["cell"]))
              ], 64);
            }), 128))
          ]));
        };
      }
    });
    var ElDescriptionsRow = /* @__PURE__ */ _export_sfc(_sfc_main$1f, [["__file", "descriptions-row.vue"]]);
  
    const descriptionProps = buildProps({
      border: {
        type: Boolean,
        default: false
      },
      column: {
        type: Number,
        default: 3
      },
      direction: {
        type: String,
        values: ["horizontal", "vertical"],
        default: "horizontal"
      },
      size: useSizeProp,
      title: {
        type: String,
        default: ""
      },
      extra: {
        type: String,
        default: ""
      }
    });
  
    const __default__$O = vue.defineComponent({
      name: "ElDescriptions"
    });
    const _sfc_main$1e = /* @__PURE__ */ vue.defineComponent({
      ...__default__$O,
      props: descriptionProps,
      setup(__props) {
        const props = __props;
        const ns = useNamespace("descriptions");
        const descriptionsSize = useSize();
        const slots = vue.useSlots();
        vue.provide(descriptionsKey, props);
        const descriptionKls = vue.computed(() => [ns.b(), ns.m(descriptionsSize.value)]);
        const filledNode = (node, span, count, isLast = false) => {
          if (!node.props) {
            node.props = {};
          }
          if (span > count) {
            node.props.span = count;
          }
          if (isLast) {
            node.props.span = span;
          }
          return node;
        };
        const getRows = () => {
          var _a;
          const children = flattedChildren((_a = slots.default) == null ? void 0 : _a.call(slots)).filter((node) => {
            var _a2;
            return ((_a2 = node == null ? void 0 : node.type) == null ? void 0 : _a2.name) === "ElDescriptionsItem";
          });
          const rows = [];
          let temp = [];
          let count = props.column;
          let totalSpan = 0;
          children.forEach((node, index) => {
            var _a2;
            const span = ((_a2 = node.props) == null ? void 0 : _a2.span) || 1;
            if (index < children.length - 1) {
              totalSpan += span > count ? count : span;
            }
            if (index === children.length - 1) {
              const lastSpan = props.column - totalSpan % props.column;
              temp.push(filledNode(node, lastSpan, count, true));
              rows.push(temp);
              return;
            }
            if (span < count) {
              count -= span;
              temp.push(node);
            } else {
              temp.push(filledNode(node, span, count));
              rows.push(temp);
              count = props.column;
              temp = [];
            }
          });
          return rows;
        };
        return (_ctx, _cache) => {
          return vue.openBlock(), vue.createElementBlock("div", {
            class: vue.normalizeClass(vue.unref(descriptionKls))
          }, [
            _ctx.title || _ctx.extra || _ctx.$slots.title || _ctx.$slots.extra ? (vue.openBlock(), vue.createElementBlock("div", {
              key: 0,
              class: vue.normalizeClass(vue.unref(ns).e("header"))
            }, [
              vue.createElementVNode("div", {
                class: vue.normalizeClass(vue.unref(ns).e("title"))
              }, [
                vue.renderSlot(_ctx.$slots, "title", {}, () => [
                  vue.createTextVNode(vue.toDisplayString(_ctx.title), 1)
                ])
              ], 2),
              vue.createElementVNode("div", {
                class: vue.normalizeClass(vue.unref(ns).e("extra"))
              }, [
                vue.renderSlot(_ctx.$slots, "extra", {}, () => [
                  vue.createTextVNode(vue.toDisplayString(_ctx.extra), 1)
                ])
              ], 2)
            ], 2)) : vue.createCommentVNode("v-if", true),
            vue.createElementVNode("div", {
              class: vue.normalizeClass(vue.unref(ns).e("body"))
            }, [
              vue.createElementVNode("table", {
                class: vue.normalizeClass([vue.unref(ns).e("table"), vue.unref(ns).is("bordered", _ctx.border)])
              }, [
                vue.createElementVNode("tbody", null, [
                  (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(getRows(), (row, index) => {
                    return vue.openBlock(), vue.createBlock(ElDescriptionsRow, {
                      key: index,
                      row
                    }, null, 8, ["row"]);
                  }), 128))
                ])
              ], 2)
            ], 2)
          ], 2);
        };
      }
    });
    var Descriptions = /* @__PURE__ */ _export_sfc(_sfc_main$1e, [["__file", "description.vue"]]);
  
    var DescriptionsItem = vue.defineComponent({
      name: "ElDescriptionsItem",
      props: {
        label: {
          type: String,
          default: ""
        },
        span: {
          type: Number,
          default: 1
        },
        width: {
          type: [String, Number],
          default: ""
        },
        minWidth: {
          type: [String, Number],
          default: ""
        },
        align: {
          type: String,
          default: "left"
        },
        labelAlign: {
          type: String,
          default: ""
        },
        className: {
          type: String,
          default: ""
        },
        labelClassName: {
          type: String,
          default: ""
        }
      }
    });
  
    const ElDescriptions = withInstall(Descriptions, {
      DescriptionsItem
    });
    const ElDescriptionsItem = withNoopInstall(DescriptionsItem);
  
    const overlayProps = buildProps({
      mask: {
        type: Boolean,
        default: true
      },
      customMaskEvent: {
        type: Boolean,
        default: false
      },
      overlayClass: {
        type: definePropType([
          String,
          Array,
          Object
        ])
      },
      zIndex: {
        type: definePropType([String, Number])
      }
    });
    const overlayEmits = {
      click: (evt) => evt instanceof MouseEvent
    };
    var Overlay$1 = vue.defineComponent({
      name: "ElOverlay",
      props: overlayProps,
      emits: overlayEmits,
      setup(props, { slots, emit }) {
        const ns = useNamespace("overlay");
        const onMaskClick = (e) => {
          emit("click", e);
        };
        const { onClick, onMousedown, onMouseup } = useSameTarget(props.customMaskEvent ? void 0 : onMaskClick);
        return () => {
          return props.mask ? vue.createVNode("div", {
            class: [ns.b(), props.overlayClass],
            style: {
              zIndex: props.zIndex
            },
            onClick,
            onMousedown,
            onMouseup
          }, [vue.renderSlot(slots, "default")], PatchFlags.STYLE | PatchFlags.CLASS | PatchFlags.PROPS, ["onClick", "onMouseup", "onMousedown"]) : vue.h("div", {
            class: props.overlayClass,
            style: {
              zIndex: props.zIndex,
              position: "fixed",
              top: "0px",
              right: "0px",
              bottom: "0px",
              left: "0px"
            }
          }, [vue.renderSlot(slots, "default")]);
        };
      }
    });
  
    const ElOverlay = Overlay$1;
  
    const dialogContentProps = buildProps({
      center: {
        type: Boolean,
        default: false
      },
      alignCenter: {
        type: Boolean,
        default: false
      },
      closeIcon: {
        type: iconPropType
      },
      customClass: {
        type: String,
        default: ""
      },
      draggable: {
        type: Boolean,
        default: false
      },
      fullscreen: {
        type: Boolean,
        default: false
      },
      showClose: {
        type: Boolean,
        default: true
      },
      title: {
        type: String,
        default: ""
      }
    });
    const dialogContentEmits = {
      close: () => true
    };
  
    const _hoisted_1$C = ["aria-label"];
    const _hoisted_2$n = ["id"];
    const __default__$N = vue.defineComponent({ name: "ElDialogContent" });
    const _sfc_main$1d = /* @__PURE__ */ vue.defineComponent({
      ...__default__$N,
      props: dialogContentProps,
      emits: dialogContentEmits,
      setup(__props) {
        const props = __props;
        const { t } = useLocale();
        const { Close } = CloseComponents;
        const { dialogRef, headerRef, bodyId, ns, style } = vue.inject(dialogInjectionKey);
        const { focusTrapRef } = vue.inject(FOCUS_TRAP_INJECTION_KEY);
        const composedDialogRef = composeRefs(focusTrapRef, dialogRef);
        const draggable = vue.computed(() => props.draggable);
        useDraggable(dialogRef, headerRef, draggable);
        return (_ctx, _cache) => {
          return vue.openBlock(), vue.createElementBlock("div", {
            ref: vue.unref(composedDialogRef),
            class: vue.normalizeClass([
              vue.unref(ns).b(),
              vue.unref(ns).is("fullscreen", _ctx.fullscreen),
              vue.unref(ns).is("draggable", vue.unref(draggable)),
              vue.unref(ns).is("align-center", _ctx.alignCenter),
              { [vue.unref(ns).m("center")]: _ctx.center },
              _ctx.customClass
            ]),
            style: vue.normalizeStyle(vue.unref(style)),
            tabindex: "-1"
          }, [
            vue.createElementVNode("header", {
              ref_key: "headerRef",
              ref: headerRef,
              class: vue.normalizeClass(vue.unref(ns).e("header"))
            }, [
              vue.renderSlot(_ctx.$slots, "header", {}, () => [
                vue.createElementVNode("span", {
                  role: "heading",
                  class: vue.normalizeClass(vue.unref(ns).e("title"))
                }, vue.toDisplayString(_ctx.title), 3)
              ]),
              _ctx.showClose ? (vue.openBlock(), vue.createElementBlock("button", {
                key: 0,
                "aria-label": vue.unref(t)("el.dialog.close"),
                class: vue.normalizeClass(vue.unref(ns).e("headerbtn")),
                type: "button",
                onClick: _cache[0] || (_cache[0] = ($event) => _ctx.$emit("close"))
              }, [
                vue.createVNode(vue.unref(ElIcon), {
                  class: vue.normalizeClass(vue.unref(ns).e("close"))
                }, {
                  default: vue.withCtx(() => [
                    (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(_ctx.closeIcon || vue.unref(Close))))
                  ]),
                  _: 1
                }, 8, ["class"])
              ], 10, _hoisted_1$C)) : vue.createCommentVNode("v-if", true)
            ], 2),
            vue.createElementVNode("div", {
              id: vue.unref(bodyId),
              class: vue.normalizeClass(vue.unref(ns).e("body"))
            }, [
              vue.renderSlot(_ctx.$slots, "default")
            ], 10, _hoisted_2$n),
            _ctx.$slots.footer ? (vue.openBlock(), vue.createElementBlock("footer", {
              key: 0,
              class: vue.normalizeClass(vue.unref(ns).e("footer"))
            }, [
              vue.renderSlot(_ctx.$slots, "footer")
            ], 2)) : vue.createCommentVNode("v-if", true)
          ], 6);
        };
      }
    });
    var ElDialogContent = /* @__PURE__ */ _export_sfc(_sfc_main$1d, [["__file", "dialog-content.vue"]]);
  
    const dialogProps = buildProps({
      ...dialogContentProps,
      appendToBody: {
        type: Boolean,
        default: false
      },
      beforeClose: {
        type: definePropType(Function)
      },
      destroyOnClose: {
        type: Boolean,
        default: false
      },
      closeOnClickModal: {
        type: Boolean,
        default: true
      },
      closeOnPressEscape: {
        type: Boolean,
        default: true
      },
      lockScroll: {
        type: Boolean,
        default: true
      },
      modal: {
        type: Boolean,
        default: true
      },
      openDelay: {
        type: Number,
        default: 0
      },
      closeDelay: {
        type: Number,
        default: 0
      },
      top: {
        type: String
      },
      modelValue: {
        type: Boolean,
        default: false
      },
      modalClass: String,
      width: {
        type: [String, Number]
      },
      zIndex: {
        type: Number
      },
      trapFocus: {
        type: Boolean,
        default: false
      }
    });
    const dialogEmits = {
      open: () => true,
      opened: () => true,
      close: () => true,
      closed: () => true,
      [UPDATE_MODEL_EVENT]: (value) => isBoolean(value),
      openAutoFocus: () => true,
      closeAutoFocus: () => true
    };
  
    const useDialog = (props, targetRef) => {
      const instance = vue.getCurrentInstance();
      const emit = instance.emit;
      const { nextZIndex } = useZIndex();
      let lastPosition = "";
      const titleId = useId();
      const bodyId = useId();
      const visible = vue.ref(false);
      const closed = vue.ref(false);
      const rendered = vue.ref(false);
      const zIndex = vue.ref(props.zIndex || nextZIndex());
      let openTimer = void 0;
      let closeTimer = void 0;
      const namespace = useGlobalConfig("namespace", defaultNamespace);
      const style = vue.computed(() => {
        const style2 = {};
        const varPrefix = `--${namespace.value}-dialog`;
        if (!props.fullscreen) {
          if (props.top) {
            style2[`${varPrefix}-margin-top`] = props.top;
          }
          if (props.width) {
            style2[`${varPrefix}-width`] = addUnit(props.width);
          }
        }
        return style2;
      });
      const overlayDialogStyle = vue.computed(() => {
        if (props.alignCenter) {
          return { display: "flex" };
        }
        return {};
      });
      function afterEnter() {
        emit("opened");
      }
      function afterLeave() {
        emit("closed");
        emit(UPDATE_MODEL_EVENT, false);
        if (props.destroyOnClose) {
          rendered.value = false;
        }
      }
      function beforeLeave() {
        emit("close");
      }
      function open() {
        closeTimer == null ? void 0 : closeTimer();
        openTimer == null ? void 0 : openTimer();
        if (props.openDelay && props.openDelay > 0) {
          ({ stop: openTimer } = useTimeoutFn(() => doOpen(), props.openDelay));
        } else {
          doOpen();
        }
      }
      function close() {
        openTimer == null ? void 0 : openTimer();
        closeTimer == null ? void 0 : closeTimer();
        if (props.closeDelay && props.closeDelay > 0) {
          ({ stop: closeTimer } = useTimeoutFn(() => doClose(), props.closeDelay));
        } else {
          doClose();
        }
      }
      function handleClose() {
        function hide(shouldCancel) {
          if (shouldCancel)
            return;
          closed.value = true;
          visible.value = false;
        }
        if (props.beforeClose) {
          props.beforeClose(hide);
        } else {
          close();
        }
      }
      function onModalClick() {
        if (props.closeOnClickModal) {
          handleClose();
        }
      }
      function doOpen() {
        if (!isClient)
          return;
        visible.value = true;
      }
      function doClose() {
        visible.value = false;
      }
      function onOpenAutoFocus() {
        emit("openAutoFocus");
      }
      function onCloseAutoFocus() {
        emit("closeAutoFocus");
      }
      function onFocusoutPrevented(event) {
        var _a;
        if (((_a = event.detail) == null ? void 0 : _a.focusReason) === "pointer") {
          event.preventDefault();
        }
      }
      if (props.lockScroll) {
        useLockscreen(visible);
      }
      function onCloseRequested() {
        if (props.closeOnPressEscape) {
          handleClose();
        }
      }
      vue.watch(() => props.modelValue, (val) => {
        if (val) {
          closed.value = false;
          open();
          rendered.value = true;
          zIndex.value = props.zIndex ? zIndex.value++ : nextZIndex();
          vue.nextTick(() => {
            emit("open");
            if (targetRef.value) {
              targetRef.value.scrollTop = 0;
            }
          });
        } else {
          if (visible.value) {
            close();
          }
        }
      });
      vue.watch(() => props.fullscreen, (val) => {
        if (!targetRef.value)
          return;
        if (val) {
          lastPosition = targetRef.value.style.transform;
          targetRef.value.style.transform = "";
        } else {
          targetRef.value.style.transform = lastPosition;
        }
      });
      vue.onMounted(() => {
        if (props.modelValue) {
          visible.value = true;
          rendered.value = true;
          open();
        }
      });
      return {
        afterEnter,
        afterLeave,
        beforeLeave,
        handleClose,
        onModalClick,
        close,
        doClose,
        onOpenAutoFocus,
        onCloseAutoFocus,
        onCloseRequested,
        onFocusoutPrevented,
        titleId,
        bodyId,
        closed,
        style,
        overlayDialogStyle,
        rendered,
        visible,
        zIndex
      };
    };
  
    const _hoisted_1$B = ["aria-label", "aria-labelledby", "aria-describedby"];
    const __default__$M = vue.defineComponent({
      name: "ElDialog",
      inheritAttrs: false
    });
    const _sfc_main$1c = /* @__PURE__ */ vue.defineComponent({
      ...__default__$M,
      props: dialogProps,
      emits: dialogEmits,
      setup(__props, { expose }) {
        const props = __props;
        const slots = vue.useSlots();
        useDeprecated({
          scope: "el-dialog",
          from: "the title slot",
          replacement: "the header slot",
          version: "3.0.0",
          ref: "https://element-plus.org/en-US/component/dialog.html#slots"
        }, vue.computed(() => !!slots.title));
        useDeprecated({
          scope: "el-dialog",
          from: "custom-class",
          replacement: "class",
          version: "2.3.0",
          ref: "https://element-plus.org/en-US/component/dialog.html#attributes",
          type: "Attribute"
        }, vue.computed(() => !!props.customClass));
        const ns = useNamespace("dialog");
        const dialogRef = vue.ref();
        const headerRef = vue.ref();
        const dialogContentRef = vue.ref();
        const {
          visible,
          titleId,
          bodyId,
          style,
          overlayDialogStyle,
          rendered,
          zIndex,
          afterEnter,
          afterLeave,
          beforeLeave,
          handleClose,
          onModalClick,
          onOpenAutoFocus,
          onCloseAutoFocus,
          onCloseRequested,
          onFocusoutPrevented
        } = useDialog(props, dialogRef);
        vue.provide(dialogInjectionKey, {
          dialogRef,
          headerRef,
          bodyId,
          ns,
          rendered,
          style
        });
        const overlayEvent = useSameTarget(onModalClick);
        const draggable = vue.computed(() => props.draggable && !props.fullscreen);
        expose({
          visible,
          dialogContentRef
        });
        return (_ctx, _cache) => {
          return vue.openBlock(), vue.createBlock(vue.Teleport, {
            to: "body",
            disabled: !_ctx.appendToBody
          }, [
            vue.createVNode(vue.Transition, {
              name: "dialog-fade",
              onAfterEnter: vue.unref(afterEnter),
              onAfterLeave: vue.unref(afterLeave),
              onBeforeLeave: vue.unref(beforeLeave),
              persisted: ""
            }, {
              default: vue.withCtx(() => [
                vue.withDirectives(vue.createVNode(vue.unref(ElOverlay), {
                  "custom-mask-event": "",
                  mask: _ctx.modal,
                  "overlay-class": _ctx.modalClass,
                  "z-index": vue.unref(zIndex)
                }, {
                  default: vue.withCtx(() => [
                    vue.createElementVNode("div", {
                      role: "dialog",
                      "aria-modal": "true",
                      "aria-label": _ctx.title || void 0,
                      "aria-labelledby": !_ctx.title ? vue.unref(titleId) : void 0,
                      "aria-describedby": vue.unref(bodyId),
                      class: vue.normalizeClass(`${vue.unref(ns).namespace.value}-overlay-dialog`),
                      style: vue.normalizeStyle(vue.unref(overlayDialogStyle)),
                      onClick: _cache[0] || (_cache[0] = (...args) => vue.unref(overlayEvent).onClick && vue.unref(overlayEvent).onClick(...args)),
                      onMousedown: _cache[1] || (_cache[1] = (...args) => vue.unref(overlayEvent).onMousedown && vue.unref(overlayEvent).onMousedown(...args)),
                      onMouseup: _cache[2] || (_cache[2] = (...args) => vue.unref(overlayEvent).onMouseup && vue.unref(overlayEvent).onMouseup(...args))
                    }, [
                      vue.createVNode(vue.unref(ElFocusTrap), {
                        loop: "",
                        trapped: vue.unref(visible),
                        "focus-start-el": "container",
                        onFocusAfterTrapped: vue.unref(onOpenAutoFocus),
                        onFocusAfterReleased: vue.unref(onCloseAutoFocus),
                        onFocusoutPrevented: vue.unref(onFocusoutPrevented),
                        onReleaseRequested: vue.unref(onCloseRequested)
                      }, {
                        default: vue.withCtx(() => [
                          vue.unref(rendered) ? (vue.openBlock(), vue.createBlock(ElDialogContent, vue.mergeProps({
                            key: 0,
                            ref_key: "dialogContentRef",
                            ref: dialogContentRef
                          }, _ctx.$attrs, {
                            "custom-class": _ctx.customClass,
                            center: _ctx.center,
                            "align-center": _ctx.alignCenter,
                            "close-icon": _ctx.closeIcon,
                            draggable: vue.unref(draggable),
                            fullscreen: _ctx.fullscreen,
                            "show-close": _ctx.showClose,
                            title: _ctx.title,
                            onClose: vue.unref(handleClose)
                          }), vue.createSlots({
                            header: vue.withCtx(() => [
                              !_ctx.$slots.title ? vue.renderSlot(_ctx.$slots, "header", {
                                key: 0,
                                close: vue.unref(handleClose),
                                titleId: vue.unref(titleId),
                                titleClass: vue.unref(ns).e("title")
                              }) : vue.renderSlot(_ctx.$slots, "title", { key: 1 })
                            ]),
                            default: vue.withCtx(() => [
                              vue.renderSlot(_ctx.$slots, "default")
                            ]),
                            _: 2
                          }, [
                            _ctx.$slots.footer ? {
                              name: "footer",
                              fn: vue.withCtx(() => [
                                vue.renderSlot(_ctx.$slots, "footer")
                              ])
                            } : void 0
                          ]), 1040, ["custom-class", "center", "align-center", "close-icon", "draggable", "fullscreen", "show-close", "title", "onClose"])) : vue.createCommentVNode("v-if", true)
                        ]),
                        _: 3
                      }, 8, ["trapped", "onFocusAfterTrapped", "onFocusAfterReleased", "onFocusoutPrevented", "onReleaseRequested"])
                    ], 46, _hoisted_1$B)
                  ]),
                  _: 3
                }, 8, ["mask", "overlay-class", "z-index"]), [
                  [vue.vShow, vue.unref(visible)]
                ])
              ]),
              _: 3
            }, 8, ["onAfterEnter", "onAfterLeave", "onBeforeLeave"])
          ], 8, ["disabled"]);
        };
      }
    });
    var Dialog = /* @__PURE__ */ _export_sfc(_sfc_main$1c, [["__file", "dialog.vue"]]);
  
    const ElDialog = withInstall(Dialog);
  
    const dividerProps = buildProps({
      direction: {
        type: String,
        values: ["horizontal", "vertical"],
        default: "horizontal"
      },
      contentPosition: {
        type: String,
        values: ["left", "center", "right"],
        default: "center"
      },
      borderStyle: {
        type: definePropType(String),
        default: "solid"
      }
    });
  
    const __default__$L = vue.defineComponent({
      name: "ElDivider"
    });
    const _sfc_main$1b = /* @__PURE__ */ vue.defineComponent({
      ...__default__$L,
      props: dividerProps,
      setup(__props) {
        const props = __props;
        const ns = useNamespace("divider");
        const dividerStyle = vue.computed(() => {
          return ns.cssVar({
            "border-style": props.borderStyle
          });
        });
        return (_ctx, _cache) => {
          return vue.openBlock(), vue.createElementBlock("div", {
            class: vue.normalizeClass([vue.unref(ns).b(), vue.unref(ns).m(_ctx.direction)]),
            style: vue.normalizeStyle(vue.unref(dividerStyle)),
            role: "separator"
          }, [
            _ctx.$slots.default && _ctx.direction !== "vertical" ? (vue.openBlock(), vue.createElementBlock("div", {
              key: 0,
              class: vue.normalizeClass([vue.unref(ns).e("text"), vue.unref(ns).is(_ctx.contentPosition)])
            }, [
              vue.renderSlot(_ctx.$slots, "default")
            ], 2)) : vue.createCommentVNode("v-if", true)
          ], 6);
        };
      }
    });
    var Divider = /* @__PURE__ */ _export_sfc(_sfc_main$1b, [["__file", "divider.vue"]]);
  
    const ElDivider = withInstall(Divider);
  
    const drawerProps = buildProps({
      ...dialogProps,
      direction: {
        type: String,
        default: "rtl",
        values: ["ltr", "rtl", "ttb", "btt"]
      },
      size: {
        type: [String, Number],
        default: "30%"
      },
      withHeader: {
        type: Boolean,
        default: true
      },
      modalFade: {
        type: Boolean,
        default: true
      }
    });
    const drawerEmits = dialogEmits;
  
    const _sfc_main$1a = vue.defineComponent({
      name: "ElDrawer",
      components: {
        ElOverlay,
        ElFocusTrap,
        ElIcon,
        Close: close_default
      },
      props: drawerProps,
      emits: drawerEmits,
      setup(props, { slots }) {
        useDeprecated({
          scope: "el-drawer",
          from: "the title slot",
          replacement: "the header slot",
          version: "3.0.0",
          ref: "https://element-plus.org/en-US/component/drawer.html#slots"
        }, vue.computed(() => !!slots.title));
        const drawerRef = vue.ref();
        const focusStartRef = vue.ref();
        const ns = useNamespace("drawer");
        const { t } = useLocale();
        const isHorizontal = vue.computed(() => props.direction === "rtl" || props.direction === "ltr");
        const drawerSize = vue.computed(() => addUnit(props.size));
        return {
          ...useDialog(props, drawerRef),
          drawerRef,
          focusStartRef,
          isHorizontal,
          drawerSize,
          ns,
          t
        };
      }
    });
    const _hoisted_1$A = ["aria-label", "aria-labelledby", "aria-describedby"];
    const _hoisted_2$m = ["id"];
    const _hoisted_3$9 = ["aria-label"];
    const _hoisted_4$7 = ["id"];
    function _sfc_render$p(_ctx, _cache, $props, $setup, $data, $options) {
      const _component_close = vue.resolveComponent("close");
      const _component_el_icon = vue.resolveComponent("el-icon");
      const _component_el_focus_trap = vue.resolveComponent("el-focus-trap");
      const _component_el_overlay = vue.resolveComponent("el-overlay");
      return vue.openBlock(), vue.createBlock(vue.Teleport, {
        to: "body",
        disabled: !_ctx.appendToBody
      }, [
        vue.createVNode(vue.Transition, {
          name: _ctx.ns.b("fade"),
          onAfterEnter: _ctx.afterEnter,
          onAfterLeave: _ctx.afterLeave,
          onBeforeLeave: _ctx.beforeLeave,
          persisted: ""
        }, {
          default: vue.withCtx(() => [
            vue.withDirectives(vue.createVNode(_component_el_overlay, {
              mask: _ctx.modal,
              "overlay-class": _ctx.modalClass,
              "z-index": _ctx.zIndex,
              onClick: _ctx.onModalClick
            }, {
              default: vue.withCtx(() => [
                vue.createVNode(_component_el_focus_trap, {
                  loop: "",
                  trapped: _ctx.visible,
                  "focus-trap-el": _ctx.drawerRef,
                  "focus-start-el": _ctx.focusStartRef,
                  onReleaseRequested: _ctx.onCloseRequested
                }, {
                  default: vue.withCtx(() => [
                    vue.createElementVNode("div", {
                      ref: "drawerRef",
                      "aria-modal": "true",
                      "aria-label": _ctx.title || void 0,
                      "aria-labelledby": !_ctx.title ? _ctx.titleId : void 0,
                      "aria-describedby": _ctx.bodyId,
                      class: vue.normalizeClass([_ctx.ns.b(), _ctx.direction, _ctx.visible && "open", _ctx.customClass]),
                      style: vue.normalizeStyle(_ctx.isHorizontal ? "width: " + _ctx.drawerSize : "height: " + _ctx.drawerSize),
                      role: "dialog",
                      onClick: _cache[1] || (_cache[1] = vue.withModifiers(() => {
                      }, ["stop"]))
                    }, [
                      vue.createElementVNode("span", {
                        ref: "focusStartRef",
                        class: vue.normalizeClass(_ctx.ns.e("sr-focus")),
                        tabindex: "-1"
                      }, null, 2),
                      _ctx.withHeader ? (vue.openBlock(), vue.createElementBlock("header", {
                        key: 0,
                        class: vue.normalizeClass(_ctx.ns.e("header"))
                      }, [
                        !_ctx.$slots.title ? vue.renderSlot(_ctx.$slots, "header", {
                          key: 0,
                          close: _ctx.handleClose,
                          titleId: _ctx.titleId,
                          titleClass: _ctx.ns.e("title")
                        }, () => [
                          !_ctx.$slots.title ? (vue.openBlock(), vue.createElementBlock("span", {
                            key: 0,
                            id: _ctx.titleId,
                            role: "heading",
                            class: vue.normalizeClass(_ctx.ns.e("title"))
                          }, vue.toDisplayString(_ctx.title), 11, _hoisted_2$m)) : vue.createCommentVNode("v-if", true)
                        ]) : vue.renderSlot(_ctx.$slots, "title", { key: 1 }, () => [
                          vue.createCommentVNode(" DEPRECATED SLOT ")
                        ]),
                        _ctx.showClose ? (vue.openBlock(), vue.createElementBlock("button", {
                          key: 2,
                          "aria-label": _ctx.t("el.drawer.close"),
                          class: vue.normalizeClass(_ctx.ns.e("close-btn")),
                          type: "button",
                          onClick: _cache[0] || (_cache[0] = (...args) => _ctx.handleClose && _ctx.handleClose(...args))
                        }, [
                          vue.createVNode(_component_el_icon, {
                            class: vue.normalizeClass(_ctx.ns.e("close"))
                          }, {
                            default: vue.withCtx(() => [
                              vue.createVNode(_component_close)
                            ]),
                            _: 1
                          }, 8, ["class"])
                        ], 10, _hoisted_3$9)) : vue.createCommentVNode("v-if", true)
                      ], 2)) : vue.createCommentVNode("v-if", true),
                      _ctx.rendered ? (vue.openBlock(), vue.createElementBlock("div", {
                        key: 1,
                        id: _ctx.bodyId,
                        class: vue.normalizeClass(_ctx.ns.e("body"))
                      }, [
                        vue.renderSlot(_ctx.$slots, "default")
                      ], 10, _hoisted_4$7)) : vue.createCommentVNode("v-if", true),
                      _ctx.$slots.footer ? (vue.openBlock(), vue.createElementBlock("div", {
                        key: 2,
                        class: vue.normalizeClass(_ctx.ns.e("footer"))
                      }, [
                        vue.renderSlot(_ctx.$slots, "footer")
                      ], 2)) : vue.createCommentVNode("v-if", true)
                    ], 14, _hoisted_1$A)
                  ]),
                  _: 3
                }, 8, ["trapped", "focus-trap-el", "focus-start-el", "onReleaseRequested"])
              ]),
              _: 3
            }, 8, ["mask", "overlay-class", "z-index", "onClick"]), [
              [vue.vShow, _ctx.visible]
            ])
          ]),
          _: 3
        }, 8, ["name", "onAfterEnter", "onAfterLeave", "onBeforeLeave"])
      ], 8, ["disabled"]);
    }
    var Drawer = /* @__PURE__ */ _export_sfc(_sfc_main$1a, [["render", _sfc_render$p], ["__file", "drawer.vue"]]);
  
    const ElDrawer = withInstall(Drawer);
  
    const _sfc_main$19 = /* @__PURE__ */ vue.defineComponent({
      inheritAttrs: false
    });
    function _sfc_render$o(_ctx, _cache, $props, $setup, $data, $options) {
      return vue.renderSlot(_ctx.$slots, "default");
    }
    var Collection = /* @__PURE__ */ _export_sfc(_sfc_main$19, [["render", _sfc_render$o], ["__file", "collection.vue"]]);
  
    const _sfc_main$18 = /* @__PURE__ */ vue.defineComponent({
      name: "ElCollectionItem",
      inheritAttrs: false
    });
    function _sfc_render$n(_ctx, _cache, $props, $setup, $data, $options) {
      return vue.renderSlot(_ctx.$slots, "default");
    }
    var CollectionItem = /* @__PURE__ */ _export_sfc(_sfc_main$18, [["render", _sfc_render$n], ["__file", "collection-item.vue"]]);
  
    const COLLECTION_ITEM_SIGN = `data-el-collection-item`;
    const createCollectionWithScope = (name) => {
      const COLLECTION_NAME = `El${name}Collection`;
      const COLLECTION_ITEM_NAME = `${COLLECTION_NAME}Item`;
      const COLLECTION_INJECTION_KEY = Symbol(COLLECTION_NAME);
      const COLLECTION_ITEM_INJECTION_KEY = Symbol(COLLECTION_ITEM_NAME);
      const ElCollection = {
        ...Collection,
        name: COLLECTION_NAME,
        setup() {
          const collectionRef = vue.ref(null);
          const itemMap = /* @__PURE__ */ new Map();
          const getItems = () => {
            const collectionEl = vue.unref(collectionRef);
            if (!collectionEl)
              return [];
            const orderedNodes = Array.from(collectionEl.querySelectorAll(`[${COLLECTION_ITEM_SIGN}]`));
            const items = [...itemMap.values()];
            return items.sort((a, b) => orderedNodes.indexOf(a.ref) - orderedNodes.indexOf(b.ref));
          };
          vue.provide(COLLECTION_INJECTION_KEY, {
            itemMap,
            getItems,
            collectionRef
          });
        }
      };
      const ElCollectionItem = {
        ...CollectionItem,
        name: COLLECTION_ITEM_NAME,
        setup(_, { attrs }) {
          const collectionItemRef = vue.ref(null);
          const collectionInjection = vue.inject(COLLECTION_INJECTION_KEY, void 0);
          vue.provide(COLLECTION_ITEM_INJECTION_KEY, {
            collectionItemRef
          });
          vue.onMounted(() => {
            const collectionItemEl = vue.unref(collectionItemRef);
            if (collectionItemEl) {
              collectionInjection.itemMap.set(collectionItemEl, {
                ref: collectionItemEl,
                ...attrs
              });
            }
          });
          vue.onBeforeUnmount(() => {
            const collectionItemEl = vue.unref(collectionItemRef);
            collectionInjection.itemMap.delete(collectionItemEl);
          });
        }
      };
      return {
        COLLECTION_INJECTION_KEY,
        COLLECTION_ITEM_INJECTION_KEY,
        ElCollection,
        ElCollectionItem
      };
    };
  
    const rovingFocusGroupProps = buildProps({
      style: { type: definePropType([String, Array, Object]) },
      currentTabId: {
        type: definePropType(String)
      },
      defaultCurrentTabId: String,
      loop: Boolean,
      dir: {
        type: String,
        values: ["ltr", "rtl"],
        default: "ltr"
      },
      orientation: {
        type: definePropType(String)
      },
      onBlur: Function,
      onFocus: Function,
      onMousedown: Function
    });
    const {
      ElCollection: ElCollection$1,
      ElCollectionItem: ElCollectionItem$1,
      COLLECTION_INJECTION_KEY: COLLECTION_INJECTION_KEY$1,
      COLLECTION_ITEM_INJECTION_KEY: COLLECTION_ITEM_INJECTION_KEY$1
    } = createCollectionWithScope("RovingFocusGroup");
  
    const ROVING_FOCUS_GROUP_INJECTION_KEY = Symbol("elRovingFocusGroup");
    const ROVING_FOCUS_GROUP_ITEM_INJECTION_KEY = Symbol("elRovingFocusGroupItem");
  
    const MAP_KEY_TO_FOCUS_INTENT = {
      ArrowLeft: "prev",
      ArrowUp: "prev",
      ArrowRight: "next",
      ArrowDown: "next",
      PageUp: "first",
      Home: "first",
      PageDown: "last",
      End: "last"
    };
    const getDirectionAwareKey = (key, dir) => {
      if (dir !== "rtl")
        return key;
      switch (key) {
        case EVENT_CODE.right:
          return EVENT_CODE.left;
        case EVENT_CODE.left:
          return EVENT_CODE.right;
        default:
          return key;
      }
    };
    const getFocusIntent = (event, orientation, dir) => {
      const key = getDirectionAwareKey(event.key, dir);
      if (orientation === "vertical" && [EVENT_CODE.left, EVENT_CODE.right].includes(key))
        return void 0;
      if (orientation === "horizontal" && [EVENT_CODE.up, EVENT_CODE.down].includes(key))
        return void 0;
      return MAP_KEY_TO_FOCUS_INTENT[key];
    };
    const reorderArray = (array, atIdx) => {
      return array.map((_, idx) => array[(idx + atIdx) % array.length]);
    };
    const focusFirst = (elements) => {
      const { activeElement: prevActive } = document;
      for (const element of elements) {
        if (element === prevActive)
          return;
        element.focus();
        if (prevActive !== document.activeElement)
          return;
      }
    };
  
    const CURRENT_TAB_ID_CHANGE_EVT = "currentTabIdChange";
    const ENTRY_FOCUS_EVT = "rovingFocusGroup.entryFocus";
    const EVT_OPTS = { bubbles: false, cancelable: true };
    const _sfc_main$17 = vue.defineComponent({
      name: "ElRovingFocusGroupImpl",
      inheritAttrs: false,
      props: rovingFocusGroupProps,
      emits: [CURRENT_TAB_ID_CHANGE_EVT, "entryFocus"],
      setup(props, { emit }) {
        var _a;
        const currentTabbedId = vue.ref((_a = props.currentTabId || props.defaultCurrentTabId) != null ? _a : null);
        const isBackingOut = vue.ref(false);
        const isClickFocus = vue.ref(false);
        const rovingFocusGroupRef = vue.ref(null);
        const { getItems } = vue.inject(COLLECTION_INJECTION_KEY$1, void 0);
        const rovingFocusGroupRootStyle = vue.computed(() => {
          return [
            {
              outline: "none"
            },
            props.style
          ];
        });
        const onItemFocus = (tabbedId) => {
          emit(CURRENT_TAB_ID_CHANGE_EVT, tabbedId);
        };
        const onItemShiftTab = () => {
          isBackingOut.value = true;
        };
        const onMousedown = composeEventHandlers((e) => {
          var _a2;
          (_a2 = props.onMousedown) == null ? void 0 : _a2.call(props, e);
        }, () => {
          isClickFocus.value = true;
        });
        const onFocus = composeEventHandlers((e) => {
          var _a2;
          (_a2 = props.onFocus) == null ? void 0 : _a2.call(props, e);
        }, (e) => {
          const isKeyboardFocus = !vue.unref(isClickFocus);
          const { target, currentTarget } = e;
          if (target === currentTarget && isKeyboardFocus && !vue.unref(isBackingOut)) {
            const entryFocusEvt = new Event(ENTRY_FOCUS_EVT, EVT_OPTS);
            currentTarget == null ? void 0 : currentTarget.dispatchEvent(entryFocusEvt);
            if (!entryFocusEvt.defaultPrevented) {
              const items = getItems().filter((item) => item.focusable);
              const activeItem = items.find((item) => item.active);
              const currentItem = items.find((item) => item.id === vue.unref(currentTabbedId));
              const candidates = [activeItem, currentItem, ...items].filter(Boolean);
              const candidateNodes = candidates.map((item) => item.ref);
              focusFirst(candidateNodes);
            }
          }
          isClickFocus.value = false;
        });
        const onBlur = composeEventHandlers((e) => {
          var _a2;
          (_a2 = props.onBlur) == null ? void 0 : _a2.call(props, e);
        }, () => {
          isBackingOut.value = false;
        });
        const handleEntryFocus = (...args) => {
          emit("entryFocus", ...args);
        };
        vue.provide(ROVING_FOCUS_GROUP_INJECTION_KEY, {
          currentTabbedId: vue.readonly(currentTabbedId),
          loop: vue.toRef(props, "loop"),
          tabIndex: vue.computed(() => {
            return vue.unref(isBackingOut) ? -1 : 0;
          }),
          rovingFocusGroupRef,
          rovingFocusGroupRootStyle,
          orientation: vue.toRef(props, "orientation"),
          dir: vue.toRef(props, "dir"),
          onItemFocus,
          onItemShiftTab,
          onBlur,
          onFocus,
          onMousedown
        });
        vue.watch(() => props.currentTabId, (val) => {
          currentTabbedId.value = val != null ? val : null;
        });
        useEventListener(rovingFocusGroupRef, ENTRY_FOCUS_EVT, handleEntryFocus);
      }
    });
    function _sfc_render$m(_ctx, _cache, $props, $setup, $data, $options) {
      return vue.renderSlot(_ctx.$slots, "default");
    }
    var ElRovingFocusGroupImpl = /* @__PURE__ */ _export_sfc(_sfc_main$17, [["render", _sfc_render$m], ["__file", "roving-focus-group-impl.vue"]]);
  
    const _sfc_main$16 = vue.defineComponent({
      name: "ElRovingFocusGroup",
      components: {
        ElFocusGroupCollection: ElCollection$1,
        ElRovingFocusGroupImpl
      }
    });
    function _sfc_render$l(_ctx, _cache, $props, $setup, $data, $options) {
      const _component_el_roving_focus_group_impl = vue.resolveComponent("el-roving-focus-group-impl");
      const _component_el_focus_group_collection = vue.resolveComponent("el-focus-group-collection");
      return vue.openBlock(), vue.createBlock(_component_el_focus_group_collection, null, {
        default: vue.withCtx(() => [
          vue.createVNode(_component_el_roving_focus_group_impl, vue.normalizeProps(vue.guardReactiveProps(_ctx.$attrs)), {
            default: vue.withCtx(() => [
              vue.renderSlot(_ctx.$slots, "default")
            ]),
            _: 3
          }, 16)
        ]),
        _: 3
      });
    }
    var ElRovingFocusGroup = /* @__PURE__ */ _export_sfc(_sfc_main$16, [["render", _sfc_render$l], ["__file", "roving-focus-group.vue"]]);
  
    const _sfc_main$15 = vue.defineComponent({
      components: {
        ElRovingFocusCollectionItem: ElCollectionItem$1
      },
      props: {
        focusable: {
          type: Boolean,
          default: true
        },
        active: {
          type: Boolean,
          default: false
        }
      },
      emits: ["mousedown", "focus", "keydown"],
      setup(props, { emit }) {
        const { currentTabbedId, loop, onItemFocus, onItemShiftTab } = vue.inject(ROVING_FOCUS_GROUP_INJECTION_KEY, void 0);
        const { getItems } = vue.inject(COLLECTION_INJECTION_KEY$1, void 0);
        const id = useId();
        const rovingFocusGroupItemRef = vue.ref(null);
        const handleMousedown = composeEventHandlers((e) => {
          emit("mousedown", e);
        }, (e) => {
          if (!props.focusable) {
            e.preventDefault();
          } else {
            onItemFocus(vue.unref(id));
          }
        });
        const handleFocus = composeEventHandlers((e) => {
          emit("focus", e);
        }, () => {
          onItemFocus(vue.unref(id));
        });
        const handleKeydown = composeEventHandlers((e) => {
          emit("keydown", e);
        }, (e) => {
          const { key, shiftKey, target, currentTarget } = e;
          if (key === EVENT_CODE.tab && shiftKey) {
            onItemShiftTab();
            return;
          }
          if (target !== currentTarget)
            return;
          const focusIntent = getFocusIntent(e);
          if (focusIntent) {
            e.preventDefault();
            const items = getItems().filter((item) => item.focusable);
            let elements = items.map((item) => item.ref);
            switch (focusIntent) {
              case "last": {
                elements.reverse();
                break;
              }
              case "prev":
              case "next": {
                if (focusIntent === "prev") {
                  elements.reverse();
                }
                const currentIdx = elements.indexOf(currentTarget);
                elements = loop.value ? reorderArray(elements, currentIdx + 1) : elements.slice(currentIdx + 1);
                break;
              }
            }
            vue.nextTick(() => {
              focusFirst(elements);
            });
          }
        });
        const isCurrentTab = vue.computed(() => currentTabbedId.value === vue.unref(id));
        vue.provide(ROVING_FOCUS_GROUP_ITEM_INJECTION_KEY, {
          rovingFocusGroupItemRef,
          tabIndex: vue.computed(() => vue.unref(isCurrentTab) ? 0 : -1),
          handleMousedown,
          handleFocus,
          handleKeydown
        });
        return {
          id,
          handleKeydown,
          handleFocus,
          handleMousedown
        };
      }
    });
    function _sfc_render$k(_ctx, _cache, $props, $setup, $data, $options) {
      const _component_el_roving_focus_collection_item = vue.resolveComponent("el-roving-focus-collection-item");
      return vue.openBlock(), vue.createBlock(_component_el_roving_focus_collection_item, {
        id: _ctx.id,
        focusable: _ctx.focusable,
        active: _ctx.active
      }, {
        default: vue.withCtx(() => [
          vue.renderSlot(_ctx.$slots, "default")
        ]),
        _: 3
      }, 8, ["id", "focusable", "active"]);
    }
    var ElRovingFocusItem = /* @__PURE__ */ _export_sfc(_sfc_main$15, [["render", _sfc_render$k], ["__file", "roving-focus-item.vue"]]);
  
    const dropdownProps = buildProps({
      trigger: useTooltipTriggerProps.trigger,
      effect: {
        ...useTooltipContentProps.effect,
        default: "light"
      },
      type: {
        type: definePropType(String)
      },
      placement: {
        type: definePropType(String),
        default: "bottom"
      },
      popperOptions: {
        type: definePropType(Object),
        default: () => ({})
      },
      id: String,
      size: {
        type: String,
        default: ""
      },
      splitButton: Boolean,
      hideOnClick: {
        type: Boolean,
        default: true
      },
      loop: {
        type: Boolean,
        default: true
      },
      showTimeout: {
        type: Number,
        default: 150
      },
      hideTimeout: {
        type: Number,
        default: 150
      },
      tabindex: {
        type: definePropType([Number, String]),
        default: 0
      },
      maxHeight: {
        type: definePropType([Number, String]),
        default: ""
      },
      popperClass: {
        type: String,
        default: ""
      },
      disabled: {
        type: Boolean,
        default: false
      },
      role: {
        type: String,
        default: "menu"
      },
      buttonProps: {
        type: definePropType(Object)
      },
      teleported: useTooltipContentProps.teleported
    });
    const dropdownItemProps = buildProps({
      command: {
        type: [Object, String, Number],
        default: () => ({})
      },
      disabled: Boolean,
      divided: Boolean,
      textValue: String,
      icon: {
        type: iconPropType
      }
    });
    const dropdownMenuProps = buildProps({
      onKeydown: { type: definePropType(Function) }
    });
    const FIRST_KEYS = [
      EVENT_CODE.down,
      EVENT_CODE.pageDown,
      EVENT_CODE.home
    ];
    const LAST_KEYS = [EVENT_CODE.up, EVENT_CODE.pageUp, EVENT_CODE.end];
    const FIRST_LAST_KEYS = [...FIRST_KEYS, ...LAST_KEYS];
    const {
      ElCollection,
      ElCollectionItem,
      COLLECTION_INJECTION_KEY,
      COLLECTION_ITEM_INJECTION_KEY
    } = createCollectionWithScope("Dropdown");
  
    const DROPDOWN_INJECTION_KEY = Symbol("elDropdown");
  
    const { ButtonGroup: ElButtonGroup } = ElButton;
    const _sfc_main$14 = vue.defineComponent({
      name: "ElDropdown",
      components: {
        ElButton,
        ElButtonGroup,
        ElScrollbar,
        ElDropdownCollection: ElCollection,
        ElTooltip,
        ElRovingFocusGroup,
        ElOnlyChild: OnlyChild,
        ElIcon,
        ArrowDown: arrow_down_default
      },
      props: dropdownProps,
      emits: ["visible-change", "click", "command"],
      setup(props, { emit }) {
        const _instance = vue.getCurrentInstance();
        const ns = useNamespace("dropdown");
        const { t } = useLocale();
        const triggeringElementRef = vue.ref();
        const referenceElementRef = vue.ref();
        const popperRef = vue.ref(null);
        const contentRef = vue.ref(null);
        const scrollbar = vue.ref(null);
        const currentTabId = vue.ref(null);
        const isUsingKeyboard = vue.ref(false);
        const triggerKeys = [EVENT_CODE.enter, EVENT_CODE.space, EVENT_CODE.down];
        const wrapStyle = vue.computed(() => ({
          maxHeight: addUnit(props.maxHeight)
        }));
        const dropdownTriggerKls = vue.computed(() => [ns.m(dropdownSize.value)]);
        const defaultTriggerId = useId().value;
        const triggerId = vue.computed(() => {
          return props.id || defaultTriggerId;
        });
        function handleClick() {
          handleClose();
        }
        function handleClose() {
          var _a;
          (_a = popperRef.value) == null ? void 0 : _a.onClose();
        }
        function handleOpen() {
          var _a;
          (_a = popperRef.value) == null ? void 0 : _a.onOpen();
        }
        const dropdownSize = useSize();
        function commandHandler(...args) {
          emit("command", ...args);
        }
        function onItemEnter() {
        }
        function onItemLeave() {
          const contentEl = vue.unref(contentRef);
          contentEl == null ? void 0 : contentEl.focus();
          currentTabId.value = null;
        }
        function handleCurrentTabIdChange(id) {
          currentTabId.value = id;
        }
        function handleEntryFocus(e) {
          if (!isUsingKeyboard.value) {
            e.preventDefault();
            e.stopImmediatePropagation();
          }
        }
        function handleBeforeShowTooltip() {
          emit("visible-change", true);
        }
        function handleShowTooltip(event) {
          if ((event == null ? void 0 : event.type) === "keydown") {
            contentRef.value.focus();
          }
        }
        function handleBeforeHideTooltip() {
          emit("visible-change", false);
        }
        vue.provide(DROPDOWN_INJECTION_KEY, {
          contentRef,
          role: vue.computed(() => props.role),
          triggerId,
          isUsingKeyboard,
          onItemEnter,
          onItemLeave
        });
        vue.provide("elDropdown", {
          instance: _instance,
          dropdownSize,
          handleClick,
          commandHandler,
          trigger: vue.toRef(props, "trigger"),
          hideOnClick: vue.toRef(props, "hideOnClick")
        });
        const onFocusAfterTrapped = (e) => {
          var _a, _b;
          e.preventDefault();
          (_b = (_a = contentRef.value) == null ? void 0 : _a.focus) == null ? void 0 : _b.call(_a, {
            preventScroll: true
          });
        };
        const handlerMainButtonClick = (event) => {
          emit("click", event);
        };
        return {
          t,
          ns,
          scrollbar,
          wrapStyle,
          dropdownTriggerKls,
          dropdownSize,
          triggerId,
          triggerKeys,
          currentTabId,
          handleCurrentTabIdChange,
          handlerMainButtonClick,
          handleEntryFocus,
          handleClose,
          handleOpen,
          handleBeforeShowTooltip,
          handleShowTooltip,
          handleBeforeHideTooltip,
          onFocusAfterTrapped,
          popperRef,
          contentRef,
          triggeringElementRef,
          referenceElementRef
        };
      }
    });
    function _sfc_render$j(_ctx, _cache, $props, $setup, $data, $options) {
      var _a;
      const _component_el_dropdown_collection = vue.resolveComponent("el-dropdown-collection");
      const _component_el_roving_focus_group = vue.resolveComponent("el-roving-focus-group");
      const _component_el_scrollbar = vue.resolveComponent("el-scrollbar");
      const _component_el_only_child = vue.resolveComponent("el-only-child");
      const _component_el_tooltip = vue.resolveComponent("el-tooltip");
      const _component_el_button = vue.resolveComponent("el-button");
      const _component_arrow_down = vue.resolveComponent("arrow-down");
      const _component_el_icon = vue.resolveComponent("el-icon");
      const _component_el_button_group = vue.resolveComponent("el-button-group");
      return vue.openBlock(), vue.createElementBlock("div", {
        class: vue.normalizeClass([_ctx.ns.b(), _ctx.ns.is("disabled", _ctx.disabled)])
      }, [
        vue.createVNode(_component_el_tooltip, {
          ref: "popperRef",
          role: _ctx.role,
          effect: _ctx.effect,
          "fallback-placements": ["bottom", "top"],
          "popper-options": _ctx.popperOptions,
          "gpu-acceleration": false,
          "hide-after": _ctx.trigger === "hover" ? _ctx.hideTimeout : 0,
          "manual-mode": true,
          placement: _ctx.placement,
          "popper-class": [_ctx.ns.e("popper"), _ctx.popperClass],
          "reference-element": (_a = _ctx.referenceElementRef) == null ? void 0 : _a.$el,
          trigger: _ctx.trigger,
          "trigger-keys": _ctx.triggerKeys,
          "trigger-target-el": _ctx.contentRef,
          "show-after": _ctx.trigger === "hover" ? _ctx.showTimeout : 0,
          "stop-popper-mouse-event": false,
          "virtual-ref": _ctx.triggeringElementRef,
          "virtual-triggering": _ctx.splitButton,
          disabled: _ctx.disabled,
          transition: `${_ctx.ns.namespace.value}-zoom-in-top`,
          teleported: _ctx.teleported,
          pure: "",
          persistent: "",
          onBeforeShow: _ctx.handleBeforeShowTooltip,
          onShow: _ctx.handleShowTooltip,
          onBeforeHide: _ctx.handleBeforeHideTooltip
        }, vue.createSlots({
          content: vue.withCtx(() => [
            vue.createVNode(_component_el_scrollbar, {
              ref: "scrollbar",
              "wrap-style": _ctx.wrapStyle,
              tag: "div",
              "view-class": _ctx.ns.e("list")
            }, {
              default: vue.withCtx(() => [
                vue.createVNode(_component_el_roving_focus_group, {
                  loop: _ctx.loop,
                  "current-tab-id": _ctx.currentTabId,
                  orientation: "horizontal",
                  onCurrentTabIdChange: _ctx.handleCurrentTabIdChange,
                  onEntryFocus: _ctx.handleEntryFocus
                }, {
                  default: vue.withCtx(() => [
                    vue.createVNode(_component_el_dropdown_collection, null, {
                      default: vue.withCtx(() => [
                        vue.renderSlot(_ctx.$slots, "dropdown")
                      ]),
                      _: 3
                    })
                  ]),
                  _: 3
                }, 8, ["loop", "current-tab-id", "onCurrentTabIdChange", "onEntryFocus"])
              ]),
              _: 3
            }, 8, ["wrap-style", "view-class"])
          ]),
          _: 2
        }, [
          !_ctx.splitButton ? {
            name: "default",
            fn: vue.withCtx(() => [
              vue.createVNode(_component_el_only_child, {
                id: _ctx.triggerId,
                role: "button",
                tabindex: _ctx.tabindex
              }, {
                default: vue.withCtx(() => [
                  vue.renderSlot(_ctx.$slots, "default")
                ]),
                _: 3
              }, 8, ["id", "tabindex"])
            ])
          } : void 0
        ]), 1032, ["role", "effect", "popper-options", "hide-after", "placement", "popper-class", "reference-element", "trigger", "trigger-keys", "trigger-target-el", "show-after", "virtual-ref", "virtual-triggering", "disabled", "transition", "teleported", "onBeforeShow", "onShow", "onBeforeHide"]),
        _ctx.splitButton ? (vue.openBlock(), vue.createBlock(_component_el_button_group, { key: 0 }, {
          default: vue.withCtx(() => [
            vue.createVNode(_component_el_button, vue.mergeProps({ ref: "referenceElementRef" }, _ctx.buttonProps, {
              size: _ctx.dropdownSize,
              type: _ctx.type,
              disabled: _ctx.disabled,
              tabindex: _ctx.tabindex,
              onClick: _ctx.handlerMainButtonClick
            }), {
              default: vue.withCtx(() => [
                vue.renderSlot(_ctx.$slots, "default")
              ]),
              _: 3
            }, 16, ["size", "type", "disabled", "tabindex", "onClick"]),
            vue.createVNode(_component_el_button, vue.mergeProps({
              id: _ctx.triggerId,
              ref: "triggeringElementRef"
            }, _ctx.buttonProps, {
              role: "button",
              size: _ctx.dropdownSize,
              type: _ctx.type,
              class: _ctx.ns.e("caret-button"),
              disabled: _ctx.disabled,
              tabindex: _ctx.tabindex,
              "aria-label": _ctx.t("el.dropdown.toggleDropdown")
            }), {
              default: vue.withCtx(() => [
                vue.createVNode(_component_el_icon, {
                  class: vue.normalizeClass(_ctx.ns.e("icon"))
                }, {
                  default: vue.withCtx(() => [
                    vue.createVNode(_component_arrow_down)
                  ]),
                  _: 1
                }, 8, ["class"])
              ]),
              _: 1
            }, 16, ["id", "size", "type", "class", "disabled", "tabindex", "aria-label"])
          ]),
          _: 3
        })) : vue.createCommentVNode("v-if", true)
      ], 2);
    }
    var Dropdown = /* @__PURE__ */ _export_sfc(_sfc_main$14, [["render", _sfc_render$j], ["__file", "dropdown.vue"]]);
  
    const _sfc_main$13 = vue.defineComponent({
      name: "DropdownItemImpl",
      components: {
        ElIcon
      },
      props: dropdownItemProps,
      emits: ["pointermove", "pointerleave", "click", "clickimpl"],
      setup(_, { emit }) {
        const ns = useNamespace("dropdown");
        const { role: menuRole } = vue.inject(DROPDOWN_INJECTION_KEY, void 0);
        const { collectionItemRef: dropdownCollectionItemRef } = vue.inject(COLLECTION_ITEM_INJECTION_KEY, void 0);
        const { collectionItemRef: rovingFocusCollectionItemRef } = vue.inject(COLLECTION_ITEM_INJECTION_KEY$1, void 0);
        const {
          rovingFocusGroupItemRef,
          tabIndex,
          handleFocus,
          handleKeydown: handleItemKeydown,
          handleMousedown
        } = vue.inject(ROVING_FOCUS_GROUP_ITEM_INJECTION_KEY, void 0);
        const itemRef = composeRefs(dropdownCollectionItemRef, rovingFocusCollectionItemRef, rovingFocusGroupItemRef);
        const role = vue.computed(() => {
          if (menuRole.value === "menu") {
            return "menuitem";
          } else if (menuRole.value === "navigation") {
            return "link";
          }
          return "button";
        });
        const handleKeydown = composeEventHandlers((e) => {
          const { code } = e;
          if (code === EVENT_CODE.enter || code === EVENT_CODE.space) {
            e.preventDefault();
            e.stopImmediatePropagation();
            emit("clickimpl", e);
            return true;
          }
        }, handleItemKeydown);
        return {
          ns,
          itemRef,
          dataset: {
            [COLLECTION_ITEM_SIGN]: ""
          },
          role,
          tabIndex,
          handleFocus,
          handleKeydown,
          handleMousedown
        };
      }
    });
    const _hoisted_1$z = ["aria-disabled", "tabindex", "role"];
    function _sfc_render$i(_ctx, _cache, $props, $setup, $data, $options) {
      const _component_el_icon = vue.resolveComponent("el-icon");
      return vue.openBlock(), vue.createElementBlock(vue.Fragment, null, [
        _ctx.divided ? (vue.openBlock(), vue.createElementBlock("li", vue.mergeProps({
          key: 0,
          role: "separator",
          class: _ctx.ns.bem("menu", "item", "divided")
        }, _ctx.$attrs), null, 16)) : vue.createCommentVNode("v-if", true),
        vue.createElementVNode("li", vue.mergeProps({ ref: _ctx.itemRef }, { ..._ctx.dataset, ..._ctx.$attrs }, {
          "aria-disabled": _ctx.disabled,
          class: [_ctx.ns.be("menu", "item"), _ctx.ns.is("disabled", _ctx.disabled)],
          tabindex: _ctx.tabIndex,
          role: _ctx.role,
          onClick: _cache[0] || (_cache[0] = (e) => _ctx.$emit("clickimpl", e)),
          onFocus: _cache[1] || (_cache[1] = (...args) => _ctx.handleFocus && _ctx.handleFocus(...args)),
          onKeydown: _cache[2] || (_cache[2] = (...args) => _ctx.handleKeydown && _ctx.handleKeydown(...args)),
          onMousedown: _cache[3] || (_cache[3] = (...args) => _ctx.handleMousedown && _ctx.handleMousedown(...args)),
          onPointermove: _cache[4] || (_cache[4] = (e) => _ctx.$emit("pointermove", e)),
          onPointerleave: _cache[5] || (_cache[5] = (e) => _ctx.$emit("pointerleave", e))
        }), [
          _ctx.icon ? (vue.openBlock(), vue.createBlock(_component_el_icon, { key: 0 }, {
            default: vue.withCtx(() => [
              (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(_ctx.icon)))
            ]),
            _: 1
          })) : vue.createCommentVNode("v-if", true),
          vue.renderSlot(_ctx.$slots, "default")
        ], 16, _hoisted_1$z)
      ], 64);
    }
    var ElDropdownItemImpl = /* @__PURE__ */ _export_sfc(_sfc_main$13, [["render", _sfc_render$i], ["__file", "dropdown-item-impl.vue"]]);
  
    const useDropdown = () => {
      const elDropdown = vue.inject("elDropdown", {});
      const _elDropdownSize = vue.computed(() => elDropdown == null ? void 0 : elDropdown.dropdownSize);
      return {
        elDropdown,
        _elDropdownSize
      };
    };
  
    const _sfc_main$12 = vue.defineComponent({
      name: "ElDropdownItem",
      components: {
        ElDropdownCollectionItem: ElCollectionItem,
        ElRovingFocusItem,
        ElDropdownItemImpl
      },
      inheritAttrs: false,
      props: dropdownItemProps,
      emits: ["pointermove", "pointerleave", "click"],
      setup(props, { emit, attrs }) {
        const { elDropdown } = useDropdown();
        const _instance = vue.getCurrentInstance();
        const itemRef = vue.ref(null);
        const textContent = vue.computed(() => {
          var _a, _b;
          return (_b = (_a = vue.unref(itemRef)) == null ? void 0 : _a.textContent) != null ? _b : "";
        });
        const { onItemEnter, onItemLeave } = vue.inject(DROPDOWN_INJECTION_KEY, void 0);
        const handlePointerMove = composeEventHandlers((e) => {
          emit("pointermove", e);
          return e.defaultPrevented;
        }, whenMouse((e) => {
          var _a;
          if (props.disabled) {
            onItemLeave(e);
          } else {
            onItemEnter(e);
            if (!e.defaultPrevented) {
              (_a = e.currentTarget) == null ? void 0 : _a.focus();
            }
          }
        }));
        const handlePointerLeave = composeEventHandlers((e) => {
          emit("pointerleave", e);
          return e.defaultPrevented;
        }, whenMouse((e) => {
          onItemLeave(e);
        }));
        const handleClick = composeEventHandlers((e) => {
          if (props.disabled) {
            return;
          }
          emit("click", e);
          return e.type !== "keydown" && e.defaultPrevented;
        }, (e) => {
          var _a, _b, _c;
          if (props.disabled) {
            e.stopImmediatePropagation();
            return;
          }
          if ((_a = elDropdown == null ? void 0 : elDropdown.hideOnClick) == null ? void 0 : _a.value) {
            (_b = elDropdown.handleClick) == null ? void 0 : _b.call(elDropdown);
          }
          (_c = elDropdown.commandHandler) == null ? void 0 : _c.call(elDropdown, props.command, _instance, e);
        });
        const propsAndAttrs = vue.computed(() => {
          return { ...props, ...attrs };
        });
        return {
          handleClick,
          handlePointerMove,
          handlePointerLeave,
          textContent,
          propsAndAttrs
        };
      }
    });
    function _sfc_render$h(_ctx, _cache, $props, $setup, $data, $options) {
      var _a;
      const _component_el_dropdown_item_impl = vue.resolveComponent("el-dropdown-item-impl");
      const _component_el_roving_focus_item = vue.resolveComponent("el-roving-focus-item");
      const _component_el_dropdown_collection_item = vue.resolveComponent("el-dropdown-collection-item");
      return vue.openBlock(), vue.createBlock(_component_el_dropdown_collection_item, {
        disabled: _ctx.disabled,
        "text-value": (_a = _ctx.textValue) != null ? _a : _ctx.textContent
      }, {
        default: vue.withCtx(() => [
          vue.createVNode(_component_el_roving_focus_item, {
            focusable: !_ctx.disabled
          }, {
            default: vue.withCtx(() => [
              vue.createVNode(_component_el_dropdown_item_impl, vue.mergeProps(_ctx.propsAndAttrs, {
                onPointerleave: _ctx.handlePointerLeave,
                onPointermove: _ctx.handlePointerMove,
                onClickimpl: _ctx.handleClick
              }), {
                default: vue.withCtx(() => [
                  vue.renderSlot(_ctx.$slots, "default")
                ]),
                _: 3
              }, 16, ["onPointerleave", "onPointermove", "onClickimpl"])
            ]),
            _: 3
          }, 8, ["focusable"])
        ]),
        _: 3
      }, 8, ["disabled", "text-value"]);
    }
    var DropdownItem = /* @__PURE__ */ _export_sfc(_sfc_main$12, [["render", _sfc_render$h], ["__file", "dropdown-item.vue"]]);
  
    const _sfc_main$11 = vue.defineComponent({
      name: "ElDropdownMenu",
      props: dropdownMenuProps,
      setup(props) {
        const ns = useNamespace("dropdown");
        const { _elDropdownSize } = useDropdown();
        const size = _elDropdownSize.value;
        const { focusTrapRef, onKeydown } = vue.inject(FOCUS_TRAP_INJECTION_KEY, void 0);
        const { contentRef, role, triggerId } = vue.inject(DROPDOWN_INJECTION_KEY, void 0);
        const { collectionRef: dropdownCollectionRef, getItems } = vue.inject(COLLECTION_INJECTION_KEY, void 0);
        const {
          rovingFocusGroupRef,
          rovingFocusGroupRootStyle,
          tabIndex,
          onBlur,
          onFocus,
          onMousedown
        } = vue.inject(ROVING_FOCUS_GROUP_INJECTION_KEY, void 0);
        const { collectionRef: rovingFocusGroupCollectionRef } = vue.inject(COLLECTION_INJECTION_KEY$1, void 0);
        const dropdownKls = vue.computed(() => {
          return [ns.b("menu"), ns.bm("menu", size == null ? void 0 : size.value)];
        });
        const dropdownListWrapperRef = composeRefs(contentRef, dropdownCollectionRef, focusTrapRef, rovingFocusGroupRef, rovingFocusGroupCollectionRef);
        const composedKeydown = composeEventHandlers((e) => {
          var _a;
          (_a = props.onKeydown) == null ? void 0 : _a.call(props, e);
        }, (e) => {
          const { currentTarget, code, target } = e;
          currentTarget.contains(target);
          if (EVENT_CODE.tab === code) {
            e.stopImmediatePropagation();
          }
          e.preventDefault();
          if (target !== vue.unref(contentRef))
            return;
          if (!FIRST_LAST_KEYS.includes(code))
            return;
          const items = getItems().filter((item) => !item.disabled);
          const targets = items.map((item) => item.ref);
          if (LAST_KEYS.includes(code)) {
            targets.reverse();
          }
          focusFirst(targets);
        });
        const handleKeydown = (e) => {
          composedKeydown(e);
          onKeydown(e);
        };
        return {
          size,
          rovingFocusGroupRootStyle,
          tabIndex,
          dropdownKls,
          role,
          triggerId,
          dropdownListWrapperRef,
          handleKeydown,
          onBlur,
          onFocus,
          onMousedown
        };
      }
    });
    const _hoisted_1$y = ["role", "aria-labelledby"];
    function _sfc_render$g(_ctx, _cache, $props, $setup, $data, $options) {
      return vue.openBlock(), vue.createElementBlock("ul", {
        ref: _ctx.dropdownListWrapperRef,
        class: vue.normalizeClass(_ctx.dropdownKls),
        style: vue.normalizeStyle(_ctx.rovingFocusGroupRootStyle),
        tabindex: -1,
        role: _ctx.role,
        "aria-labelledby": _ctx.triggerId,
        onBlur: _cache[0] || (_cache[0] = (...args) => _ctx.onBlur && _ctx.onBlur(...args)),
        onFocus: _cache[1] || (_cache[1] = (...args) => _ctx.onFocus && _ctx.onFocus(...args)),
        onKeydown: _cache[2] || (_cache[2] = (...args) => _ctx.handleKeydown && _ctx.handleKeydown(...args)),
        onMousedown: _cache[3] || (_cache[3] = (...args) => _ctx.onMousedown && _ctx.onMousedown(...args))
      }, [
        vue.renderSlot(_ctx.$slots, "default")
      ], 46, _hoisted_1$y);
    }
    var DropdownMenu = /* @__PURE__ */ _export_sfc(_sfc_main$11, [["render", _sfc_render$g], ["__file", "dropdown-menu.vue"]]);
  
    const ElDropdown = withInstall(Dropdown, {
      DropdownItem,
      DropdownMenu
    });
    const ElDropdownItem = withNoopInstall(DropdownItem);
    const ElDropdownMenu = withNoopInstall(DropdownMenu);
  
    let id = 0;
    const _sfc_main$10 = vue.defineComponent({
      name: "ImgEmpty",
      setup() {
        const ns = useNamespace("empty");
        return {
          ns,
          id: ++id
        };
      }
    });
    const _hoisted_1$x = {
      viewBox: "0 0 79 86",
      version: "1.1",
      xmlns: "http://www.w3.org/2000/svg",
      "xmlns:xlink": "http://www.w3.org/1999/xlink"
    };
    const _hoisted_2$l = ["id"];
    const _hoisted_3$8 = ["stop-color"];
    const _hoisted_4$6 = ["stop-color"];
    const _hoisted_5$5 = ["id"];
    const _hoisted_6$1 = ["stop-color"];
    const _hoisted_7 = ["stop-color"];
    const _hoisted_8 = ["id"];
    const _hoisted_9 = {
      id: "Illustrations",
      stroke: "none",
      "stroke-width": "1",
      fill: "none",
      "fill-rule": "evenodd"
    };
    const _hoisted_10 = {
      id: "B-type",
      transform: "translate(-1268.000000, -535.000000)"
    };
    const _hoisted_11 = {
      id: "Group-2",
      transform: "translate(1268.000000, 535.000000)"
    };
    const _hoisted_12 = ["fill"];
    const _hoisted_13 = ["fill"];
    const _hoisted_14 = {
      id: "Group-Copy",
      transform: "translate(34.500000, 31.500000) scale(-1, 1) rotate(-25.000000) translate(-34.500000, -31.500000) translate(7.000000, 10.000000)"
    };
    const _hoisted_15 = ["fill"];
    const _hoisted_16 = ["fill"];
    const _hoisted_17 = ["fill"];
    const _hoisted_18 = ["fill"];
    const _hoisted_19 = ["fill"];
    const _hoisted_20 = {
      id: "Rectangle-Copy-17",
      transform: "translate(53.000000, 45.000000)"
    };
    const _hoisted_21 = ["fill", "xlink:href"];
    const _hoisted_22 = ["fill", "mask"];
    const _hoisted_23 = ["fill"];
    function _sfc_render$f(_ctx, _cache, $props, $setup, $data, $options) {
      return vue.openBlock(), vue.createElementBlock("svg", _hoisted_1$x, [
        vue.createElementVNode("defs", null, [
          vue.createElementVNode("linearGradient", {
            id: `linearGradient-1-${_ctx.id}`,
            x1: "38.8503086%",
            y1: "0%",
            x2: "61.1496914%",
            y2: "100%"
          }, [
            vue.createElementVNode("stop", {
              "stop-color": `var(${_ctx.ns.cssVarBlockName("fill-color-1")})`,
              offset: "0%"
            }, null, 8, _hoisted_3$8),
            vue.createElementVNode("stop", {
              "stop-color": `var(${_ctx.ns.cssVarBlockName("fill-color-4")})`,
              offset: "100%"
            }, null, 8, _hoisted_4$6)
          ], 8, _hoisted_2$l),
          vue.createElementVNode("linearGradient", {
            id: `linearGradient-2-${_ctx.id}`,
            x1: "0%",
            y1: "9.5%",
            x2: "100%",
            y2: "90.5%"
          }, [
            vue.createElementVNode("stop", {
              "stop-color": `var(${_ctx.ns.cssVarBlockName("fill-color-1")})`,
              offset: "0%"
            }, null, 8, _hoisted_6$1),
            vue.createElementVNode("stop", {
              "stop-color": `var(${_ctx.ns.cssVarBlockName("fill-color-6")})`,
              offset: "100%"
            }, null, 8, _hoisted_7)
          ], 8, _hoisted_5$5),
          vue.createElementVNode("rect", {
            id: `path-3-${_ctx.id}`,
            x: "0",
            y: "0",
            width: "17",
            height: "36"
          }, null, 8, _hoisted_8)
        ]),
        vue.createElementVNode("g", _hoisted_9, [
          vue.createElementVNode("g", _hoisted_10, [
            vue.createElementVNode("g", _hoisted_11, [
              vue.createElementVNode("path", {
                id: "Oval-Copy-2",
                d: "M39.5,86 C61.3152476,86 79,83.9106622 79,81.3333333 C79,78.7560045 57.3152476,78 35.5,78 C13.6847524,78 0,78.7560045 0,81.3333333 C0,83.9106622 17.6847524,86 39.5,86 Z",
                fill: `var(${_ctx.ns.cssVarBlockName("fill-color-3")})`
              }, null, 8, _hoisted_12),
              vue.createElementVNode("polygon", {
                id: "Rectangle-Copy-14",
                fill: `var(${_ctx.ns.cssVarBlockName("fill-color-7")})`,
                transform: "translate(27.500000, 51.500000) scale(1, -1) translate(-27.500000, -51.500000) ",
                points: "13 58 53 58 42 45 2 45"
              }, null, 8, _hoisted_13),
              vue.createElementVNode("g", _hoisted_14, [
                vue.createElementVNode("polygon", {
                  id: "Rectangle-Copy-10",
                  fill: `var(${_ctx.ns.cssVarBlockName("fill-color-7")})`,
                  transform: "translate(11.500000, 5.000000) scale(1, -1) translate(-11.500000, -5.000000) ",
                  points: "2.84078316e-14 3 18 3 23 7 5 7"
                }, null, 8, _hoisted_15),
                vue.createElementVNode("polygon", {
                  id: "Rectangle-Copy-11",
                  fill: `var(${_ctx.ns.cssVarBlockName("fill-color-5")})`,
                  points: "-3.69149156e-15 7 38 7 38 43 -3.69149156e-15 43"
                }, null, 8, _hoisted_16),
                vue.createElementVNode("rect", {
                  id: "Rectangle-Copy-12",
                  fill: `url(#linearGradient-1-${_ctx.id})`,
                  transform: "translate(46.500000, 25.000000) scale(-1, 1) translate(-46.500000, -25.000000) ",
                  x: "38",
                  y: "7",
                  width: "17",
                  height: "36"
                }, null, 8, _hoisted_17),
                vue.createElementVNode("polygon", {
                  id: "Rectangle-Copy-13",
                  fill: `var(${_ctx.ns.cssVarBlockName("fill-color-2")})`,
                  transform: "translate(39.500000, 3.500000) scale(-1, 1) translate(-39.500000, -3.500000) ",
                  points: "24 7 41 7 55 -3.63806207e-12 38 -3.63806207e-12"
                }, null, 8, _hoisted_18)
              ]),
              vue.createElementVNode("rect", {
                id: "Rectangle-Copy-15",
                fill: `url(#linearGradient-2-${_ctx.id})`,
                x: "13",
                y: "45",
                width: "40",
                height: "36"
              }, null, 8, _hoisted_19),
              vue.createElementVNode("g", _hoisted_20, [
                vue.createElementVNode("use", {
                  id: "Mask",
                  fill: `var(${_ctx.ns.cssVarBlockName("fill-color-8")})`,
                  transform: "translate(8.500000, 18.000000) scale(-1, 1) translate(-8.500000, -18.000000) ",
                  "xlink:href": `#path-3-${_ctx.id}`
                }, null, 8, _hoisted_21),
                vue.createElementVNode("polygon", {
                  id: "Rectangle-Copy",
                  fill: `var(${_ctx.ns.cssVarBlockName("fill-color-9")})`,
                  mask: `url(#mask-4-${_ctx.id})`,
                  transform: "translate(12.000000, 9.000000) scale(-1, 1) translate(-12.000000, -9.000000) ",
                  points: "7 0 24 0 20 18 7 16.5"
                }, null, 8, _hoisted_22)
              ]),
              vue.createElementVNode("polygon", {
                id: "Rectangle-Copy-18",
                fill: `var(${_ctx.ns.cssVarBlockName("fill-color-2")})`,
                transform: "translate(66.000000, 51.500000) scale(-1, 1) translate(-66.000000, -51.500000) ",
                points: "62 45 79 45 70 58 53 58"
              }, null, 8, _hoisted_23)
            ])
          ])
        ])
      ]);
    }
    var ImgEmpty = /* @__PURE__ */ _export_sfc(_sfc_main$10, [["render", _sfc_render$f], ["__file", "img-empty.vue"]]);
  
    const emptyProps = {
      image: {
        type: String,
        default: ""
      },
      imageSize: Number,
      description: {
        type: String,
        default: ""
      }
    };
  
    const _hoisted_1$w = ["src"];
    const _hoisted_2$k = { key: 1 };
    const __default__$K = vue.defineComponent({
      name: "ElEmpty"
    });
    const _sfc_main$$ = /* @__PURE__ */ vue.defineComponent({
      ...__default__$K,
      props: emptyProps,
      setup(__props) {
        const props = __props;
        const { t } = useLocale();
        const ns = useNamespace("empty");
        const emptyDescription = vue.computed(() => props.description || t("el.table.emptyText"));
        const imageStyle = vue.computed(() => ({
          width: props.imageSize ? `${props.imageSize}px` : ""
        }));
        return (_ctx, _cache) => {
          return vue.openBlock(), vue.createElementBlock("div", {
            class: vue.normalizeClass(vue.unref(ns).b())
          }, [
            vue.createElementVNode("div", {
              class: vue.normalizeClass(vue.unref(ns).e("image")),
              style: vue.normalizeStyle(vue.unref(imageStyle))
            }, [
              _ctx.image ? (vue.openBlock(), vue.createElementBlock("img", {
                key: 0,
                src: _ctx.image,
                ondragstart: "return false"
              }, null, 8, _hoisted_1$w)) : vue.renderSlot(_ctx.$slots, "image", { key: 1 }, () => [
                vue.createVNode(ImgEmpty)
              ])
            ], 6),
            vue.createElementVNode("div", {
              class: vue.normalizeClass(vue.unref(ns).e("description"))
            }, [
              _ctx.$slots.description ? vue.renderSlot(_ctx.$slots, "description", { key: 0 }) : (vue.openBlock(), vue.createElementBlock("p", _hoisted_2$k, vue.toDisplayString(vue.unref(emptyDescription)), 1))
            ], 2),
            _ctx.$slots.default ? (vue.openBlock(), vue.createElementBlock("div", {
              key: 0,
              class: vue.normalizeClass(vue.unref(ns).e("bottom"))
            }, [
              vue.renderSlot(_ctx.$slots, "default")
            ], 2)) : vue.createCommentVNode("v-if", true)
          ], 2);
        };
      }
    });
    var Empty = /* @__PURE__ */ _export_sfc(_sfc_main$$, [["__file", "empty.vue"]]);
  
    const ElEmpty = withInstall(Empty);
  
    const formProps = buildProps({
      model: Object,
      rules: {
        type: definePropType(Object)
      },
      labelPosition: {
        type: String,
        values: ["left", "right", "top"],
        default: "right"
      },
      requireAsteriskPosition: {
        type: String,
        values: ["left", "right"],
        default: "left"
      },
      labelWidth: {
        type: [String, Number],
        default: ""
      },
      labelSuffix: {
        type: String,
        default: ""
      },
      inline: Boolean,
      inlineMessage: Boolean,
      statusIcon: Boolean,
      showMessage: {
        type: Boolean,
        default: true
      },
      size: {
        type: String,
        values: componentSizes
      },
      disabled: Boolean,
      validateOnRuleChange: {
        type: Boolean,
        default: true
      },
      hideRequiredAsterisk: {
        type: Boolean,
        default: false
      },
      scrollToError: Boolean
    });
    const formEmits = {
      validate: (prop, isValid, message) => (isArray(prop) || isString(prop)) && isBoolean(isValid) && isString(message)
    };
  
    function useFormLabelWidth() {
      const potentialLabelWidthArr = vue.ref([]);
      const autoLabelWidth = vue.computed(() => {
        if (!potentialLabelWidthArr.value.length)
          return "0";
        const max = Math.max(...potentialLabelWidthArr.value);
        return max ? `${max}px` : "";
      });
      function getLabelWidthIndex(width) {
        const index = potentialLabelWidthArr.value.indexOf(width);
        if (index === -1 && autoLabelWidth.value === "0") ;
        return index;
      }
      function registerLabelWidth(val, oldVal) {
        if (val && oldVal) {
          const index = getLabelWidthIndex(oldVal);
          potentialLabelWidthArr.value.splice(index, 1, val);
        } else if (val) {
          potentialLabelWidthArr.value.push(val);
        }
      }
      function deregisterLabelWidth(val) {
        const index = getLabelWidthIndex(val);
        if (index > -1) {
          potentialLabelWidthArr.value.splice(index, 1);
        }
      }
      return {
        autoLabelWidth,
        registerLabelWidth,
        deregisterLabelWidth
      };
    }
    const filterFields = (fields, props) => {
      const normalized = castArray$1(props);
      return normalized.length > 0 ? fields.filter((field) => field.prop && normalized.includes(field.prop)) : fields;
    };
  
    const COMPONENT_NAME$e = "ElForm";
    const __default__$J = vue.defineComponent({
      name: COMPONENT_NAME$e
    });
    const _sfc_main$_ = /* @__PURE__ */ vue.defineComponent({
      ...__default__$J,
      props: formProps,
      emits: formEmits,
      setup(__props, { expose, emit }) {
        const props = __props;
        const fields = [];
        const formSize = useSize();
        const ns = useNamespace("form");
        const formClasses = vue.computed(() => {
          const { labelPosition, inline } = props;
          return [
            ns.b(),
            ns.m(formSize.value || "default"),
            {
              [ns.m(`label-${labelPosition}`)]: labelPosition,
              [ns.m("inline")]: inline
            }
          ];
        });
        const addField = (field) => {
          fields.push(field);
        };
        const removeField = (field) => {
          if (field.prop) {
            fields.splice(fields.indexOf(field), 1);
          }
        };
        const resetFields = (properties = []) => {
          if (!props.model) {
            return;
          }
          filterFields(fields, properties).forEach((field) => field.resetField());
        };
        const clearValidate = (props2 = []) => {
          filterFields(fields, props2).forEach((field) => field.clearValidate());
        };
        const isValidatable = vue.computed(() => {
          const hasModel = !!props.model;
          return hasModel;
        });
        const obtainValidateFields = (props2) => {
          if (fields.length === 0)
            return [];
          const filteredFields = filterFields(fields, props2);
          if (!filteredFields.length) {
            return [];
          }
          return filteredFields;
        };
        const validate = async (callback) => validateField(void 0, callback);
        const doValidateField = async (props2 = []) => {
          if (!isValidatable.value)
            return false;
          const fields2 = obtainValidateFields(props2);
          if (fields2.length === 0)
            return true;
          let validationErrors = {};
          for (const field of fields2) {
            try {
              await field.validate("");
            } catch (fields3) {
              validationErrors = {
                ...validationErrors,
                ...fields3
              };
            }
          }
          if (Object.keys(validationErrors).length === 0)
            return true;
          return Promise.reject(validationErrors);
        };
        const validateField = async (modelProps = [], callback) => {
          const shouldThrow = !isFunction(callback);
          try {
            const result = await doValidateField(modelProps);
            if (result === true) {
              callback == null ? void 0 : callback(result);
            }
            return result;
          } catch (e) {
            if (e instanceof Error)
              throw e;
            const invalidFields = e;
            if (props.scrollToError) {
              scrollToField(Object.keys(invalidFields)[0]);
            }
            callback == null ? void 0 : callback(false, invalidFields);
            return shouldThrow && Promise.reject(invalidFields);
          }
        };
        const scrollToField = (prop) => {
          var _a;
          const field = filterFields(fields, prop)[0];
          if (field) {
            (_a = field.$el) == null ? void 0 : _a.scrollIntoView();
          }
        };
        vue.watch(() => props.rules, () => {
          if (props.validateOnRuleChange) {
            validate().catch((err) => debugWarn());
          }
        }, { deep: true });
        vue.provide(formContextKey, vue.reactive({
          ...vue.toRefs(props),
          emit,
          resetFields,
          clearValidate,
          validateField,
          addField,
          removeField,
          ...useFormLabelWidth()
        }));
        expose({
          validate,
          validateField,
          resetFields,
          clearValidate,
          scrollToField
        });
        return (_ctx, _cache) => {
          return vue.openBlock(), vue.createElementBlock("form", {
            class: vue.normalizeClass(vue.unref(formClasses))
          }, [
            vue.renderSlot(_ctx.$slots, "default")
          ], 2);
        };
      }
    });
    var Form = /* @__PURE__ */ _export_sfc(_sfc_main$_, [["__file", "form.vue"]]);
  
    function _extends() {
      _extends = Object.assign ? Object.assign.bind() : function(target) {
        for (var i = 1; i < arguments.length; i++) {
          var source = arguments[i];
          for (var key in source) {
            if (Object.prototype.hasOwnProperty.call(source, key)) {
              target[key] = source[key];
            }
          }
        }
        return target;
      };
      return _extends.apply(this, arguments);
    }
    function _inheritsLoose(subClass, superClass) {
      subClass.prototype = Object.create(superClass.prototype);
      subClass.prototype.constructor = subClass;
      _setPrototypeOf(subClass, superClass);
    }
    function _getPrototypeOf(o) {
      _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf2(o2) {
        return o2.__proto__ || Object.getPrototypeOf(o2);
      };
      return _getPrototypeOf(o);
    }
    function _setPrototypeOf(o, p) {
      _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf2(o2, p2) {
        o2.__proto__ = p2;
        return o2;
      };
      return _setPrototypeOf(o, p);
    }
    function _isNativeReflectConstruct() {
      if (typeof Reflect === "undefined" || !Reflect.construct)
        return false;
      if (Reflect.construct.sham)
        return false;
      if (typeof Proxy === "function")
        return true;
      try {
        Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
        }));
        return true;
      } catch (e) {
        return false;
      }
    }
    function _construct(Parent, args, Class) {
      if (_isNativeReflectConstruct()) {
        _construct = Reflect.construct.bind();
      } else {
        _construct = function _construct2(Parent2, args2, Class2) {
          var a = [null];
          a.push.apply(a, args2);
          var Constructor = Function.bind.apply(Parent2, a);
          var instance = new Constructor();
          if (Class2)
            _setPrototypeOf(instance, Class2.prototype);
          return instance;
        };
      }
      return _construct.apply(null, arguments);
    }
    function _isNativeFunction(fn) {
      return Function.toString.call(fn).indexOf("[native code]") !== -1;
    }
    function _wrapNativeSuper(Class) {
      var _cache = typeof Map === "function" ? /* @__PURE__ */ new Map() : void 0;
      _wrapNativeSuper = function _wrapNativeSuper2(Class2) {
        if (Class2 === null || !_isNativeFunction(Class2))
          return Class2;
        if (typeof Class2 !== "function") {
          throw new TypeError("Super expression must either be null or a function");
        }
        if (typeof _cache !== "undefined") {
          if (_cache.has(Class2))
            return _cache.get(Class2);
          _cache.set(Class2, Wrapper);
        }
        function Wrapper() {
          return _construct(Class2, arguments, _getPrototypeOf(this).constructor);
        }
        Wrapper.prototype = Object.create(Class2.prototype, {
          constructor: {
            value: Wrapper,
            enumerable: false,
            writable: true,
            configurable: true
          }
        });
        return _setPrototypeOf(Wrapper, Class2);
      };
      return _wrapNativeSuper(Class);
    }
    var formatRegExp = /%[sdj%]/g;
    var warning = function warning2() {
    };
    if (typeof process !== "undefined" && process.env && false) {
      warning = function warning3(type4, errors) {
        if (typeof console !== "undefined" && console.warn && typeof ASYNC_VALIDATOR_NO_WARNING === "undefined") {
          if (errors.every(function(e) {
            return typeof e === "string";
          })) {
            console.warn(type4, errors);
          }
        }
      };
    }
    function convertFieldsError(errors) {
      if (!errors || !errors.length)
        return null;
      var fields = {};
      errors.forEach(function(error) {
        var field = error.field;
        fields[field] = fields[field] || [];
        fields[field].push(error);
      });
      return fields;
    }
    function format(template) {
      for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
        args[_key - 1] = arguments[_key];
      }
      var i = 0;
      var len = args.length;
      if (typeof template === "function") {
        return template.apply(null, args);
      }
      if (typeof template === "string") {
        var str = template.replace(formatRegExp, function(x) {
          if (x === "%%") {
            return "%";
          }
          if (i >= len) {
            return x;
          }
          switch (x) {
            case "%s":
              return String(args[i++]);
            case "%d":
              return Number(args[i++]);
            case "%j":
              try {
                return JSON.stringify(args[i++]);
              } catch (_) {
                return "[Circular]";
              }
              break;
            default:
              return x;
          }
        });
        return str;
      }
      return template;
    }
    function isNativeStringType(type4) {
      return type4 === "string" || type4 === "url" || type4 === "hex" || type4 === "email" || type4 === "date" || type4 === "pattern";
    }
    function isEmptyValue(value, type4) {
      if (value === void 0 || value === null) {
        return true;
      }
      if (type4 === "array" && Array.isArray(value) && !value.length) {
        return true;
      }
      if (isNativeStringType(type4) && typeof value === "string" && !value) {
        return true;
      }
      return false;
    }
    function asyncParallelArray(arr, func, callback) {
      var results = [];
      var total = 0;
      var arrLength = arr.length;
      function count(errors) {
        results.push.apply(results, errors || []);
        total++;
        if (total === arrLength) {
          callback(results);
        }
      }
      arr.forEach(function(a) {
        func(a, count);
      });
    }
    function asyncSerialArray(arr, func, callback) {
      var index = 0;
      var arrLength = arr.length;
      function next(errors) {
        if (errors && errors.length) {
          callback(errors);
          return;
        }
        var original = index;
        index = index + 1;
        if (original < arrLength) {
          func(arr[original], next);
        } else {
          callback([]);
        }
      }
      next([]);
    }
    function flattenObjArr(objArr) {
      var ret = [];
      Object.keys(objArr).forEach(function(k) {
        ret.push.apply(ret, objArr[k] || []);
      });
      return ret;
    }
    var AsyncValidationError = /* @__PURE__ */ function(_Error) {
      _inheritsLoose(AsyncValidationError2, _Error);
      function AsyncValidationError2(errors, fields) {
        var _this;
        _this = _Error.call(this, "Async Validation Error") || this;
        _this.errors = errors;
        _this.fields = fields;
        return _this;
      }
      return AsyncValidationError2;
    }(/* @__PURE__ */ _wrapNativeSuper(Error));
    function asyncMap(objArr, option, func, callback, source) {
      if (option.first) {
        var _pending = new Promise(function(resolve, reject) {
          var next = function next2(errors) {
            callback(errors);
            return errors.length ? reject(new AsyncValidationError(errors, convertFieldsError(errors))) : resolve(source);
          };
          var flattenArr = flattenObjArr(objArr);
          asyncSerialArray(flattenArr, func, next);
        });
        _pending["catch"](function(e) {
          return e;
        });
        return _pending;
      }
      var firstFields = option.firstFields === true ? Object.keys(objArr) : option.firstFields || [];
      var objArrKeys = Object.keys(objArr);
      var objArrLength = objArrKeys.length;
      var total = 0;
      var results = [];
      var pending = new Promise(function(resolve, reject) {
        var next = function next2(errors) {
          results.push.apply(results, errors);
          total++;
          if (total === objArrLength) {
            callback(results);
            return results.length ? reject(new AsyncValidationError(results, convertFieldsError(results))) : resolve(source);
          }
        };
        if (!objArrKeys.length) {
          callback(results);
          resolve(source);
        }
        objArrKeys.forEach(function(key) {
          var arr = objArr[key];
          if (firstFields.indexOf(key) !== -1) {
            asyncSerialArray(arr, func, next);
          } else {
            asyncParallelArray(arr, func, next);
          }
        });
      });
      pending["catch"](function(e) {
        return e;
      });
      return pending;
    }
    function isErrorObj(obj) {
      return !!(obj && obj.message !== void 0);
    }
    function getValue(value, path) {
      var v = value;
      for (var i = 0; i < path.length; i++) {
        if (v == void 0) {
          return v;
        }
        v = v[path[i]];
      }
      return v;
    }
    function complementError(rule, source) {
      return function(oe) {
        var fieldValue;
        if (rule.fullFields) {
          fieldValue = getValue(source, rule.fullFields);
        } else {
          fieldValue = source[oe.field || rule.fullField];
        }
        if (isErrorObj(oe)) {
          oe.field = oe.field || rule.fullField;
          oe.fieldValue = fieldValue;
          return oe;
        }
        return {
          message: typeof oe === "function" ? oe() : oe,
          fieldValue,
          field: oe.field || rule.fullField
        };
      };
    }
    function deepMerge(target, source) {
      if (source) {
        for (var s in source) {
          if (source.hasOwnProperty(s)) {
            var value = source[s];
            if (typeof value === "object" && typeof target[s] === "object") {
              target[s] = _extends({}, target[s], value);
            } else {
              target[s] = value;
            }
          }
        }
      }
      return target;
    }
    var required$1 = function required(rule, value, source, errors, options, type4) {
      if (rule.required && (!source.hasOwnProperty(rule.field) || isEmptyValue(value, type4 || rule.type))) {
        errors.push(format(options.messages.required, rule.fullField));
      }
    };
    var whitespace = function whitespace2(rule, value, source, errors, options) {
      if (/^\s+$/.test(value) || value === "") {
        errors.push(format(options.messages.whitespace, rule.fullField));
      }
    };
    var urlReg;
    var getUrlRegex = function() {
      if (urlReg) {
        return urlReg;
      }
      var word = "[a-fA-F\\d:]";
      var b = function b2(options) {
        return options && options.includeBoundaries ? "(?:(?<=\\s|^)(?=" + word + ")|(?<=" + word + ")(?=\\s|$))" : "";
      };
      var v4 = "(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)(?:\\.(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)){3}";
      var v6seg = "[a-fA-F\\d]{1,4}";
      var v6 = ("\n(?:\n(?:" + v6seg + ":){7}(?:" + v6seg + "|:)|                                    // 1:2:3:4:5:6:7::  1:2:3:4:5:6:7:8\n(?:" + v6seg + ":){6}(?:" + v4 + "|:" + v6seg + "|:)|                             // 1:2:3:4:5:6::    1:2:3:4:5:6::8   1:2:3:4:5:6::8  1:2:3:4:5:6::1.2.3.4\n(?:" + v6seg + ":){5}(?::" + v4 + "|(?::" + v6seg + "){1,2}|:)|                   // 1:2:3:4:5::      1:2:3:4:5::7:8   1:2:3:4:5::8    1:2:3:4:5::7:1.2.3.4\n(?:" + v6seg + ":){4}(?:(?::" + v6seg + "){0,1}:" + v4 + "|(?::" + v6seg + "){1,3}|:)| // 1:2:3:4::        1:2:3:4::6:7:8   1:2:3:4::8      1:2:3:4::6:7:1.2.3.4\n(?:" + v6seg + ":){3}(?:(?::" + v6seg + "){0,2}:" + v4 + "|(?::" + v6seg + "){1,4}|:)| // 1:2:3::          1:2:3::5:6:7:8   1:2:3::8        1:2:3::5:6:7:1.2.3.4\n(?:" + v6seg + ":){2}(?:(?::" + v6seg + "){0,3}:" + v4 + "|(?::" + v6seg + "){1,5}|:)| // 1:2::            1:2::4:5:6:7:8   1:2::8          1:2::4:5:6:7:1.2.3.4\n(?:" + v6seg + ":){1}(?:(?::" + v6seg + "){0,4}:" + v4 + "|(?::" + v6seg + "){1,6}|:)| // 1::              1::3:4:5:6:7:8   1::8            1::3:4:5:6:7:1.2.3.4\n(?::(?:(?::" + v6seg + "){0,5}:" + v4 + "|(?::" + v6seg + "){1,7}|:))             // ::2:3:4:5:6:7:8  ::2:3:4:5:6:7:8  ::8             ::1.2.3.4\n)(?:%[0-9a-zA-Z]{1,})?                                             // %eth0            %1\n").replace(/\s*\/\/.*$/gm, "").replace(/\n/g, "").trim();
      var v46Exact = new RegExp("(?:^" + v4 + "$)|(?:^" + v6 + "$)");
      var v4exact = new RegExp("^" + v4 + "$");
      var v6exact = new RegExp("^" + v6 + "$");
      var ip = function ip2(options) {
        return options && options.exact ? v46Exact : new RegExp("(?:" + b(options) + v4 + b(options) + ")|(?:" + b(options) + v6 + b(options) + ")", "g");
      };
      ip.v4 = function(options) {
        return options && options.exact ? v4exact : new RegExp("" + b(options) + v4 + b(options), "g");
      };
      ip.v6 = function(options) {
        return options && options.exact ? v6exact : new RegExp("" + b(options) + v6 + b(options), "g");
      };
      var protocol = "(?:(?:[a-z]+:)?//)";
      var auth = "(?:\\S+(?::\\S*)?@)?";
      var ipv4 = ip.v4().source;
      var ipv6 = ip.v6().source;
      var host = "(?:(?:[a-z\\u00a1-\\uffff0-9][-_]*)*[a-z\\u00a1-\\uffff0-9]+)";
      var domain = "(?:\\.(?:[a-z\\u00a1-\\uffff0-9]-*)*[a-z\\u00a1-\\uffff0-9]+)*";
      var tld = "(?:\\.(?:[a-z\\u00a1-\\uffff]{2,}))";
      var port = "(?::\\d{2,5})?";
      var path = '(?:[/?#][^\\s"]*)?';
      var regex = "(?:" + protocol + "|www\\.)" + auth + "(?:localhost|" + ipv4 + "|" + ipv6 + "|" + host + domain + tld + ")" + port + path;
      urlReg = new RegExp("(?:^" + regex + "$)", "i");
      return urlReg;
    };
    var pattern$2 = {
      email: /^(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]+\.)+[a-zA-Z\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]{2,}))$/,
      hex: /^#?([a-f0-9]{6}|[a-f0-9]{3})$/i
    };
    var types = {
      integer: function integer(value) {
        return types.number(value) && parseInt(value, 10) === value;
      },
      "float": function float(value) {
        return types.number(value) && !types.integer(value);
      },
      array: function array(value) {
        return Array.isArray(value);
      },
      regexp: function regexp(value) {
        if (value instanceof RegExp) {
          return true;
        }
        try {
          return !!new RegExp(value);
        } catch (e) {
          return false;
        }
      },
      date: function date(value) {
        return typeof value.getTime === "function" && typeof value.getMonth === "function" && typeof value.getYear === "function" && !isNaN(value.getTime());
      },
      number: function number(value) {
        if (isNaN(value)) {
          return false;
        }
        return typeof value === "number";
      },
      object: function object(value) {
        return typeof value === "object" && !types.array(value);
      },
      method: function method(value) {
        return typeof value === "function";
      },
      email: function email(value) {
        return typeof value === "string" && value.length <= 320 && !!value.match(pattern$2.email);
      },
      url: function url(value) {
        return typeof value === "string" && value.length <= 2048 && !!value.match(getUrlRegex());
      },
      hex: function hex(value) {
        return typeof value === "string" && !!value.match(pattern$2.hex);
      }
    };
    var type$1 = function type(rule, value, source, errors, options) {
      if (rule.required && value === void 0) {
        required$1(rule, value, source, errors, options);
        return;
      }
      var custom = ["integer", "float", "array", "regexp", "object", "method", "email", "number", "date", "url", "hex"];
      var ruleType = rule.type;
      if (custom.indexOf(ruleType) > -1) {
        if (!types[ruleType](value)) {
          errors.push(format(options.messages.types[ruleType], rule.fullField, rule.type));
        }
      } else if (ruleType && typeof value !== rule.type) {
        errors.push(format(options.messages.types[ruleType], rule.fullField, rule.type));
      }
    };
    var range = function range2(rule, value, source, errors, options) {
      var len = typeof rule.len === "number";
      var min = typeof rule.min === "number";
      var max = typeof rule.max === "number";
      var spRegexp = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g;
      var val = value;
      var key = null;
      var num = typeof value === "number";
      var str = typeof value === "string";
      var arr = Array.isArray(value);
      if (num) {
        key = "number";
      } else if (str) {
        key = "string";
      } else if (arr) {
        key = "array";
      }
      if (!key) {
        return false;
      }
      if (arr) {
        val = value.length;
      }
      if (str) {
        val = value.replace(spRegexp, "_").length;
      }
      if (len) {
        if (val !== rule.len) {
          errors.push(format(options.messages[key].len, rule.fullField, rule.len));
        }
      } else if (min && !max && val < rule.min) {
        errors.push(format(options.messages[key].min, rule.fullField, rule.min));
      } else if (max && !min && val > rule.max) {
        errors.push(format(options.messages[key].max, rule.fullField, rule.max));
      } else if (min && max && (val < rule.min || val > rule.max)) {
        errors.push(format(options.messages[key].range, rule.fullField, rule.min, rule.max));
      }
    };
    var ENUM$1 = "enum";
    var enumerable$1 = function enumerable(rule, value, source, errors, options) {
      rule[ENUM$1] = Array.isArray(rule[ENUM$1]) ? rule[ENUM$1] : [];
      if (rule[ENUM$1].indexOf(value) === -1) {
        errors.push(format(options.messages[ENUM$1], rule.fullField, rule[ENUM$1].join(", ")));
      }
    };
    var pattern$1 = function pattern(rule, value, source, errors, options) {
      if (rule.pattern) {
        if (rule.pattern instanceof RegExp) {
          rule.pattern.lastIndex = 0;
          if (!rule.pattern.test(value)) {
            errors.push(format(options.messages.pattern.mismatch, rule.fullField, value, rule.pattern));
          }
        } else if (typeof rule.pattern === "string") {
          var _pattern = new RegExp(rule.pattern);
          if (!_pattern.test(value)) {
            errors.push(format(options.messages.pattern.mismatch, rule.fullField, value, rule.pattern));
          }
        }
      }
    };
    var rules = {
      required: required$1,
      whitespace,
      type: type$1,
      range,
      "enum": enumerable$1,
      pattern: pattern$1
    };
    var string = function string2(rule, value, callback, source, options) {
      var errors = [];
      var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
      if (validate) {
        if (isEmptyValue(value, "string") && !rule.required) {
          return callback();
        }
        rules.required(rule, value, source, errors, options, "string");
        if (!isEmptyValue(value, "string")) {
          rules.type(rule, value, source, errors, options);
          rules.range(rule, value, source, errors, options);
          rules.pattern(rule, value, source, errors, options);
          if (rule.whitespace === true) {
            rules.whitespace(rule, value, source, errors, options);
          }
        }
      }
      callback(errors);
    };
    var method2 = function method3(rule, value, callback, source, options) {
      var errors = [];
      var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
      if (validate) {
        if (isEmptyValue(value) && !rule.required) {
          return callback();
        }
        rules.required(rule, value, source, errors, options);
        if (value !== void 0) {
          rules.type(rule, value, source, errors, options);
        }
      }
      callback(errors);
    };
    var number2 = function number3(rule, value, callback, source, options) {
      var errors = [];
      var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
      if (validate) {
        if (value === "") {
          value = void 0;
        }
        if (isEmptyValue(value) && !rule.required) {
          return callback();
        }
        rules.required(rule, value, source, errors, options);
        if (value !== void 0) {
          rules.type(rule, value, source, errors, options);
          rules.range(rule, value, source, errors, options);
        }
      }
      callback(errors);
    };
    var _boolean = function _boolean2(rule, value, callback, source, options) {
      var errors = [];
      var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
      if (validate) {
        if (isEmptyValue(value) && !rule.required) {
          return callback();
        }
        rules.required(rule, value, source, errors, options);
        if (value !== void 0) {
          rules.type(rule, value, source, errors, options);
        }
      }
      callback(errors);
    };
    var regexp2 = function regexp3(rule, value, callback, source, options) {
      var errors = [];
      var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
      if (validate) {
        if (isEmptyValue(value) && !rule.required) {
          return callback();
        }
        rules.required(rule, value, source, errors, options);
        if (!isEmptyValue(value)) {
          rules.type(rule, value, source, errors, options);
        }
      }
      callback(errors);
    };
    var integer2 = function integer3(rule, value, callback, source, options) {
      var errors = [];
      var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
      if (validate) {
        if (isEmptyValue(value) && !rule.required) {
          return callback();
        }
        rules.required(rule, value, source, errors, options);
        if (value !== void 0) {
          rules.type(rule, value, source, errors, options);
          rules.range(rule, value, source, errors, options);
        }
      }
      callback(errors);
    };
    var floatFn = function floatFn2(rule, value, callback, source, options) {
      var errors = [];
      var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
      if (validate) {
        if (isEmptyValue(value) && !rule.required) {
          return callback();
        }
        rules.required(rule, value, source, errors, options);
        if (value !== void 0) {
          rules.type(rule, value, source, errors, options);
          rules.range(rule, value, source, errors, options);
        }
      }
      callback(errors);
    };
    var array2 = function array3(rule, value, callback, source, options) {
      var errors = [];
      var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
      if (validate) {
        if ((value === void 0 || value === null) && !rule.required) {
          return callback();
        }
        rules.required(rule, value, source, errors, options, "array");
        if (value !== void 0 && value !== null) {
          rules.type(rule, value, source, errors, options);
          rules.range(rule, value, source, errors, options);
        }
      }
      callback(errors);
    };
    var object2 = function object3(rule, value, callback, source, options) {
      var errors = [];
      var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
      if (validate) {
        if (isEmptyValue(value) && !rule.required) {
          return callback();
        }
        rules.required(rule, value, source, errors, options);
        if (value !== void 0) {
          rules.type(rule, value, source, errors, options);
        }
      }
      callback(errors);
    };
    var ENUM = "enum";
    var enumerable2 = function enumerable3(rule, value, callback, source, options) {
      var errors = [];
      var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
      if (validate) {
        if (isEmptyValue(value) && !rule.required) {
          return callback();
        }
        rules.required(rule, value, source, errors, options);
        if (value !== void 0) {
          rules[ENUM](rule, value, source, errors, options);
        }
      }
      callback(errors);
    };
    var pattern2 = function pattern3(rule, value, callback, source, options) {
      var errors = [];
      var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
      if (validate) {
        if (isEmptyValue(value, "string") && !rule.required) {
          return callback();
        }
        rules.required(rule, value, source, errors, options);
        if (!isEmptyValue(value, "string")) {
          rules.pattern(rule, value, source, errors, options);
        }
      }
      callback(errors);
    };
    var date2 = function date3(rule, value, callback, source, options) {
      var errors = [];
      var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
      if (validate) {
        if (isEmptyValue(value, "date") && !rule.required) {
          return callback();
        }
        rules.required(rule, value, source, errors, options);
        if (!isEmptyValue(value, "date")) {
          var dateObject;
          if (value instanceof Date) {
            dateObject = value;
          } else {
            dateObject = new Date(value);
          }
          rules.type(rule, dateObject, source, errors, options);
          if (dateObject) {
            rules.range(rule, dateObject.getTime(), source, errors, options);
          }
        }
      }
      callback(errors);
    };
    var required2 = function required3(rule, value, callback, source, options) {
      var errors = [];
      var type4 = Array.isArray(value) ? "array" : typeof value;
      rules.required(rule, value, source, errors, options, type4);
      callback(errors);
    };
    var type2 = function type3(rule, value, callback, source, options) {
      var ruleType = rule.type;
      var errors = [];
      var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
      if (validate) {
        if (isEmptyValue(value, ruleType) && !rule.required) {
          return callback();
        }
        rules.required(rule, value, source, errors, options, ruleType);
        if (!isEmptyValue(value, ruleType)) {
          rules.type(rule, value, source, errors, options);
        }
      }
      callback(errors);
    };
    var any = function any2(rule, value, callback, source, options) {
      var errors = [];
      var validate = rule.required || !rule.required && source.hasOwnProperty(rule.field);
      if (validate) {
        if (isEmptyValue(value) && !rule.required) {
          return callback();
        }
        rules.required(rule, value, source, errors, options);
      }
      callback(errors);
    };
    var validators = {
      string,
      method: method2,
      number: number2,
      "boolean": _boolean,
      regexp: regexp2,
      integer: integer2,
      "float": floatFn,
      array: array2,
      object: object2,
      "enum": enumerable2,
      pattern: pattern2,
      date: date2,
      url: type2,
      hex: type2,
      email: type2,
      required: required2,
      any
    };
    function newMessages() {
      return {
        "default": "Validation error on field %s",
        required: "%s is required",
        "enum": "%s must be one of %s",
        whitespace: "%s cannot be empty",
        date: {
          format: "%s date %s is invalid for format %s",
          parse: "%s date could not be parsed, %s is invalid ",
          invalid: "%s date %s is invalid"
        },
        types: {
          string: "%s is not a %s",
          method: "%s is not a %s (function)",
          array: "%s is not an %s",
          object: "%s is not an %s",
          number: "%s is not a %s",
          date: "%s is not a %s",
          "boolean": "%s is not a %s",
          integer: "%s is not an %s",
          "float": "%s is not a %s",
          regexp: "%s is not a valid %s",
          email: "%s is not a valid %s",
          url: "%s is not a valid %s",
          hex: "%s is not a valid %s"
        },
        string: {
          len: "%s must be exactly %s characters",
          min: "%s must be at least %s characters",
          max: "%s cannot be longer than %s characters",
          range: "%s must be between %s and %s characters"
        },
        number: {
          len: "%s must equal %s",
          min: "%s cannot be less than %s",
          max: "%s cannot be greater than %s",
          range: "%s must be between %s and %s"
        },
        array: {
          len: "%s must be exactly %s in length",
          min: "%s cannot be less than %s in length",
          max: "%s cannot be greater than %s in length",
          range: "%s must be between %s and %s in length"
        },
        pattern: {
          mismatch: "%s value %s does not match pattern %s"
        },
        clone: function clone() {
          var cloned = JSON.parse(JSON.stringify(this));
          cloned.clone = this.clone;
          return cloned;
        }
      };
    }
    var messages = newMessages();
    var Schema = /* @__PURE__ */ function() {
      function Schema2(descriptor) {
        this.rules = null;
        this._messages = messages;
        this.define(descriptor);
      }
      var _proto = Schema2.prototype;
      _proto.define = function define(rules2) {
        var _this = this;
        if (!rules2) {
          throw new Error("Cannot configure a schema with no rules");
        }
        if (typeof rules2 !== "object" || Array.isArray(rules2)) {
          throw new Error("Rules must be an object");
        }
        this.rules = {};
        Object.keys(rules2).forEach(function(name) {
          var item = rules2[name];
          _this.rules[name] = Array.isArray(item) ? item : [item];
        });
      };
      _proto.messages = function messages2(_messages) {
        if (_messages) {
          this._messages = deepMerge(newMessages(), _messages);
        }
        return this._messages;
      };
      _proto.validate = function validate(source_, o, oc) {
        var _this2 = this;
        if (o === void 0) {
          o = {};
        }
        if (oc === void 0) {
          oc = function oc2() {
          };
        }
        var source = source_;
        var options = o;
        var callback = oc;
        if (typeof options === "function") {
          callback = options;
          options = {};
        }
        if (!this.rules || Object.keys(this.rules).length === 0) {
          if (callback) {
            callback(null, source);
          }
          return Promise.resolve(source);
        }
        function complete(results) {
          var errors = [];
          var fields = {};
          function add(e) {
            if (Array.isArray(e)) {
              var _errors;
              errors = (_errors = errors).concat.apply(_errors, e);
            } else {
              errors.push(e);
            }
          }
          for (var i = 0; i < results.length; i++) {
            add(results[i]);
          }
          if (!errors.length) {
            callback(null, source);
          } else {
            fields = convertFieldsError(errors);
            callback(errors, fields);
          }
        }
        if (options.messages) {
          var messages$1 = this.messages();
          if (messages$1 === messages) {
            messages$1 = newMessages();
          }
          deepMerge(messages$1, options.messages);
          options.messages = messages$1;
        } else {
          options.messages = this.messages();
        }
        var series = {};
        var keys = options.keys || Object.keys(this.rules);
        keys.forEach(function(z) {
          var arr = _this2.rules[z];
          var value = source[z];
          arr.forEach(function(r) {
            var rule = r;
            if (typeof rule.transform === "function") {
              if (source === source_) {
                source = _extends({}, source);
              }
              value = source[z] = rule.transform(value);
            }
            if (typeof rule === "function") {
              rule = {
                validator: rule
              };
            } else {
              rule = _extends({}, rule);
            }
            rule.validator = _this2.getValidationMethod(rule);
            if (!rule.validator) {
              return;
            }
            rule.field = z;
            rule.fullField = rule.fullField || z;
            rule.type = _this2.getType(rule);
            series[z] = series[z] || [];
            series[z].push({
              rule,
              value,
              source,
              field: z
            });
          });
        });
        var errorFields = {};
        return asyncMap(series, options, function(data, doIt) {
          var rule = data.rule;
          var deep = (rule.type === "object" || rule.type === "array") && (typeof rule.fields === "object" || typeof rule.defaultField === "object");
          deep = deep && (rule.required || !rule.required && data.value);
          rule.field = data.field;
          function addFullField(key, schema) {
            return _extends({}, schema, {
              fullField: rule.fullField + "." + key,
              fullFields: rule.fullFields ? [].concat(rule.fullFields, [key]) : [key]
            });
          }
          function cb(e) {
            if (e === void 0) {
              e = [];
            }
            var errorList = Array.isArray(e) ? e : [e];
            if (!options.suppressWarning && errorList.length) {
              Schema2.warning("async-validator:", errorList);
            }
            if (errorList.length && rule.message !== void 0) {
              errorList = [].concat(rule.message);
            }
            var filledErrors = errorList.map(complementError(rule, source));
            if (options.first && filledErrors.length) {
              errorFields[rule.field] = 1;
              return doIt(filledErrors);
            }
            if (!deep) {
              doIt(filledErrors);
            } else {
              if (rule.required && !data.value) {
                if (rule.message !== void 0) {
                  filledErrors = [].concat(rule.message).map(complementError(rule, source));
                } else if (options.error) {
                  filledErrors = [options.error(rule, format(options.messages.required, rule.field))];
                }
                return doIt(filledErrors);
              }
              var fieldsSchema = {};
              if (rule.defaultField) {
                Object.keys(data.value).map(function(key) {
                  fieldsSchema[key] = rule.defaultField;
                });
              }
              fieldsSchema = _extends({}, fieldsSchema, data.rule.fields);
              var paredFieldsSchema = {};
              Object.keys(fieldsSchema).forEach(function(field) {
                var fieldSchema = fieldsSchema[field];
                var fieldSchemaList = Array.isArray(fieldSchema) ? fieldSchema : [fieldSchema];
                paredFieldsSchema[field] = fieldSchemaList.map(addFullField.bind(null, field));
              });
              var schema = new Schema2(paredFieldsSchema);
              schema.messages(options.messages);
              if (data.rule.options) {
                data.rule.options.messages = options.messages;
                data.rule.options.error = options.error;
              }
              schema.validate(data.value, data.rule.options || options, function(errs) {
                var finalErrors = [];
                if (filledErrors && filledErrors.length) {
                  finalErrors.push.apply(finalErrors, filledErrors);
                }
                if (errs && errs.length) {
                  finalErrors.push.apply(finalErrors, errs);
                }
                doIt(finalErrors.length ? finalErrors : null);
              });
            }
          }
          var res;
          if (rule.asyncValidator) {
            res = rule.asyncValidator(rule, data.value, cb, data.source, options);
          } else if (rule.validator) {
            try {
              res = rule.validator(rule, data.value, cb, data.source, options);
            } catch (error) {
              console.error == null ? void 0 : console.error(error);
              if (!options.suppressValidatorError) {
                setTimeout(function() {
                  throw error;
                }, 0);
              }
              cb(error.message);
            }
            if (res === true) {
              cb();
            } else if (res === false) {
              cb(typeof rule.message === "function" ? rule.message(rule.fullField || rule.field) : rule.message || (rule.fullField || rule.field) + " fails");
            } else if (res instanceof Array) {
              cb(res);
            } else if (res instanceof Error) {
              cb(res.message);
            }
          }
          if (res && res.then) {
            res.then(function() {
              return cb();
            }, function(e) {
              return cb(e);
            });
          }
        }, function(results) {
          complete(results);
        }, source);
      };
      _proto.getType = function getType(rule) {
        if (rule.type === void 0 && rule.pattern instanceof RegExp) {
          rule.type = "pattern";
        }
        if (typeof rule.validator !== "function" && rule.type && !validators.hasOwnProperty(rule.type)) {
          throw new Error(format("Unknown rule type %s", rule.type));
        }
        return rule.type || "string";
      };
      _proto.getValidationMethod = function getValidationMethod(rule) {
        if (typeof rule.validator === "function") {
          return rule.validator;
        }
        var keys = Object.keys(rule);
        var messageIndex = keys.indexOf("message");
        if (messageIndex !== -1) {
          keys.splice(messageIndex, 1);
        }
        if (keys.length === 1 && keys[0] === "required") {
          return validators.required;
        }
        return validators[this.getType(rule)] || void 0;
      };
      return Schema2;
    }();
    Schema.register = function register(type4, validator) {
      if (typeof validator !== "function") {
        throw new Error("Cannot register a validator by type, validator is not a function");
      }
      validators[type4] = validator;
    };
    Schema.warning = warning;
    Schema.messages = messages;
    Schema.validators = validators;
  
    const formItemValidateStates = [
      "",
      "error",
      "validating",
      "success"
    ];
    const formItemProps = buildProps({
      label: String,
      labelWidth: {
        type: [String, Number],
        default: ""
      },
      prop: {
        type: definePropType([String, Array])
      },
      required: {
        type: Boolean,
        default: void 0
      },
      rules: {
        type: definePropType([Object, Array])
      },
      error: String,
      validateStatus: {
        type: String,
        values: formItemValidateStates
      },
      for: String,
      inlineMessage: {
        type: [String, Boolean],
        default: ""
      },
      showMessage: {
        type: Boolean,
        default: true
      },
      size: {
        type: String,
        values: componentSizes
      }
    });
  
    const COMPONENT_NAME$d = "ElLabelWrap";
    var FormLabelWrap = vue.defineComponent({
      name: COMPONENT_NAME$d,
      props: {
        isAutoWidth: Boolean,
        updateAll: Boolean
      },
      setup(props, {
        slots
      }) {
        const formContext = vue.inject(formContextKey, void 0);
        const formItemContext = vue.inject(formItemContextKey);
        if (!formItemContext)
          throwError(COMPONENT_NAME$d, "usage: <el-form-item><label-wrap /></el-form-item>");
        const ns = useNamespace("form");
        const el = vue.ref();
        const computedWidth = vue.ref(0);
        const getLabelWidth = () => {
          var _a;
          if ((_a = el.value) == null ? void 0 : _a.firstElementChild) {
            const width = window.getComputedStyle(el.value.firstElementChild).width;
            return Math.ceil(Number.parseFloat(width));
          } else {
            return 0;
          }
        };
        const updateLabelWidth = (action = "update") => {
          vue.nextTick(() => {
            if (slots.default && props.isAutoWidth) {
              if (action === "update") {
                computedWidth.value = getLabelWidth();
              } else if (action === "remove") {
                formContext == null ? void 0 : formContext.deregisterLabelWidth(computedWidth.value);
              }
            }
          });
        };
        const updateLabelWidthFn = () => updateLabelWidth("update");
        vue.onMounted(() => {
          updateLabelWidthFn();
        });
        vue.onBeforeUnmount(() => {
          updateLabelWidth("remove");
        });
        vue.onUpdated(() => updateLabelWidthFn());
        vue.watch(computedWidth, (val, oldVal) => {
          if (props.updateAll) {
            formContext == null ? void 0 : formContext.registerLabelWidth(val, oldVal);
          }
        });
        useResizeObserver(vue.computed(() => {
          var _a, _b;
          return (_b = (_a = el.value) == null ? void 0 : _a.firstElementChild) != null ? _b : null;
        }), updateLabelWidthFn);
        return () => {
          var _a, _b;
          if (!slots)
            return null;
          const {
            isAutoWidth
          } = props;
          if (isAutoWidth) {
            const autoLabelWidth = formContext == null ? void 0 : formContext.autoLabelWidth;
            const hasLabel = formItemContext == null ? void 0 : formItemContext.hasLabel;
            const style = {};
            if (hasLabel && autoLabelWidth && autoLabelWidth !== "auto") {
              const marginWidth = Math.max(0, Number.parseInt(autoLabelWidth, 10) - computedWidth.value);
              const marginPosition = formContext.labelPosition === "left" ? "marginRight" : "marginLeft";
              if (marginWidth) {
                style[marginPosition] = `${marginWidth}px`;
              }
            }
            return vue.createVNode("div", {
              "ref": el,
              "class": [ns.be("item", "label-wrap")],
              "style": style
            }, [(_a = slots.default) == null ? void 0 : _a.call(slots)]);
          } else {
            return vue.createVNode(vue.Fragment, {
              "ref": el
            }, [(_b = slots.default) == null ? void 0 : _b.call(slots)]);
          }
        };
      }
    });
  
    const _hoisted_1$v = ["role", "aria-labelledby"];
    const __default__$I = vue.defineComponent({
      name: "ElFormItem"
    });
    const _sfc_main$Z = /* @__PURE__ */ vue.defineComponent({
      ...__default__$I,
      props: formItemProps,
      setup(__props, { expose }) {
        const props = __props;
        const slots = vue.useSlots();
        const formContext = vue.inject(formContextKey, void 0);
        const parentFormItemContext = vue.inject(formItemContextKey, void 0);
        const _size = useSize(void 0, { formItem: false });
        const ns = useNamespace("form-item");
        const labelId = useId().value;
        const inputIds = vue.ref([]);
        const validateState = vue.ref("");
        const validateStateDebounced = refDebounced(validateState, 100);
        const validateMessage = vue.ref("");
        const formItemRef = vue.ref();
        let initialValue = void 0;
        let isResettingField = false;
        const labelStyle = vue.computed(() => {
          if ((formContext == null ? void 0 : formContext.labelPosition) === "top") {
            return {};
          }
          const labelWidth = addUnit(props.labelWidth || (formContext == null ? void 0 : formContext.labelWidth) || "");
          if (labelWidth)
            return { width: labelWidth };
          return {};
        });
        const contentStyle = vue.computed(() => {
          if ((formContext == null ? void 0 : formContext.labelPosition) === "top" || (formContext == null ? void 0 : formContext.inline)) {
            return {};
          }
          if (!props.label && !props.labelWidth && isNested) {
            return {};
          }
          const labelWidth = addUnit(props.labelWidth || (formContext == null ? void 0 : formContext.labelWidth) || "");
          if (!props.label && !slots.label) {
            return { marginLeft: labelWidth };
          }
          return {};
        });
        const formItemClasses = vue.computed(() => [
          ns.b(),
          ns.m(_size.value),
          ns.is("error", validateState.value === "error"),
          ns.is("validating", validateState.value === "validating"),
          ns.is("success", validateState.value === "success"),
          ns.is("required", isRequired.value || props.required),
          ns.is("no-asterisk", formContext == null ? void 0 : formContext.hideRequiredAsterisk),
          (formContext == null ? void 0 : formContext.requireAsteriskPosition) === "right" ? "asterisk-right" : "asterisk-left",
          { [ns.m("feedback")]: formContext == null ? void 0 : formContext.statusIcon }
        ]);
        const _inlineMessage = vue.computed(() => isBoolean(props.inlineMessage) ? props.inlineMessage : (formContext == null ? void 0 : formContext.inlineMessage) || false);
        const validateClasses = vue.computed(() => [
          ns.e("error"),
          { [ns.em("error", "inline")]: _inlineMessage.value }
        ]);
        const propString = vue.computed(() => {
          if (!props.prop)
            return "";
          return isString(props.prop) ? props.prop : props.prop.join(".");
        });
        const hasLabel = vue.computed(() => {
          return !!(props.label || slots.label);
        });
        const labelFor = vue.computed(() => {
          return props.for || inputIds.value.length === 1 ? inputIds.value[0] : void 0;
        });
        const isGroup = vue.computed(() => {
          return !labelFor.value && hasLabel.value;
        });
        const isNested = !!parentFormItemContext;
        const fieldValue = vue.computed(() => {
          const model = formContext == null ? void 0 : formContext.model;
          if (!model || !props.prop) {
            return;
          }
          return getProp(model, props.prop).value;
        });
        const normalizedRules = vue.computed(() => {
          const { required } = props;
          const rules = [];
          if (props.rules) {
            rules.push(...castArray$1(props.rules));
          }
          const formRules = formContext == null ? void 0 : formContext.rules;
          if (formRules && props.prop) {
            const _rules = getProp(formRules, props.prop).value;
            if (_rules) {
              rules.push(...castArray$1(_rules));
            }
          }
          if (required !== void 0) {
            const requiredRules = rules.map((rule, i) => [rule, i]).filter(([rule]) => Object.keys(rule).includes("required"));
            if (requiredRules.length > 0) {
              for (const [rule, i] of requiredRules) {
                if (rule.required === required)
                  continue;
                rules[i] = { ...rule, required };
              }
            } else {
              rules.push({ required });
            }
          }
          return rules;
        });
        const validateEnabled = vue.computed(() => normalizedRules.value.length > 0);
        const getFilteredRule = (trigger) => {
          const rules = normalizedRules.value;
          return rules.filter((rule) => {
            if (!rule.trigger || !trigger)
              return true;
            if (Array.isArray(rule.trigger)) {
              return rule.trigger.includes(trigger);
            } else {
              return rule.trigger === trigger;
            }
          }).map(({ trigger: trigger2, ...rule }) => rule);
        };
        const isRequired = vue.computed(() => normalizedRules.value.some((rule) => rule.required));
        const shouldShowError = vue.computed(() => {
          var _a;
          return validateStateDebounced.value === "error" && props.showMessage && ((_a = formContext == null ? void 0 : formContext.showMessage) != null ? _a : true);
        });
        const currentLabel = vue.computed(() => `${props.label || ""}${(formContext == null ? void 0 : formContext.labelSuffix) || ""}`);
        const setValidationState = (state) => {
          validateState.value = state;
        };
        const onValidationFailed = (error) => {
          var _a, _b;
          const { errors, fields } = error;
          if (!errors || !fields) {
            console.error(error);
          }
          setValidationState("error");
          validateMessage.value = errors ? (_b = (_a = errors == null ? void 0 : errors[0]) == null ? void 0 : _a.message) != null ? _b : `${props.prop} is required` : "";
          formContext == null ? void 0 : formContext.emit("validate", props.prop, false, validateMessage.value);
        };
        const onValidationSucceeded = () => {
          setValidationState("success");
          formContext == null ? void 0 : formContext.emit("validate", props.prop, true, "");
        };
        const doValidate = async (rules) => {
          const modelName = propString.value;
          const validator = new Schema({
            [modelName]: rules
          });
          return validator.validate({ [modelName]: fieldValue.value }, { firstFields: true }).then(() => {
            onValidationSucceeded();
            return true;
          }).catch((err) => {
            onValidationFailed(err);
            return Promise.reject(err);
          });
        };
        const validate = async (trigger, callback) => {
          if (isResettingField || !props.prop) {
            return false;
          }
          const hasCallback = isFunction(callback);
          if (!validateEnabled.value) {
            callback == null ? void 0 : callback(false);
            return false;
          }
          const rules = getFilteredRule(trigger);
          if (rules.length === 0) {
            callback == null ? void 0 : callback(true);
            return true;
          }
          setValidationState("validating");
          return doValidate(rules).then(() => {
            callback == null ? void 0 : callback(true);
            return true;
          }).catch((err) => {
            const { fields } = err;
            callback == null ? void 0 : callback(false, fields);
            return hasCallback ? false : Promise.reject(fields);
          });
        };
        const clearValidate = () => {
          setValidationState("");
          validateMessage.value = "";
          isResettingField = false;
        };
        const resetField = async () => {
          const model = formContext == null ? void 0 : formContext.model;
          if (!model || !props.prop)
            return;
          const computedValue = getProp(model, props.prop);
          isResettingField = true;
          computedValue.value = clone(initialValue);
          await vue.nextTick();
          clearValidate();
          isResettingField = false;
        };
        const addInputId = (id) => {
          if (!inputIds.value.includes(id)) {
            inputIds.value.push(id);
          }
        };
        const removeInputId = (id) => {
          inputIds.value = inputIds.value.filter((listId) => listId !== id);
        };
        vue.watch(() => props.error, (val) => {
          validateMessage.value = val || "";
          setValidationState(val ? "error" : "");
        }, { immediate: true });
        vue.watch(() => props.validateStatus, (val) => setValidationState(val || ""));
        const context = vue.reactive({
          ...vue.toRefs(props),
          $el: formItemRef,
          size: _size,
          validateState,
          labelId,
          inputIds,
          isGroup,
          hasLabel,
          addInputId,
          removeInputId,
          resetField,
          clearValidate,
          validate
        });
        vue.provide(formItemContextKey, context);
        vue.onMounted(() => {
          if (props.prop) {
            formContext == null ? void 0 : formContext.addField(context);
            initialValue = clone(fieldValue.value);
          }
        });
        vue.onBeforeUnmount(() => {
          formContext == null ? void 0 : formContext.removeField(context);
        });
        expose({
          size: _size,
          validateMessage,
          validateState,
          validate,
          clearValidate,
          resetField
        });
        return (_ctx, _cache) => {
          var _a;
          return vue.openBlock(), vue.createElementBlock("div", {
            ref_key: "formItemRef",
            ref: formItemRef,
            class: vue.normalizeClass(vue.unref(formItemClasses)),
            role: vue.unref(isGroup) ? "group" : void 0,
            "aria-labelledby": vue.unref(isGroup) ? vue.unref(labelId) : void 0
          }, [
            vue.createVNode(vue.unref(FormLabelWrap), {
              "is-auto-width": vue.unref(labelStyle).width === "auto",
              "update-all": ((_a = vue.unref(formContext)) == null ? void 0 : _a.labelWidth) === "auto"
            }, {
              default: vue.withCtx(() => [
                vue.unref(hasLabel) ? (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(vue.unref(labelFor) ? "label" : "div"), {
                  key: 0,
                  id: vue.unref(labelId),
                  for: vue.unref(labelFor),
                  class: vue.normalizeClass(vue.unref(ns).e("label")),
                  style: vue.normalizeStyle(vue.unref(labelStyle))
                }, {
                  default: vue.withCtx(() => [
                    vue.renderSlot(_ctx.$slots, "label", { label: vue.unref(currentLabel) }, () => [
                      vue.createTextVNode(vue.toDisplayString(vue.unref(currentLabel)), 1)
                    ])
                  ]),
                  _: 3
                }, 8, ["id", "for", "class", "style"])) : vue.createCommentVNode("v-if", true)
              ]),
              _: 3
            }, 8, ["is-auto-width", "update-all"]),
            vue.createElementVNode("div", {
              class: vue.normalizeClass(vue.unref(ns).e("content")),
              style: vue.normalizeStyle(vue.unref(contentStyle))
            }, [
              vue.renderSlot(_ctx.$slots, "default"),
              vue.createVNode(vue.Transition, {
                name: `${vue.unref(ns).namespace.value}-zoom-in-top`
              }, {
                default: vue.withCtx(() => [
                  vue.unref(shouldShowError) ? vue.renderSlot(_ctx.$slots, "error", {
                    key: 0,
                    error: validateMessage.value
                  }, () => [
                    vue.createElementVNode("div", {
                      class: vue.normalizeClass(vue.unref(validateClasses))
                    }, vue.toDisplayString(validateMessage.value), 3)
                  ]) : vue.createCommentVNode("v-if", true)
                ]),
                _: 3
              }, 8, ["name"])
            ], 6)
          ], 10, _hoisted_1$v);
        };
      }
    });
    var FormItem = /* @__PURE__ */ _export_sfc(_sfc_main$Z, [["__file", "form-item.vue"]]);
  
    const ElForm = withInstall(Form, {
      FormItem
    });
    const ElFormItem = withNoopInstall(FormItem);
  
    const imageViewerProps = buildProps({
      urlList: {
        type: definePropType(Array),
        default: () => mutable([])
      },
      zIndex: {
        type: Number
      },
      initialIndex: {
        type: Number,
        default: 0
      },
      infinite: {
        type: Boolean,
        default: true
      },
      hideOnClickModal: {
        type: Boolean,
        default: false
      },
      teleported: {
        type: Boolean,
        default: false
      },
      closeOnPressEscape: {
        type: Boolean,
        default: true
      }
    });
    const imageViewerEmits = {
      close: () => true,
      switch: (index) => isNumber(index)
    };
  
    const _hoisted_1$u = ["src"];
    const __default__$H = vue.defineComponent({
      name: "ElImageViewer"
    });
    const _sfc_main$Y = /* @__PURE__ */ vue.defineComponent({
      ...__default__$H,
      props: imageViewerProps,
      emits: imageViewerEmits,
      setup(__props, { expose, emit }) {
        const props = __props;
        const modes = {
          CONTAIN: {
            name: "contain",
            icon: vue.markRaw(full_screen_default)
          },
          ORIGINAL: {
            name: "original",
            icon: vue.markRaw(scale_to_original_default)
          }
        };
        const mousewheelEventName = isFirefox() ? "DOMMouseScroll" : "mousewheel";
        const { t } = useLocale();
        const ns = useNamespace("image-viewer");
        const { nextZIndex } = useZIndex();
        const wrapper = vue.ref();
        const imgRefs = vue.ref([]);
        const scopeEventListener = vue.effectScope();
        const loading = vue.ref(true);
        const activeIndex = vue.ref(props.initialIndex);
        const mode = vue.shallowRef(modes.CONTAIN);
        const transform = vue.ref({
          scale: 1,
          deg: 0,
          offsetX: 0,
          offsetY: 0,
          enableTransition: false
        });
        const isSingle = vue.computed(() => {
          const { urlList } = props;
          return urlList.length <= 1;
        });
        const isFirst = vue.computed(() => {
          return activeIndex.value === 0;
        });
        const isLast = vue.computed(() => {
          return activeIndex.value === props.urlList.length - 1;
        });
        const currentImg = vue.computed(() => {
          return props.urlList[activeIndex.value];
        });
        const imgStyle = vue.computed(() => {
          const { scale, deg, offsetX, offsetY, enableTransition } = transform.value;
          let translateX = offsetX / scale;
          let translateY = offsetY / scale;
          switch (deg % 360) {
            case 90:
            case -270:
              [translateX, translateY] = [translateY, -translateX];
              break;
            case 180:
            case -180:
              [translateX, translateY] = [-translateX, -translateY];
              break;
            case 270:
            case -90:
              [translateX, translateY] = [-translateY, translateX];
              break;
          }
          const style = {
            transform: `scale(${scale}) rotate(${deg}deg) translate(${translateX}px, ${translateY}px)`,
            transition: enableTransition ? "transform .3s" : ""
          };
          if (mode.value.name === modes.CONTAIN.name) {
            style.maxWidth = style.maxHeight = "100%";
          }
          return style;
        });
        const computedZIndex = vue.computed(() => {
          return isNumber(props.zIndex) ? props.zIndex : nextZIndex();
        });
        function hide() {
          unregisterEventListener();
          emit("close");
        }
        function registerEventListener() {
          const keydownHandler = throttle((e) => {
            switch (e.code) {
              case EVENT_CODE.esc:
                props.closeOnPressEscape && hide();
                break;
              case EVENT_CODE.space:
                toggleMode();
                break;
              case EVENT_CODE.left:
                prev();
                break;
              case EVENT_CODE.up:
                handleActions("zoomIn");
                break;
              case EVENT_CODE.right:
                next();
                break;
              case EVENT_CODE.down:
                handleActions("zoomOut");
                break;
            }
          });
          const mousewheelHandler = throttle((e) => {
            const delta = e.wheelDelta ? e.wheelDelta : -e.detail;
            if (delta > 0) {
              handleActions("zoomIn", {
                zoomRate: 1.2,
                enableTransition: false
              });
            } else {
              handleActions("zoomOut", {
                zoomRate: 1.2,
                enableTransition: false
              });
            }
          });
          scopeEventListener.run(() => {
            useEventListener(document, "keydown", keydownHandler);
            useEventListener(document, mousewheelEventName, mousewheelHandler);
          });
        }
        function unregisterEventListener() {
          scopeEventListener.stop();
        }
        function handleImgLoad() {
          loading.value = false;
        }
        function handleImgError(e) {
          loading.value = false;
          e.target.alt = t("el.image.error");
        }
        function handleMouseDown(e) {
          if (loading.value || e.button !== 0 || !wrapper.value)
            return;
          transform.value.enableTransition = false;
          const { offsetX, offsetY } = transform.value;
          const startX = e.pageX;
          const startY = e.pageY;
          const dragHandler = throttle((ev) => {
            transform.value = {
              ...transform.value,
              offsetX: offsetX + ev.pageX - startX,
              offsetY: offsetY + ev.pageY - startY
            };
          });
          const removeMousemove = useEventListener(document, "mousemove", dragHandler);
          useEventListener(document, "mouseup", () => {
            removeMousemove();
          });
          e.preventDefault();
        }
        function reset() {
          transform.value = {
            scale: 1,
            deg: 0,
            offsetX: 0,
            offsetY: 0,
            enableTransition: false
          };
        }
        function toggleMode() {
          if (loading.value)
            return;
          const modeNames = keysOf(modes);
          const modeValues = Object.values(modes);
          const currentMode = mode.value.name;
          const index = modeValues.findIndex((i) => i.name === currentMode);
          const nextIndex = (index + 1) % modeNames.length;
          mode.value = modes[modeNames[nextIndex]];
          reset();
        }
        function setActiveItem(index) {
          const len = props.urlList.length;
          activeIndex.value = (index + len) % len;
        }
        function prev() {
          if (isFirst.value && !props.infinite)
            return;
          setActiveItem(activeIndex.value - 1);
        }
        function next() {
          if (isLast.value && !props.infinite)
            return;
          setActiveItem(activeIndex.value + 1);
        }
        function handleActions(action, options = {}) {
          if (loading.value)
            return;
          const { zoomRate, rotateDeg, enableTransition } = {
            zoomRate: 1.4,
            rotateDeg: 90,
            enableTransition: true,
            ...options
          };
          switch (action) {
            case "zoomOut":
              if (transform.value.scale > 0.2) {
                transform.value.scale = Number.parseFloat((transform.value.scale / zoomRate).toFixed(3));
              }
              break;
            case "zoomIn":
              if (transform.value.scale < 7) {
                transform.value.scale = Number.parseFloat((transform.value.scale * zoomRate).toFixed(3));
              }
              break;
            case "clockwise":
              transform.value.deg += rotateDeg;
              break;
            case "anticlockwise":
              transform.value.deg -= rotateDeg;
              break;
          }
          transform.value.enableTransition = enableTransition;
        }
        vue.watch(currentImg, () => {
          vue.nextTick(() => {
            const $img = imgRefs.value[0];
            if (!($img == null ? void 0 : $img.complete)) {
              loading.value = true;
            }
          });
        });
        vue.watch(activeIndex, (val) => {
          reset();
          emit("switch", val);
        });
        vue.onMounted(() => {
          var _a, _b;
          registerEventListener();
          (_b = (_a = wrapper.value) == null ? void 0 : _a.focus) == null ? void 0 : _b.call(_a);
        });
        expose({
          setActiveItem
        });
        return (_ctx, _cache) => {
          return vue.openBlock(), vue.createBlock(vue.Teleport, {
            to: "body",
            disabled: !_ctx.teleported
          }, [
            vue.createVNode(vue.Transition, {
              name: "viewer-fade",
              appear: ""
            }, {
              default: vue.withCtx(() => [
                vue.createElementVNode("div", {
                  ref_key: "wrapper",
                  ref: wrapper,
                  tabindex: -1,
                  class: vue.normalizeClass(vue.unref(ns).e("wrapper")),
                  style: vue.normalizeStyle({ zIndex: vue.unref(computedZIndex) })
                }, [
                  vue.createElementVNode("div", {
                    class: vue.normalizeClass(vue.unref(ns).e("mask")),
                    onClick: _cache[0] || (_cache[0] = vue.withModifiers(($event) => _ctx.hideOnClickModal && hide(), ["self"]))
                  }, null, 2),
                  vue.createCommentVNode(" CLOSE "),
                  vue.createElementVNode("span", {
                    class: vue.normalizeClass([vue.unref(ns).e("btn"), vue.unref(ns).e("close")]),
                    onClick: hide
                  }, [
                    vue.createVNode(vue.unref(ElIcon), null, {
                      default: vue.withCtx(() => [
                        vue.createVNode(vue.unref(close_default))
                      ]),
                      _: 1
                    })
                  ], 2),
                  vue.createCommentVNode(" ARROW "),
                  !vue.unref(isSingle) ? (vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: 0 }, [
                    vue.createElementVNode("span", {
                      class: vue.normalizeClass([
                        vue.unref(ns).e("btn"),
                        vue.unref(ns).e("prev"),
                        vue.unref(ns).is("disabled", !_ctx.infinite && vue.unref(isFirst))
                      ]),
                      onClick: prev
                    }, [
                      vue.createVNode(vue.unref(ElIcon), null, {
                        default: vue.withCtx(() => [
                          vue.createVNode(vue.unref(arrow_left_default))
                        ]),
                        _: 1
                      })
                    ], 2),
                    vue.createElementVNode("span", {
                      class: vue.normalizeClass([
                        vue.unref(ns).e("btn"),
                        vue.unref(ns).e("next"),
                        vue.unref(ns).is("disabled", !_ctx.infinite && vue.unref(isLast))
                      ]),
                      onClick: next
                    }, [
                      vue.createVNode(vue.unref(ElIcon), null, {
                        default: vue.withCtx(() => [
                          vue.createVNode(vue.unref(arrow_right_default))
                        ]),
                        _: 1
                      })
                    ], 2)
                  ], 64)) : vue.createCommentVNode("v-if", true),
                  vue.createCommentVNode(" ACTIONS "),
                  vue.createElementVNode("div", {
                    class: vue.normalizeClass([vue.unref(ns).e("btn"), vue.unref(ns).e("actions")])
                  }, [
                    vue.createElementVNode("div", {
                      class: vue.normalizeClass(vue.unref(ns).e("actions__inner"))
                    }, [
                      vue.createVNode(vue.unref(ElIcon), {
                        onClick: _cache[1] || (_cache[1] = ($event) => handleActions("zoomOut"))
                      }, {
                        default: vue.withCtx(() => [
                          vue.createVNode(vue.unref(zoom_out_default))
                        ]),
                        _: 1
                      }),
                      vue.createVNode(vue.unref(ElIcon), {
                        onClick: _cache[2] || (_cache[2] = ($event) => handleActions("zoomIn"))
                      }, {
                        default: vue.withCtx(() => [
                          vue.createVNode(vue.unref(zoom_in_default))
                        ]),
                        _: 1
                      }),
                      vue.createElementVNode("i", {
                        class: vue.normalizeClass(vue.unref(ns).e("actions__divider"))
                      }, null, 2),
                      vue.createVNode(vue.unref(ElIcon), { onClick: toggleMode }, {
                        default: vue.withCtx(() => [
                          (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(vue.unref(mode).icon)))
                        ]),
                        _: 1
                      }),
                      vue.createElementVNode("i", {
                        class: vue.normalizeClass(vue.unref(ns).e("actions__divider"))
                      }, null, 2),
                      vue.createVNode(vue.unref(ElIcon), {
                        onClick: _cache[3] || (_cache[3] = ($event) => handleActions("anticlockwise"))
                      }, {
                        default: vue.withCtx(() => [
                          vue.createVNode(vue.unref(refresh_left_default))
                        ]),
                        _: 1
                      }),
                      vue.createVNode(vue.unref(ElIcon), {
                        onClick: _cache[4] || (_cache[4] = ($event) => handleActions("clockwise"))
                      }, {
                        default: vue.withCtx(() => [
                          vue.createVNode(vue.unref(refresh_right_default))
                        ]),
                        _: 1
                      })
                    ], 2)
                  ], 2),
                  vue.createCommentVNode(" CANVAS "),
                  vue.createElementVNode("div", {
                    class: vue.normalizeClass(vue.unref(ns).e("canvas"))
                  }, [
                    (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(_ctx.urlList, (url, i) => {
                      return vue.withDirectives((vue.openBlock(), vue.createElementBlock("img", {
                        ref_for: true,
                        ref: (el) => imgRefs.value[i] = el,
                        key: url,
                        src: url,
                        style: vue.normalizeStyle(vue.unref(imgStyle)),
                        class: vue.normalizeClass(vue.unref(ns).e("img")),
                        onLoad: handleImgLoad,
                        onError: handleImgError,
                        onMousedown: handleMouseDown
                      }, null, 46, _hoisted_1$u)), [
                        [vue.vShow, i === activeIndex.value]
                      ]);
                    }), 128))
                  ], 2),
                  vue.renderSlot(_ctx.$slots, "default")
                ], 6)
              ]),
              _: 3
            })
          ], 8, ["disabled"]);
        };
      }
    });
    var ImageViewer = /* @__PURE__ */ _export_sfc(_sfc_main$Y, [["__file", "image-viewer.vue"]]);
  
    const ElImageViewer = withInstall(ImageViewer);
  
    const imageProps = buildProps({
      hideOnClickModal: {
        type: Boolean,
        default: false
      },
      src: {
        type: String,
        default: ""
      },
      fit: {
        type: String,
        values: ["", "contain", "cover", "fill", "none", "scale-down"],
        default: ""
      },
      loading: {
        type: String,
        values: ["eager", "lazy"]
      },
      lazy: {
        type: Boolean,
        default: false
      },
      scrollContainer: {
        type: definePropType([String, Object])
      },
      previewSrcList: {
        type: definePropType(Array),
        default: () => mutable([])
      },
      previewTeleported: {
        type: Boolean,
        default: false
      },
      zIndex: {
        type: Number
      },
      initialIndex: {
        type: Number,
        default: 0
      },
      infinite: {
        type: Boolean,
        default: true
      },
      closeOnPressEscape: {
        type: Boolean,
        default: true
      }
    });
    const imageEmits = {
      load: (evt) => evt instanceof Event,
      error: (evt) => evt instanceof Event,
      switch: (val) => isNumber(val),
      close: () => true,
      show: () => true
    };
  
    const _hoisted_1$t = ["src", "loading"];
    const _hoisted_2$j = { key: 0 };
    const __default__$G = vue.defineComponent({
      name: "ElImage",
      inheritAttrs: false
    });
    const _sfc_main$X = /* @__PURE__ */ vue.defineComponent({
      ...__default__$G,
      props: imageProps,
      emits: imageEmits,
      setup(__props, { emit }) {
        const props = __props;
        let prevOverflow = "";
        const { t } = useLocale();
        const ns = useNamespace("image");
        const rawAttrs = vue.useAttrs();
        const attrs = useAttrs();
        const imageSrc = vue.ref();
        const hasLoadError = vue.ref(false);
        const isLoading = vue.ref(true);
        const showViewer = vue.ref(false);
        const container = vue.ref();
        const _scrollContainer = vue.ref();
        const supportLoading = isClient && "loading" in HTMLImageElement.prototype;
        let stopScrollListener;
        let stopWheelListener;
        const containerStyle = vue.computed(() => rawAttrs.style);
        const imageStyle = vue.computed(() => {
          const { fit } = props;
          if (isClient && fit) {
            return { objectFit: fit };
          }
          return {};
        });
        const preview = vue.computed(() => {
          const { previewSrcList } = props;
          return Array.isArray(previewSrcList) && previewSrcList.length > 0;
        });
        const imageIndex = vue.computed(() => {
          const { previewSrcList, initialIndex } = props;
          let previewIndex = initialIndex;
          if (initialIndex > previewSrcList.length - 1) {
            previewIndex = 0;
          }
          return previewIndex;
        });
        const isManual = vue.computed(() => {
          if (props.loading === "eager")
            return false;
          return !supportLoading && props.loading === "lazy" || props.lazy;
        });
        const loadImage = () => {
          if (!isClient)
            return;
          isLoading.value = true;
          hasLoadError.value = false;
          imageSrc.value = props.src;
        };
        function handleLoad(event) {
          isLoading.value = false;
          hasLoadError.value = false;
          emit("load", event);
        }
        function handleError(event) {
          isLoading.value = false;
          hasLoadError.value = true;
          emit("error", event);
        }
        function handleLazyLoad() {
          if (isInContainer(container.value, _scrollContainer.value)) {
            loadImage();
            removeLazyLoadListener();
          }
        }
        const lazyLoadHandler = useThrottleFn(handleLazyLoad, 200);
        async function addLazyLoadListener() {
          var _a;
          if (!isClient)
            return;
          await vue.nextTick();
          const { scrollContainer } = props;
          if (isElement$1(scrollContainer)) {
            _scrollContainer.value = scrollContainer;
          } else if (isString(scrollContainer) && scrollContainer !== "") {
            _scrollContainer.value = (_a = document.querySelector(scrollContainer)) != null ? _a : void 0;
          } else if (container.value) {
            _scrollContainer.value = getScrollContainer(container.value);
          }
          if (_scrollContainer.value) {
            stopScrollListener = useEventListener(_scrollContainer, "scroll", lazyLoadHandler);
            setTimeout(() => handleLazyLoad(), 100);
          }
        }
        function removeLazyLoadListener() {
          if (!isClient || !_scrollContainer.value || !lazyLoadHandler)
            return;
          stopScrollListener == null ? void 0 : stopScrollListener();
          _scrollContainer.value = void 0;
        }
        function wheelHandler(e) {
          if (!e.ctrlKey)
            return;
          if (e.deltaY < 0) {
            e.preventDefault();
            return false;
          } else if (e.deltaY > 0) {
            e.preventDefault();
            return false;
          }
        }
        function clickHandler() {
          if (!preview.value)
            return;
          stopWheelListener = useEventListener("wheel", wheelHandler, {
            passive: false
          });
          prevOverflow = document.body.style.overflow;
          document.body.style.overflow = "hidden";
          showViewer.value = true;
          emit("show");
        }
        function closeViewer() {
          stopWheelListener == null ? void 0 : stopWheelListener();
          document.body.style.overflow = prevOverflow;
          showViewer.value = false;
          emit("close");
        }
        function switchViewer(val) {
          emit("switch", val);
        }
        vue.watch(() => props.src, () => {
          if (isManual.value) {
            isLoading.value = true;
            hasLoadError.value = false;
            removeLazyLoadListener();
            addLazyLoadListener();
          } else {
            loadImage();
          }
        });
        vue.onMounted(() => {
          if (isManual.value) {
            addLazyLoadListener();
          } else {
            loadImage();
          }
        });
        return (_ctx, _cache) => {
          return vue.openBlock(), vue.createElementBlock("div", {
            ref_key: "container",
            ref: container,
            class: vue.normalizeClass([vue.unref(ns).b(), _ctx.$attrs.class]),
            style: vue.normalizeStyle(vue.unref(containerStyle))
          }, [
            imageSrc.value !== void 0 && !hasLoadError.value ? (vue.openBlock(), vue.createElementBlock("img", vue.mergeProps({ key: 0 }, vue.unref(attrs), {
              src: imageSrc.value,
              loading: _ctx.loading,
              style: vue.unref(imageStyle),
              class: [
                vue.unref(ns).e("inner"),
                vue.unref(preview) && vue.unref(ns).e("preview"),
                isLoading.value && vue.unref(ns).is("loading")
              ],
              onClick: clickHandler,
              onLoad: handleLoad,
              onError: handleError
            }), null, 16, _hoisted_1$t)) : vue.createCommentVNode("v-if", true),
            isLoading.value || hasLoadError.value ? (vue.openBlock(), vue.createElementBlock("div", {
              key: 1,
              class: vue.normalizeClass(vue.unref(ns).e("wrapper"))
            }, [
              isLoading.value ? vue.renderSlot(_ctx.$slots, "placeholder", { key: 0 }, () => [
                vue.createElementVNode("div", {
                  class: vue.normalizeClass(vue.unref(ns).e("placeholder"))
                }, null, 2)
              ]) : hasLoadError.value ? vue.renderSlot(_ctx.$slots, "error", { key: 1 }, () => [
                vue.createElementVNode("div", {
                  class: vue.normalizeClass(vue.unref(ns).e("error"))
                }, vue.toDisplayString(vue.unref(t)("el.image.error")), 3)
              ]) : vue.createCommentVNode("v-if", true)
            ], 2)) : vue.createCommentVNode("v-if", true),
            vue.unref(preview) ? (vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: 2 }, [
              showViewer.value ? (vue.openBlock(), vue.createBlock(vue.unref(ElImageViewer), {
                key: 0,
                "z-index": _ctx.zIndex,
                "initial-index": vue.unref(imageIndex),
                infinite: _ctx.infinite,
                "url-list": _ctx.previewSrcList,
                "hide-on-click-modal": _ctx.hideOnClickModal,
                teleported: _ctx.previewTeleported,
                "close-on-press-escape": _ctx.closeOnPressEscape,
                onClose: closeViewer,
                onSwitch: switchViewer
              }, {
                default: vue.withCtx(() => [
                  _ctx.$slots.viewer ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_2$j, [
                    vue.renderSlot(_ctx.$slots, "viewer")
                  ])) : vue.createCommentVNode("v-if", true)
                ]),
                _: 3
              }, 8, ["z-index", "initial-index", "infinite", "url-list", "hide-on-click-modal", "teleported", "close-on-press-escape"])) : vue.createCommentVNode("v-if", true)
            ], 64)) : vue.createCommentVNode("v-if", true)
          ], 6);
        };
      }
    });
    var Image = /* @__PURE__ */ _export_sfc(_sfc_main$X, [["__file", "image.vue"]]);
  
    const ElImage = withInstall(Image);
  
    const inputNumberProps = buildProps({
      id: {
        type: String,
        default: void 0
      },
      step: {
        type: Number,
        default: 1
      },
      stepStrictly: Boolean,
      max: {
        type: Number,
        default: Number.POSITIVE_INFINITY
      },
      min: {
        type: Number,
        default: Number.NEGATIVE_INFINITY
      },
      modelValue: Number,
      readonly: Boolean,
      disabled: Boolean,
      size: useSizeProp,
      controls: {
        type: Boolean,
        default: true
      },
      controlsPosition: {
        type: String,
        default: "",
        values: ["", "right"]
      },
      valueOnClear: {
        type: [String, Number, null],
        validator: (val) => val === null || isNumber(val) || ["min", "max"].includes(val),
        default: null
      },
      name: String,
      label: String,
      placeholder: String,
      precision: {
        type: Number,
        validator: (val) => val >= 0 && val === Number.parseInt(`${val}`, 10)
      },
      validateEvent: {
        type: Boolean,
        default: true
      }
    });
    const inputNumberEmits = {
      [CHANGE_EVENT]: (prev, cur) => prev !== cur,
      blur: (e) => e instanceof FocusEvent,
      focus: (e) => e instanceof FocusEvent,
      [INPUT_EVENT]: (val) => isNumber(val) || isNil(val),
      [UPDATE_MODEL_EVENT]: (val) => isNumber(val) || isNil(val)
    };
  
    const _hoisted_1$s = ["aria-label", "onKeydown"];
    const _hoisted_2$i = ["aria-label", "onKeydown"];
    const __default__$F = vue.defineComponent({
      name: "ElInputNumber"
    });
    const _sfc_main$W = /* @__PURE__ */ vue.defineComponent({
      ...__default__$F,
      props: inputNumberProps,
      emits: inputNumberEmits,
      setup(__props, { expose, emit }) {
        const props = __props;
        const { t } = useLocale();
        const ns = useNamespace("input-number");
        const input = vue.ref();
        const data = vue.reactive({
          currentValue: props.modelValue,
          userInput: null
        });
        const { formItem } = useFormItem();
        const minDisabled = vue.computed(() => isNumber(props.modelValue) && ensurePrecision(props.modelValue, -1) < props.min);
        const maxDisabled = vue.computed(() => isNumber(props.modelValue) && ensurePrecision(props.modelValue) > props.max);
        const numPrecision = vue.computed(() => {
          const stepPrecision = getPrecision(props.step);
          if (!isUndefined(props.precision)) {
            if (stepPrecision > props.precision) ;
            return props.precision;
          } else {
            return Math.max(getPrecision(props.modelValue), stepPrecision);
          }
        });
        const controlsAtRight = vue.computed(() => {
          return props.controls && props.controlsPosition === "right";
        });
        const inputNumberSize = useSize();
        const inputNumberDisabled = useDisabled();
        const displayValue = vue.computed(() => {
          if (data.userInput !== null) {
            return data.userInput;
          }
          let currentValue = data.currentValue;
          if (isNil(currentValue))
            return "";
          if (isNumber(currentValue)) {
            if (Number.isNaN(currentValue))
              return "";
            if (!isUndefined(props.precision)) {
              currentValue = currentValue.toFixed(props.precision);
            }
          }
          return currentValue;
        });
        const toPrecision = (num, pre) => {
          if (isUndefined(pre))
            pre = numPrecision.value;
          if (pre === 0)
            return Math.round(num);
          let snum = String(num);
          const pointPos = snum.indexOf(".");
          if (pointPos === -1)
            return num;
          const nums = snum.replace(".", "").split("");
          const datum = nums[pointPos + pre];
          if (!datum)
            return num;
          const length = snum.length;
          if (snum.charAt(length - 1) === "5") {
            snum = `${snum.slice(0, Math.max(0, length - 1))}6`;
          }
          return Number.parseFloat(Number(snum).toFixed(pre));
        };
        const getPrecision = (value) => {
          if (isNil(value))
            return 0;
          const valueString = value.toString();
          const dotPosition = valueString.indexOf(".");
          let precision = 0;
          if (dotPosition !== -1) {
            precision = valueString.length - dotPosition - 1;
          }
          return precision;
        };
        const ensurePrecision = (val, coefficient = 1) => {
          if (!isNumber(val))
            return data.currentValue;
          return toPrecision(val + props.step * coefficient);
        };
        const increase = () => {
          if (props.readonly || inputNumberDisabled.value || maxDisabled.value)
            return;
          const value = Number(displayValue.value) || 0;
          const newVal = ensurePrecision(value);
          setCurrentValue(newVal);
          emit(INPUT_EVENT, data.currentValue);
        };
        const decrease = () => {
          if (props.readonly || inputNumberDisabled.value || minDisabled.value)
            return;
          const value = Number(displayValue.value) || 0;
          const newVal = ensurePrecision(value, -1);
          setCurrentValue(newVal);
          emit(INPUT_EVENT, data.currentValue);
        };
        const verifyValue = (value, update) => {
          const { max, min, step, precision, stepStrictly, valueOnClear } = props;
          let newVal = Number(value);
          if (isNil(value) || Number.isNaN(newVal)) {
            return null;
          }
          if (value === "") {
            if (valueOnClear === null) {
              return null;
            }
            newVal = isString(valueOnClear) ? { min, max }[valueOnClear] : valueOnClear;
          }
          if (stepStrictly) {
            newVal = toPrecision(Math.round(newVal / step) * step, precision);
          }
          if (!isUndefined(precision)) {
            newVal = toPrecision(newVal, precision);
          }
          if (newVal > max || newVal < min) {
            newVal = newVal > max ? max : min;
            update && emit(UPDATE_MODEL_EVENT, newVal);
          }
          return newVal;
        };
        const setCurrentValue = (value) => {
          var _a;
          const oldVal = data.currentValue;
          const newVal = verifyValue(value);
          if (oldVal === newVal)
            return;
          data.userInput = null;
          emit(UPDATE_MODEL_EVENT, newVal);
          emit(CHANGE_EVENT, newVal, oldVal);
          if (props.validateEvent) {
            (_a = formItem == null ? void 0 : formItem.validate) == null ? void 0 : _a.call(formItem, "change").catch((err) => debugWarn());
          }
          data.currentValue = newVal;
        };
        const handleInput = (value) => {
          data.userInput = value;
          emit(INPUT_EVENT, value === "" ? null : Number(value));
        };
        const handleInputChange = (value) => {
          const newVal = value !== "" ? Number(value) : "";
          if (isNumber(newVal) && !Number.isNaN(newVal) || value === "") {
            setCurrentValue(newVal);
          }
          data.userInput = null;
        };
        const focus = () => {
          var _a, _b;
          (_b = (_a = input.value) == null ? void 0 : _a.focus) == null ? void 0 : _b.call(_a);
        };
        const blur = () => {
          var _a, _b;
          (_b = (_a = input.value) == null ? void 0 : _a.blur) == null ? void 0 : _b.call(_a);
        };
        const handleFocus = (event) => {
          emit("focus", event);
        };
        const handleBlur = (event) => {
          var _a;
          emit("blur", event);
          if (props.validateEvent) {
            (_a = formItem == null ? void 0 : formItem.validate) == null ? void 0 : _a.call(formItem, "blur").catch((err) => debugWarn());
          }
        };
        vue.watch(() => props.modelValue, (value) => {
          data.currentValue = verifyValue(value, true);
          data.userInput = null;
        }, { immediate: true });
        vue.onMounted(() => {
          var _a;
          const { min, max, modelValue } = props;
          const innerInput = (_a = input.value) == null ? void 0 : _a.input;
          innerInput.setAttribute("role", "spinbutton");
          if (Number.isFinite(max)) {
            innerInput.setAttribute("aria-valuemax", String(max));
          } else {
            innerInput.removeAttribute("aria-valuemax");
          }
          if (Number.isFinite(min)) {
            innerInput.setAttribute("aria-valuemin", String(min));
          } else {
            innerInput.removeAttribute("aria-valuemin");
          }
          innerInput.setAttribute("aria-valuenow", String(data.currentValue));
          innerInput.setAttribute("aria-disabled", String(inputNumberDisabled.value));
          if (!isNumber(modelValue) && modelValue != null) {
            let val = Number(modelValue);
            if (Number.isNaN(val)) {
              val = null;
            }
            emit(UPDATE_MODEL_EVENT, val);
          }
        });
        vue.onUpdated(() => {
          var _a;
          const innerInput = (_a = input.value) == null ? void 0 : _a.input;
          innerInput == null ? void 0 : innerInput.setAttribute("aria-valuenow", `${data.currentValue}`);
        });
        expose({
          focus,
          blur
        });
        return (_ctx, _cache) => {
          return vue.openBlock(), vue.createElementBlock("div", {
            class: vue.normalizeClass([
              vue.unref(ns).b(),
              vue.unref(ns).m(vue.unref(inputNumberSize)),
              vue.unref(ns).is("disabled", vue.unref(inputNumberDisabled)),
              vue.unref(ns).is("without-controls", !_ctx.controls),
              vue.unref(ns).is("controls-right", vue.unref(controlsAtRight))
            ]),
            onDragstart: _cache[0] || (_cache[0] = vue.withModifiers(() => {
            }, ["prevent"]))
          }, [
            _ctx.controls ? vue.withDirectives((vue.openBlock(), vue.createElementBlock("span", {
              key: 0,
              role: "button",
              "aria-label": vue.unref(t)("el.inputNumber.decrease"),
              class: vue.normalizeClass([vue.unref(ns).e("decrease"), vue.unref(ns).is("disabled", vue.unref(minDisabled))]),
              onKeydown: vue.withKeys(decrease, ["enter"])
            }, [
              vue.createVNode(vue.unref(ElIcon), null, {
                default: vue.withCtx(() => [
                  vue.unref(controlsAtRight) ? (vue.openBlock(), vue.createBlock(vue.unref(arrow_down_default), { key: 0 })) : (vue.openBlock(), vue.createBlock(vue.unref(minus_default), { key: 1 }))
                ]),
                _: 1
              })
            ], 42, _hoisted_1$s)), [
              [vue.unref(vRepeatClick), decrease]
            ]) : vue.createCommentVNode("v-if", true),
            _ctx.controls ? vue.withDirectives((vue.openBlock(), vue.createElementBlock("span", {
              key: 1,
              role: "button",
              "aria-label": vue.unref(t)("el.inputNumber.increase"),
              class: vue.normalizeClass([vue.unref(ns).e("increase"), vue.unref(ns).is("disabled", vue.unref(maxDisabled))]),
              onKeydown: vue.withKeys(increase, ["enter"])
            }, [
              vue.createVNode(vue.unref(ElIcon), null, {
                default: vue.withCtx(() => [
                  vue.unref(controlsAtRight) ? (vue.openBlock(), vue.createBlock(vue.unref(arrow_up_default), { key: 0 })) : (vue.openBlock(), vue.createBlock(vue.unref(plus_default), { key: 1 }))
                ]),
                _: 1
              })
            ], 42, _hoisted_2$i)), [
              [vue.unref(vRepeatClick), increase]
            ]) : vue.createCommentVNode("v-if", true),
            vue.createVNode(vue.unref(ElInput), {
              id: _ctx.id,
              ref_key: "input",
              ref: input,
              type: "number",
              step: _ctx.step,
              "model-value": vue.unref(displayValue),
              placeholder: _ctx.placeholder,
              readonly: _ctx.readonly,
              disabled: vue.unref(inputNumberDisabled),
              size: vue.unref(inputNumberSize),
              max: _ctx.max,
              min: _ctx.min,
              name: _ctx.name,
              label: _ctx.label,
              "validate-event": false,
              onKeydown: [
                vue.withKeys(vue.withModifiers(increase, ["prevent"]), ["up"]),
                vue.withKeys(vue.withModifiers(decrease, ["prevent"]), ["down"])
              ],
              onBlur: handleBlur,
              onFocus: handleFocus,
              onInput: handleInput,
              onChange: handleInputChange
            }, null, 8, ["id", "step", "model-value", "placeholder", "readonly", "disabled", "size", "max", "min", "name", "label", "onKeydown"])
          ], 34);
        };
      }
    });
    var InputNumber = /* @__PURE__ */ _export_sfc(_sfc_main$W, [["__file", "input-number.vue"]]);
  
    const ElInputNumber = withInstall(InputNumber);
  
    const linkProps = buildProps({
      type: {
        type: String,
        values: ["primary", "success", "warning", "info", "danger", "default"],
        default: "default"
      },
      underline: {
        type: Boolean,
        default: true
      },
      disabled: { type: Boolean, default: false },
      href: { type: String, default: "" },
      icon: {
        type: iconPropType
      }
    });
    const linkEmits = {
      click: (evt) => evt instanceof MouseEvent
    };
  
    const _hoisted_1$r = ["href"];
    const __default__$E = vue.defineComponent({
      name: "ElLink"
    });
    const _sfc_main$V = /* @__PURE__ */ vue.defineComponent({
      ...__default__$E,
      props: linkProps,
      emits: linkEmits,
      setup(__props, { emit }) {
        const props = __props;
        const ns = useNamespace("link");
        function handleClick(event) {
          if (!props.disabled)
            emit("click", event);
        }
        return (_ctx, _cache) => {
          return vue.openBlock(), vue.createElementBlock("a", {
            class: vue.normalizeClass([
              vue.unref(ns).b(),
              vue.unref(ns).m(_ctx.type),
              vue.unref(ns).is("disabled", _ctx.disabled),
              vue.unref(ns).is("underline", _ctx.underline && !_ctx.disabled)
            ]),
            href: _ctx.disabled || !_ctx.href ? void 0 : _ctx.href,
            onClick: handleClick
          }, [
            _ctx.icon ? (vue.openBlock(), vue.createBlock(vue.unref(ElIcon), { key: 0 }, {
              default: vue.withCtx(() => [
                (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(_ctx.icon)))
              ]),
              _: 1
            })) : vue.createCommentVNode("v-if", true),
            _ctx.$slots.default ? (vue.openBlock(), vue.createElementBlock("span", {
              key: 1,
              class: vue.normalizeClass(vue.unref(ns).e("inner"))
            }, [
              vue.renderSlot(_ctx.$slots, "default")
            ], 2)) : vue.createCommentVNode("v-if", true),
            _ctx.$slots.icon ? vue.renderSlot(_ctx.$slots, "icon", { key: 2 }) : vue.createCommentVNode("v-if", true)
          ], 10, _hoisted_1$r);
        };
      }
    });
    var Link = /* @__PURE__ */ _export_sfc(_sfc_main$V, [["__file", "link.vue"]]);
  
    const ElLink = withInstall(Link);
  
    class SubMenu$1 {
      constructor(parent, domNode) {
        this.parent = parent;
        this.domNode = domNode;
        this.subIndex = 0;
        this.subIndex = 0;
        this.init();
      }
      init() {
        this.subMenuItems = this.domNode.querySelectorAll("li");
        this.addListeners();
      }
      gotoSubIndex(idx) {
        if (idx === this.subMenuItems.length) {
          idx = 0;
        } else if (idx < 0) {
          idx = this.subMenuItems.length - 1;
        }
        this.subMenuItems[idx].focus();
        this.subIndex = idx;
      }
      addListeners() {
        const parentNode = this.parent.domNode;
        Array.prototype.forEach.call(this.subMenuItems, (el) => {
          el.addEventListener("keydown", (event) => {
            let prevDef = false;
            switch (event.code) {
              case EVENT_CODE.down: {
                this.gotoSubIndex(this.subIndex + 1);
                prevDef = true;
                break;
              }
              case EVENT_CODE.up: {
                this.gotoSubIndex(this.subIndex - 1);
                prevDef = true;
                break;
              }
              case EVENT_CODE.tab: {
                triggerEvent(parentNode, "mouseleave");
                break;
              }
              case EVENT_CODE.enter:
              case EVENT_CODE.space: {
                prevDef = true;
                event.currentTarget.click();
                break;
              }
            }
            if (prevDef) {
              event.preventDefault();
              event.stopPropagation();
            }
            return false;
          });
        });
      }
    }
    var SubMenu$2 = SubMenu$1;
  
    class MenuItem$1 {
      constructor(domNode, namespace) {
        this.domNode = domNode;
        this.submenu = null;
        this.submenu = null;
        this.init(namespace);
      }
      init(namespace) {
        this.domNode.setAttribute("tabindex", "0");
        const menuChild = this.domNode.querySelector(`.${namespace}-menu`);
        if (menuChild) {
          this.submenu = new SubMenu$2(this, menuChild);
        }
        this.addListeners();
      }
      addListeners() {
        this.domNode.addEventListener("keydown", (event) => {
          let prevDef = false;
          switch (event.code) {
            case EVENT_CODE.down: {
              triggerEvent(event.currentTarget, "mouseenter");
              this.submenu && this.submenu.gotoSubIndex(0);
              prevDef = true;
              break;
            }
            case EVENT_CODE.up: {
              triggerEvent(event.currentTarget, "mouseenter");
              this.submenu && this.submenu.gotoSubIndex(this.submenu.subMenuItems.length - 1);
              prevDef = true;
              break;
            }
            case EVENT_CODE.tab: {
              triggerEvent(event.currentTarget, "mouseleave");
              break;
            }
            case EVENT_CODE.enter:
            case EVENT_CODE.space: {
              prevDef = true;
              event.currentTarget.click();
              break;
            }
          }
          if (prevDef) {
            event.preventDefault();
          }
        });
      }
    }
    var MenuItem$2 = MenuItem$1;
  
    class Menu$1 {
      constructor(domNode, namespace) {
        this.domNode = domNode;
        this.init(namespace);
      }
      init(namespace) {
        const menuChildren = this.domNode.childNodes;
        Array.from(menuChildren).forEach((child) => {
          if (child.nodeType === 1) {
            new MenuItem$2(child, namespace);
          }
        });
      }
    }
    var Menubar = Menu$1;
  
    const _sfc_main$U = vue.defineComponent({
      name: "ElMenuCollapseTransition",
      setup() {
        const ns = useNamespace("menu");
        const listeners = {
          onBeforeEnter: (el) => el.style.opacity = "0.2",
          onEnter(el, done) {
            addClass(el, `${ns.namespace.value}-opacity-transition`);
            el.style.opacity = "1";
            done();
          },
          onAfterEnter(el) {
            removeClass(el, `${ns.namespace.value}-opacity-transition`);
            el.style.opacity = "";
          },
          onBeforeLeave(el) {
            if (!el.dataset) {
              el.dataset = {};
            }
            if (hasClass(el, ns.m("collapse"))) {
              removeClass(el, ns.m("collapse"));
              el.dataset.oldOverflow = el.style.overflow;
              el.dataset.scrollWidth = el.clientWidth.toString();
              addClass(el, ns.m("collapse"));
            } else {
              addClass(el, ns.m("collapse"));
              el.dataset.oldOverflow = el.style.overflow;
              el.dataset.scrollWidth = el.clientWidth.toString();
              removeClass(el, ns.m("collapse"));
            }
            el.style.width = `${el.scrollWidth}px`;
            el.style.overflow = "hidden";
          },
          onLeave(el) {
            addClass(el, "horizontal-collapse-transition");
            el.style.width = `${el.dataset.scrollWidth}px`;
          }
        };
        return {
          listeners
        };
      }
    });
    function _sfc_render$e(_ctx, _cache, $props, $setup, $data, $options) {
      return vue.openBlock(), vue.createBlock(vue.Transition, vue.mergeProps({ mode: "out-in" }, _ctx.listeners), {
        default: vue.withCtx(() => [
          vue.renderSlot(_ctx.$slots, "default")
        ]),
        _: 3
      }, 16);
    }
    var ElMenuCollapseTransition = /* @__PURE__ */ _export_sfc(_sfc_main$U, [["render", _sfc_render$e], ["__file", "menu-collapse-transition.vue"]]);
  
    function useMenu(instance, currentIndex) {
      const indexPath = vue.computed(() => {
        let parent = instance.parent;
        const path = [currentIndex.value];
        while (parent.type.name !== "ElMenu") {
          if (parent.props.index) {
            path.unshift(parent.props.index);
          }
          parent = parent.parent;
        }
        return path;
      });
      const parentMenu = vue.computed(() => {
        let parent = instance.parent;
        while (parent && !["ElMenu", "ElSubMenu"].includes(parent.type.name)) {
          parent = parent.parent;
        }
        return parent;
      });
      return {
        parentMenu,
        indexPath
      };
    }
  
    function useMenuColor(props) {
      const menuBarColor = vue.computed(() => {
        const color = props.backgroundColor;
        if (!color) {
          return "";
        } else {
          return new TinyColor(color).shade(20).toString();
        }
      });
      return menuBarColor;
    }
  
    const useMenuCssVar = (props, level) => {
      const ns = useNamespace("menu");
      return vue.computed(() => {
        return ns.cssVarBlock({
          "text-color": props.textColor || "",
          "hover-text-color": props.textColor || "",
          "bg-color": props.backgroundColor || "",
          "hover-bg-color": useMenuColor(props).value || "",
          "active-color": props.activeTextColor || "",
          level: `${level}`
        });
      });
    };
  
    const subMenuProps = buildProps({
      index: {
        type: String,
        required: true
      },
      showTimeout: {
        type: Number,
        default: 300
      },
      hideTimeout: {
        type: Number,
        default: 300
      },
      popperClass: String,
      disabled: Boolean,
      popperAppendToBody: {
        type: Boolean,
        default: void 0
      },
      popperOffset: {
        type: Number,
        default: 6
      },
      expandCloseIcon: {
        type: iconPropType
      },
      expandOpenIcon: {
        type: iconPropType
      },
      collapseCloseIcon: {
        type: iconPropType
      },
      collapseOpenIcon: {
        type: iconPropType
      }
    });
    const COMPONENT_NAME$c = "ElSubMenu";
    var SubMenu = vue.defineComponent({
      name: COMPONENT_NAME$c,
      props: subMenuProps,
      setup(props, { slots, expose }) {
        const instance = vue.getCurrentInstance();
        const { indexPath, parentMenu } = useMenu(instance, vue.computed(() => props.index));
        const nsMenu = useNamespace("menu");
        const nsSubMenu = useNamespace("sub-menu");
        const rootMenu = vue.inject("rootMenu");
        if (!rootMenu)
          throwError(COMPONENT_NAME$c, "can not inject root menu");
        const subMenu = vue.inject(`subMenu:${parentMenu.value.uid}`);
        if (!subMenu)
          throwError(COMPONENT_NAME$c, "can not inject sub menu");
        const items = vue.ref({});
        const subMenus = vue.ref({});
        let timeout;
        const mouseInChild = vue.ref(false);
        const verticalTitleRef = vue.ref();
        const vPopper = vue.ref(null);
        const currentPlacement = vue.computed(() => mode.value === "horizontal" && isFirstLevel.value ? "bottom-start" : "right-start");
        const subMenuTitleIcon = vue.computed(() => {
          return mode.value === "horizontal" && isFirstLevel.value || mode.value === "vertical" && !rootMenu.props.collapse ? props.expandCloseIcon && props.expandOpenIcon ? opened.value ? props.expandOpenIcon : props.expandCloseIcon : arrow_down_default : props.collapseCloseIcon && props.collapseOpenIcon ? opened.value ? props.collapseOpenIcon : props.collapseCloseIcon : arrow_right_default;
        });
        const isFirstLevel = vue.computed(() => {
          return subMenu.level === 0;
        });
        const appendToBody = vue.computed(() => {
          return props.popperAppendToBody === void 0 ? isFirstLevel.value : Boolean(props.popperAppendToBody);
        });
        const menuTransitionName = vue.computed(() => rootMenu.props.collapse ? `${nsMenu.namespace.value}-zoom-in-left` : `${nsMenu.namespace.value}-zoom-in-top`);
        const fallbackPlacements = vue.computed(() => mode.value === "horizontal" && isFirstLevel.value ? [
          "bottom-start",
          "bottom-end",
          "top-start",
          "top-end",
          "right-start",
          "left-start"
        ] : [
          "right-start",
          "left-start",
          "bottom-start",
          "bottom-end",
          "top-start",
          "top-end"
        ]);
        const opened = vue.computed(() => rootMenu.openedMenus.includes(props.index));
        const active = vue.computed(() => {
          let isActive = false;
          Object.values(items.value).forEach((item2) => {
            if (item2.active) {
              isActive = true;
            }
          });
          Object.values(subMenus.value).forEach((subItem) => {
            if (subItem.active) {
              isActive = true;
            }
          });
          return isActive;
        });
        const backgroundColor = vue.computed(() => rootMenu.props.backgroundColor || "");
        const activeTextColor = vue.computed(() => rootMenu.props.activeTextColor || "");
        const textColor = vue.computed(() => rootMenu.props.textColor || "");
        const mode = vue.computed(() => rootMenu.props.mode);
        const item = vue.reactive({
          index: props.index,
          indexPath,
          active
        });
        const titleStyle = vue.computed(() => {
          if (mode.value !== "horizontal") {
            return {
              color: textColor.value
            };
          }
          return {
            borderBottomColor: active.value ? rootMenu.props.activeTextColor ? activeTextColor.value : "" : "transparent",
            color: active.value ? activeTextColor.value : textColor.value
          };
        });
        const doDestroy = () => {
          var _a, _b, _c;
          return (_c = (_b = (_a = vPopper.value) == null ? void 0 : _a.popperRef) == null ? void 0 : _b.popperInstanceRef) == null ? void 0 : _c.destroy();
        };
        const handleCollapseToggle = (value) => {
          if (!value) {
            doDestroy();
          }
        };
        const handleClick = () => {
          if (rootMenu.props.menuTrigger === "hover" && rootMenu.props.mode === "horizontal" || rootMenu.props.collapse && rootMenu.props.mode === "vertical" || props.disabled)
            return;
          rootMenu.handleSubMenuClick({
            index: props.index,
            indexPath: indexPath.value,
            active: active.value
          });
        };
        const handleMouseenter = (event, showTimeout = props.showTimeout) => {
          var _a;
          if (event.type === "focus") {
            return;
          }
          if (rootMenu.props.menuTrigger === "click" && rootMenu.props.mode === "horizontal" || !rootMenu.props.collapse && rootMenu.props.mode === "vertical" || props.disabled) {
            return;
          }
          subMenu.mouseInChild.value = true;
          timeout == null ? void 0 : timeout();
          ({ stop: timeout } = useTimeoutFn(() => {
            rootMenu.openMenu(props.index, indexPath.value);
          }, showTimeout));
          if (appendToBody.value) {
            (_a = parentMenu.value.vnode.el) == null ? void 0 : _a.dispatchEvent(new MouseEvent("mouseenter"));
          }
        };
        const handleMouseleave = (deepDispatch = false) => {
          var _a, _b;
          if (rootMenu.props.menuTrigger === "click" && rootMenu.props.mode === "horizontal" || !rootMenu.props.collapse && rootMenu.props.mode === "vertical") {
            return;
          }
          timeout == null ? void 0 : timeout();
          subMenu.mouseInChild.value = false;
          ({ stop: timeout } = useTimeoutFn(() => !mouseInChild.value && rootMenu.closeMenu(props.index, indexPath.value), props.hideTimeout));
          if (appendToBody.value && deepDispatch) {
            if (((_a = instance.parent) == null ? void 0 : _a.type.name) === "ElSubMenu") {
              (_b = subMenu.handleMouseleave) == null ? void 0 : _b.call(subMenu, true);
            }
          }
        };
        vue.watch(() => rootMenu.props.collapse, (value) => handleCollapseToggle(Boolean(value)));
        {
          const addSubMenu = (item2) => {
            subMenus.value[item2.index] = item2;
          };
          const removeSubMenu = (item2) => {
            delete subMenus.value[item2.index];
          };
          vue.provide(`subMenu:${instance.uid}`, {
            addSubMenu,
            removeSubMenu,
            handleMouseleave,
            mouseInChild,
            level: subMenu.level + 1
          });
        }
        expose({
          opened
        });
        vue.onMounted(() => {
          rootMenu.addSubMenu(item);
          subMenu.addSubMenu(item);
        });
        vue.onBeforeUnmount(() => {
          subMenu.removeSubMenu(item);
          rootMenu.removeSubMenu(item);
        });
        return () => {
          var _a;
          const titleTag = [
            (_a = slots.title) == null ? void 0 : _a.call(slots),
            vue.h(ElIcon, {
              class: nsSubMenu.e("icon-arrow"),
              style: {
                transform: opened.value ? props.expandCloseIcon && props.expandOpenIcon || props.collapseCloseIcon && props.collapseOpenIcon && rootMenu.props.collapse ? "none" : "rotateZ(180deg)" : "none"
              }
            }, {
              default: () => isString(subMenuTitleIcon.value) ? vue.h(instance.appContext.components[subMenuTitleIcon.value]) : vue.h(subMenuTitleIcon.value)
            })
          ];
          const ulStyle = useMenuCssVar(rootMenu.props, subMenu.level + 1);
          const child = rootMenu.isMenuPopup ? vue.h(ElTooltip, {
            ref: vPopper,
            visible: opened.value,
            effect: "light",
            pure: true,
            offset: props.popperOffset,
            showArrow: false,
            persistent: true,
            popperClass: props.popperClass,
            placement: currentPlacement.value,
            teleported: appendToBody.value,
            fallbackPlacements: fallbackPlacements.value,
            transition: menuTransitionName.value,
            gpuAcceleration: false
          }, {
            content: () => {
              var _a2;
              return vue.h("div", {
                class: [
                  nsMenu.m(mode.value),
                  nsMenu.m("popup-container"),
                  props.popperClass
                ],
                onMouseenter: (evt) => handleMouseenter(evt, 100),
                onMouseleave: () => handleMouseleave(true),
                onFocus: (evt) => handleMouseenter(evt, 100)
              }, [
                vue.h("ul", {
                  class: [
                    nsMenu.b(),
                    nsMenu.m("popup"),
                    nsMenu.m(`popup-${currentPlacement.value}`)
                  ],
                  style: ulStyle.value
                }, [(_a2 = slots.default) == null ? void 0 : _a2.call(slots)])
              ]);
            },
            default: () => vue.h("div", {
              class: nsSubMenu.e("title"),
              style: [
                titleStyle.value,
                { backgroundColor: backgroundColor.value }
              ],
              onClick: handleClick
            }, titleTag)
          }) : vue.h(vue.Fragment, {}, [
            vue.h("div", {
              class: nsSubMenu.e("title"),
              style: [
                titleStyle.value,
                { backgroundColor: backgroundColor.value }
              ],
              ref: verticalTitleRef,
              onClick: handleClick
            }, titleTag),
            vue.h(_CollapseTransition, {}, {
              default: () => {
                var _a2;
                return vue.withDirectives(vue.h("ul", {
                  role: "menu",
                  class: [nsMenu.b(), nsMenu.m("inline")],
                  style: ulStyle.value
                }, [(_a2 = slots.default) == null ? void 0 : _a2.call(slots)]), [[vue.vShow, opened.value]]);
              }
            })
          ]);
          return vue.h("li", {
            class: [
              nsSubMenu.b(),
              nsSubMenu.is("active", active.value),
              nsSubMenu.is("opened", opened.value),
              nsSubMenu.is("disabled", props.disabled)
            ],
            role: "menuitem",
            ariaHaspopup: true,
            ariaExpanded: opened.value,
            onMouseenter: handleMouseenter,
            onMouseleave: () => handleMouseleave(true),
            onFocus: handleMouseenter
          }, [child]);
        };
      }
    });
  
    const menuProps = buildProps({
      mode: {
        type: String,
        values: ["horizontal", "vertical"],
        default: "vertical"
      },
      defaultActive: {
        type: String,
        default: ""
      },
      defaultOpeneds: {
        type: definePropType(Array),
        default: () => mutable([])
      },
      uniqueOpened: Boolean,
      router: Boolean,
      menuTrigger: {
        type: String,
        values: ["hover", "click"],
        default: "hover"
      },
      collapse: Boolean,
      backgroundColor: String,
      textColor: String,
      activeTextColor: String,
      collapseTransition: {
        type: Boolean,
        default: true
      },
      ellipsis: {
        type: Boolean,
        default: true
      }
    });
    const checkIndexPath = (indexPath) => Array.isArray(indexPath) && indexPath.every((path) => isString(path));
    const menuEmits = {
      close: (index, indexPath) => isString(index) && checkIndexPath(indexPath),
      open: (index, indexPath) => isString(index) && checkIndexPath(indexPath),
      select: (index, indexPath, item, routerResult) => isString(index) && checkIndexPath(indexPath) && isObject$1(item) && (routerResult === void 0 || routerResult instanceof Promise)
    };
    var Menu = vue.defineComponent({
      name: "ElMenu",
      props: menuProps,
      emits: menuEmits,
      setup(props, { emit, slots, expose }) {
        const instance = vue.getCurrentInstance();
        const router = instance.appContext.config.globalProperties.$router;
        const menu = vue.ref();
        const nsMenu = useNamespace("menu");
        const nsSubMenu = useNamespace("sub-menu");
        const sliceIndex = vue.ref(-1);
        const openedMenus = vue.ref(props.defaultOpeneds && !props.collapse ? props.defaultOpeneds.slice(0) : []);
        const activeIndex = vue.ref(props.defaultActive);
        const items = vue.ref({});
        const subMenus = vue.ref({});
        const isMenuPopup = vue.computed(() => {
          return props.mode === "horizontal" || props.mode === "vertical" && props.collapse;
        });
        const initMenu = () => {
          const activeItem = activeIndex.value && items.value[activeIndex.value];
          if (!activeItem || props.mode === "horizontal" || props.collapse)
            return;
          const indexPath = activeItem.indexPath;
          indexPath.forEach((index) => {
            const subMenu = subMenus.value[index];
            subMenu && openMenu(index, subMenu.indexPath);
          });
        };
        const openMenu = (index, indexPath) => {
          if (openedMenus.value.includes(index))
            return;
          if (props.uniqueOpened) {
            openedMenus.value = openedMenus.value.filter((index2) => indexPath.includes(index2));
          }
          openedMenus.value.push(index);
          emit("open", index, indexPath);
        };
        const closeMenu = (index, indexPath) => {
          const i = openedMenus.value.indexOf(index);
          if (i !== -1) {
            openedMenus.value.splice(i, 1);
          }
          emit("close", index, indexPath);
        };
        const handleSubMenuClick = ({
          index,
          indexPath
        }) => {
          const isOpened = openedMenus.value.includes(index);
          if (isOpened) {
            closeMenu(index, indexPath);
          } else {
            openMenu(index, indexPath);
          }
        };
        const handleMenuItemClick = (menuItem) => {
          if (props.mode === "horizontal" || props.collapse) {
            openedMenus.value = [];
          }
          const { index, indexPath } = menuItem;
          if (index === void 0 || indexPath === void 0)
            return;
          if (props.router && router) {
            const route = menuItem.route || index;
            const routerResult = router.push(route).then((res) => {
              if (!res)
                activeIndex.value = index;
              return res;
            });
            emit("select", index, indexPath, { index, indexPath, route }, routerResult);
          } else {
            activeIndex.value = index;
            emit("select", index, indexPath, { index, indexPath });
          }
        };
        const updateActiveIndex = (val) => {
          const itemsInData = items.value;
          const item = itemsInData[val] || activeIndex.value && itemsInData[activeIndex.value] || itemsInData[props.defaultActive];
          if (item) {
            activeIndex.value = item.index;
          } else {
            activeIndex.value = val;
          }
        };
        const calcSliceIndex = () => {
          var _a, _b;
          if (!menu.value)
            return -1;
          const items2 = Array.from((_b = (_a = menu.value) == null ? void 0 : _a.childNodes) != null ? _b : []).filter((item) => item.nodeName !== "#text" || item.nodeValue);
          const moreItemWidth = 64;
          const paddingLeft = Number.parseInt(getComputedStyle(menu.value).paddingLeft, 10);
          const paddingRight = Number.parseInt(getComputedStyle(menu.value).paddingRight, 10);
          const menuWidth = menu.value.clientWidth - paddingLeft - paddingRight;
          let calcWidth = 0;
          let sliceIndex2 = 0;
          items2.forEach((item, index) => {
            calcWidth += item.offsetWidth || 0;
            if (calcWidth <= menuWidth - moreItemWidth) {
              sliceIndex2 = index + 1;
            }
          });
          return sliceIndex2 === items2.length ? -1 : sliceIndex2;
        };
        const debounce = (fn, wait = 33.34) => {
          let timmer;
          return () => {
            timmer && clearTimeout(timmer);
            timmer = setTimeout(() => {
              fn();
            }, wait);
          };
        };
        let isFirstTimeRender = true;
        const handleResize = () => {
          const callback = () => {
            sliceIndex.value = -1;
            vue.nextTick(() => {
              sliceIndex.value = calcSliceIndex();
            });
          };
          isFirstTimeRender ? callback() : debounce(callback)();
          isFirstTimeRender = false;
        };
        vue.watch(() => props.defaultActive, (currentActive) => {
          if (!items.value[currentActive]) {
            activeIndex.value = "";
          }
          updateActiveIndex(currentActive);
        });
        vue.watch(() => props.collapse, (value) => {
          if (value)
            openedMenus.value = [];
        });
        vue.watch(items.value, initMenu);
        let resizeStopper;
        vue.watchEffect(() => {
          if (props.mode === "horizontal" && props.ellipsis)
            resizeStopper = useResizeObserver(menu, handleResize).stop;
          else
            resizeStopper == null ? void 0 : resizeStopper();
        });
        {
          const addSubMenu = (item) => {
            subMenus.value[item.index] = item;
          };
          const removeSubMenu = (item) => {
            delete subMenus.value[item.index];
          };
          const addMenuItem = (item) => {
            items.value[item.index] = item;
          };
          const removeMenuItem = (item) => {
            delete items.value[item.index];
          };
          vue.provide("rootMenu", vue.reactive({
            props,
            openedMenus,
            items,
            subMenus,
            activeIndex,
            isMenuPopup,
            addMenuItem,
            removeMenuItem,
            addSubMenu,
            removeSubMenu,
            openMenu,
            closeMenu,
            handleMenuItemClick,
            handleSubMenuClick
          }));
          vue.provide(`subMenu:${instance.uid}`, {
            addSubMenu,
            removeSubMenu,
            mouseInChild: vue.ref(false),
            level: 0
          });
        }
        vue.onMounted(() => {
          if (props.mode === "horizontal") {
            new Menubar(instance.vnode.el, nsMenu.namespace.value);
          }
        });
        {
          const open = (index) => {
            const { indexPath } = subMenus.value[index];
            indexPath.forEach((i) => openMenu(i, indexPath));
          };
          expose({
            open,
            close: closeMenu,
            handleResize
          });
        }
        return () => {
          var _a, _b;
          let slot = (_b = (_a = slots.default) == null ? void 0 : _a.call(slots)) != null ? _b : [];
          const vShowMore = [];
          if (props.mode === "horizontal" && menu.value) {
            const originalSlot = flattedChildren(slot);
            const slotDefault = sliceIndex.value === -1 ? originalSlot : originalSlot.slice(0, sliceIndex.value);
            const slotMore = sliceIndex.value === -1 ? [] : originalSlot.slice(sliceIndex.value);
            if ((slotMore == null ? void 0 : slotMore.length) && props.ellipsis) {
              slot = slotDefault;
              vShowMore.push(vue.h(SubMenu, {
                index: "sub-menu-more",
                class: nsSubMenu.e("hide-arrow")
              }, {
                title: () => vue.h(ElIcon, {
                  class: nsSubMenu.e("icon-more")
                }, { default: () => vue.h(more_default) }),
                default: () => slotMore
              }));
            }
          }
          const ulStyle = useMenuCssVar(props, 0);
          const vMenu = vue.h("ul", {
            key: String(props.collapse),
            role: "menubar",
            ref: menu,
            style: ulStyle.value,
            class: {
              [nsMenu.b()]: true,
              [nsMenu.m(props.mode)]: true,
              [nsMenu.m("collapse")]: props.collapse
            }
          }, [...slot, ...vShowMore]);
          if (props.collapseTransition && props.mode === "vertical") {
            return vue.h(ElMenuCollapseTransition, () => vMenu);
          }
          return vMenu;
        };
      }
    });
  
    const menuItemProps = buildProps({
      index: {
        type: definePropType([String, null]),
        default: null
      },
      route: {
        type: definePropType([String, Object])
      },
      disabled: Boolean
    });
    const menuItemEmits = {
      click: (item) => isString(item.index) && Array.isArray(item.indexPath)
    };
  
    const COMPONENT_NAME$b = "ElMenuItem";
    const _sfc_main$T = vue.defineComponent({
      name: COMPONENT_NAME$b,
      components: {
        ElTooltip
      },
      props: menuItemProps,
      emits: menuItemEmits,
      setup(props, { emit }) {
        const instance = vue.getCurrentInstance();
        const rootMenu = vue.inject("rootMenu");
        const nsMenu = useNamespace("menu");
        const nsMenuItem = useNamespace("menu-item");
        if (!rootMenu)
          throwError(COMPONENT_NAME$b, "can not inject root menu");
        const { parentMenu, indexPath } = useMenu(instance, vue.toRef(props, "index"));
        const subMenu = vue.inject(`subMenu:${parentMenu.value.uid}`);
        if (!subMenu)
          throwError(COMPONENT_NAME$b, "can not inject sub menu");
        const active = vue.computed(() => props.index === rootMenu.activeIndex);
        const item = vue.reactive({
          index: props.index,
          indexPath,
          active
        });
        const handleClick = () => {
          if (!props.disabled) {
            rootMenu.handleMenuItemClick({
              index: props.index,
              indexPath: indexPath.value,
              route: props.route
            });
            emit("click", item);
          }
        };
        vue.onMounted(() => {
          subMenu.addSubMenu(item);
          rootMenu.addMenuItem(item);
        });
        vue.onBeforeUnmount(() => {
          subMenu.removeSubMenu(item);
          rootMenu.removeMenuItem(item);
        });
        return {
          Effect,
          parentMenu,
          rootMenu,
          active,
          nsMenu,
          nsMenuItem,
          handleClick
        };
      }
    });
    function _sfc_render$d(_ctx, _cache, $props, $setup, $data, $options) {
      const _component_el_tooltip = vue.resolveComponent("el-tooltip");
      return vue.openBlock(), vue.createElementBlock("li", {
        class: vue.normalizeClass([
          _ctx.nsMenuItem.b(),
          _ctx.nsMenuItem.is("active", _ctx.active),
          _ctx.nsMenuItem.is("disabled", _ctx.disabled)
        ]),
        role: "menuitem",
        tabindex: "-1",
        onClick: _cache[0] || (_cache[0] = (...args) => _ctx.handleClick && _ctx.handleClick(...args))
      }, [
        _ctx.parentMenu.type.name === "ElMenu" && _ctx.rootMenu.props.collapse && _ctx.$slots.title ? (vue.openBlock(), vue.createBlock(_component_el_tooltip, {
          key: 0,
          effect: _ctx.Effect.DARK,
          placement: "right",
          "fallback-placements": ["left"],
          persistent: ""
        }, {
          content: vue.withCtx(() => [
            vue.renderSlot(_ctx.$slots, "title")
          ]),
          default: vue.withCtx(() => [
            vue.createElementVNode("div", {
              class: vue.normalizeClass(_ctx.nsMenu.be("tooltip", "trigger"))
            }, [
              vue.renderSlot(_ctx.$slots, "default")
            ], 2)
          ]),
          _: 3
        }, 8, ["effect"])) : (vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: 1 }, [
          vue.renderSlot(_ctx.$slots, "default"),
          vue.renderSlot(_ctx.$slots, "title")
        ], 64))
      ], 2);
    }
    var MenuItem = /* @__PURE__ */ _export_sfc(_sfc_main$T, [["render", _sfc_render$d], ["__file", "menu-item.vue"]]);
  
    const menuItemGroupProps = {
      title: String
    };
  
    const COMPONENT_NAME$a = "ElMenuItemGroup";
    const _sfc_main$S = vue.defineComponent({
      name: COMPONENT_NAME$a,
      props: menuItemGroupProps,
      setup() {
        const ns = useNamespace("menu-item-group");
        return {
          ns
        };
      }
    });
    function _sfc_render$c(_ctx, _cache, $props, $setup, $data, $options) {
      return vue.openBlock(), vue.createElementBlock("li", {
        class: vue.normalizeClass(_ctx.ns.b())
      }, [
        vue.createElementVNode("div", {
          class: vue.normalizeClass(_ctx.ns.e("title"))
        }, [
          !_ctx.$slots.title ? (vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: 0 }, [
            vue.createTextVNode(vue.toDisplayString(_ctx.title), 1)
          ], 64)) : vue.renderSlot(_ctx.$slots, "title", { key: 1 })
        ], 2),
        vue.createElementVNode("ul", null, [
          vue.renderSlot(_ctx.$slots, "default")
        ])
      ], 2);
    }
    var MenuItemGroup = /* @__PURE__ */ _export_sfc(_sfc_main$S, [["render", _sfc_render$c], ["__file", "menu-item-group.vue"]]);
  
    const ElMenu = withInstall(Menu, {
      MenuItem,
      MenuItemGroup,
      SubMenu
    });
    const ElMenuItem = withNoopInstall(MenuItem);
    const ElMenuItemGroup = withNoopInstall(MenuItemGroup);
    const ElSubMenu = withNoopInstall(SubMenu);
  
    const pageHeaderProps = buildProps({
      icon: {
        type: iconPropType,
        default: () => back_default
      },
      title: String,
      content: {
        type: String,
        default: ""
      }
    });
    const pageHeaderEmits = {
      back: () => true
    };
  
    const _hoisted_1$q = ["aria-label"];
    const __default__$D = vue.defineComponent({
      name: "ElPageHeader"
    });
    const _sfc_main$R = /* @__PURE__ */ vue.defineComponent({
      ...__default__$D,
      props: pageHeaderProps,
      emits: pageHeaderEmits,
      setup(__props, { emit }) {
        const slots = vue.useSlots();
        const { t } = useLocale();
        const ns = useNamespace("page-header");
        const kls = vue.computed(() => {
          return [
            ns.b(),
            {
              [ns.m("has-breadcrumb")]: !!slots.breadcrumb,
              [ns.m("has-extra")]: !!slots.extra,
              [ns.is("contentful")]: !!slots.default
            }
          ];
        });
        function handleClick() {
          emit("back");
        }
        return (_ctx, _cache) => {
          return vue.openBlock(), vue.createElementBlock("div", {
            class: vue.normalizeClass(vue.unref(kls))
          }, [
            vue.createElementVNode("div", {
              class: vue.normalizeClass(vue.unref(ns).e("breadcrumb"))
            }, [
              vue.renderSlot(_ctx.$slots, "breadcrumb")
            ], 2),
            vue.createElementVNode("div", {
              class: vue.normalizeClass(vue.unref(ns).e("header"))
            }, [
              vue.createElementVNode("div", {
                class: vue.normalizeClass(vue.unref(ns).e("left"))
              }, [
                vue.createElementVNode("div", {
                  class: vue.normalizeClass(vue.unref(ns).e("back")),
                  role: "button",
                  tabindex: "0",
                  onClick: handleClick
                }, [
                  _ctx.icon || _ctx.$slots.icon ? (vue.openBlock(), vue.createElementBlock("div", {
                    key: 0,
                    "aria-label": _ctx.title || vue.unref(t)("el.pageHeader.title"),
                    class: vue.normalizeClass(vue.unref(ns).e("icon"))
                  }, [
                    vue.renderSlot(_ctx.$slots, "icon", {}, () => [
                      _ctx.icon ? (vue.openBlock(), vue.createBlock(vue.unref(ElIcon), { key: 0 }, {
                        default: vue.withCtx(() => [
                          (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(_ctx.icon)))
                        ]),
                        _: 1
                      })) : vue.createCommentVNode("v-if", true)
                    ])
                  ], 10, _hoisted_1$q)) : vue.createCommentVNode("v-if", true),
                  vue.createElementVNode("div", {
                    class: vue.normalizeClass(vue.unref(ns).e("title"))
                  }, [
                    vue.renderSlot(_ctx.$slots, "title", {}, () => [
                      vue.createTextVNode(vue.toDisplayString(_ctx.title || vue.unref(t)("el.pageHeader.title")), 1)
                    ])
                  ], 2)
                ], 2),
                vue.createVNode(vue.unref(ElDivider), { direction: "vertical" }),
                vue.createElementVNode("div", {
                  class: vue.normalizeClass(vue.unref(ns).e("content"))
                }, [
                  vue.renderSlot(_ctx.$slots, "content", {}, () => [
                    vue.createTextVNode(vue.toDisplayString(_ctx.content), 1)
                  ])
                ], 2)
              ], 2),
              _ctx.$slots.extra ? (vue.openBlock(), vue.createElementBlock("div", {
                key: 0,
                class: vue.normalizeClass(vue.unref(ns).e("extra"))
              }, [
                vue.renderSlot(_ctx.$slots, "extra")
              ], 2)) : vue.createCommentVNode("v-if", true)
            ], 2),
            _ctx.$slots.default ? (vue.openBlock(), vue.createElementBlock("div", {
              key: 0,
              class: vue.normalizeClass(vue.unref(ns).e("main"))
            }, [
              vue.renderSlot(_ctx.$slots, "default")
            ], 2)) : vue.createCommentVNode("v-if", true)
          ], 2);
        };
      }
    });
    var PageHeader = /* @__PURE__ */ _export_sfc(_sfc_main$R, [["__file", "page-header.vue"]]);
  
    const ElPageHeader = withInstall(PageHeader);
  
    const paginationPrevProps = buildProps({
      disabled: Boolean,
      currentPage: {
        type: Number,
        default: 1
      },
      prevText: {
        type: String
      },
      prevIcon: {
        type: iconPropType
      }
    });
    const paginationPrevEmits = {
      click: (evt) => evt instanceof MouseEvent
    };
  
    const _hoisted_1$p = ["disabled", "aria-disabled"];
    const _hoisted_2$h = { key: 0 };
    const __default__$C = vue.defineComponent({
      name: "ElPaginationPrev"
    });
    const _sfc_main$Q = /* @__PURE__ */ vue.defineComponent({
      ...__default__$C,
      props: paginationPrevProps,
      emits: paginationPrevEmits,
      setup(__props) {
        const props = __props;
        const internalDisabled = vue.computed(() => props.disabled || props.currentPage <= 1);
        return (_ctx, _cache) => {
          return vue.openBlock(), vue.createElementBlock("button", {
            type: "button",
            class: "btn-prev",
            disabled: vue.unref(internalDisabled),
            "aria-disabled": vue.unref(internalDisabled),
            onClick: _cache[0] || (_cache[0] = ($event) => _ctx.$emit("click", $event))
          }, [
            _ctx.prevText ? (vue.openBlock(), vue.createElementBlock("span", _hoisted_2$h, vue.toDisplayString(_ctx.prevText), 1)) : (vue.openBlock(), vue.createBlock(vue.unref(ElIcon), { key: 1 }, {
              default: vue.withCtx(() => [
                (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(_ctx.prevIcon)))
              ]),
              _: 1
            }))
          ], 8, _hoisted_1$p);
        };
      }
    });
    var Prev = /* @__PURE__ */ _export_sfc(_sfc_main$Q, [["__file", "prev.vue"]]);
  
    const paginationNextProps = buildProps({
      disabled: Boolean,
      currentPage: {
        type: Number,
        default: 1
      },
      pageCount: {
        type: Number,
        default: 50
      },
      nextText: {
        type: String
      },
      nextIcon: {
        type: iconPropType
      }
    });
  
    const _hoisted_1$o = ["disabled", "aria-disabled"];
    const _hoisted_2$g = { key: 0 };
    const __default__$B = vue.defineComponent({
      name: "ElPaginationNext"
    });
    const _sfc_main$P = /* @__PURE__ */ vue.defineComponent({
      ...__default__$B,
      props: paginationNextProps,
      emits: ["click"],
      setup(__props) {
        const props = __props;
        const internalDisabled = vue.computed(() => props.disabled || props.currentPage === props.pageCount || props.pageCount === 0);
        return (_ctx, _cache) => {
          return vue.openBlock(), vue.createElementBlock("button", {
            type: "button",
            class: "btn-next",
            disabled: vue.unref(internalDisabled),
            "aria-disabled": vue.unref(internalDisabled),
            onClick: _cache[0] || (_cache[0] = ($event) => _ctx.$emit("click", $event))
          }, [
            _ctx.nextText ? (vue.openBlock(), vue.createElementBlock("span", _hoisted_2$g, vue.toDisplayString(_ctx.nextText), 1)) : (vue.openBlock(), vue.createBlock(vue.unref(ElIcon), { key: 1 }, {
              default: vue.withCtx(() => [
                (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(_ctx.nextIcon)))
              ]),
              _: 1
            }))
          ], 8, _hoisted_1$o);
        };
      }
    });
    var Next = /* @__PURE__ */ _export_sfc(_sfc_main$P, [["__file", "next.vue"]]);
  
    const selectGroupKey = "ElSelectGroup";
    const selectKey = "ElSelect";
  
    function useOption$1(props, states) {
      const select = vue.inject(selectKey);
      const selectGroup = vue.inject(selectGroupKey, { disabled: false });
      const isObject = vue.computed(() => {
        return Object.prototype.toString.call(props.value).toLowerCase() === "[object object]";
      });
      const itemSelected = vue.computed(() => {
        if (!select.props.multiple) {
          return isEqual(props.value, select.props.modelValue);
        } else {
          return contains(select.props.modelValue, props.value);
        }
      });
      const limitReached = vue.computed(() => {
        if (select.props.multiple) {
          const modelValue = select.props.modelValue || [];
          return !itemSelected.value && modelValue.length >= select.props.multipleLimit && select.props.multipleLimit > 0;
        } else {
          return false;
        }
      });
      const currentLabel = vue.computed(() => {
        return props.label || (isObject.value ? "" : props.value);
      });
      const currentValue = vue.computed(() => {
        return props.value || props.label || "";
      });
      const isDisabled = vue.computed(() => {
        return props.disabled || states.groupDisabled || limitReached.value;
      });
      const instance = vue.getCurrentInstance();
      const contains = (arr = [], target) => {
        if (!isObject.value) {
          return arr && arr.includes(target);
        } else {
          const valueKey = select.props.valueKey;
          return arr && arr.some((item) => {
            return vue.toRaw(get(item, valueKey)) === get(target, valueKey);
          });
        }
      };
      const isEqual = (a, b) => {
        if (!isObject.value) {
          return a === b;
        } else {
          const { valueKey } = select.props;
          return get(a, valueKey) === get(b, valueKey);
        }
      };
      const hoverItem = () => {
        if (!props.disabled && !selectGroup.disabled) {
          select.hoverIndex = select.optionsArray.indexOf(instance.proxy);
        }
      };
      vue.watch(() => currentLabel.value, () => {
        if (!props.created && !select.props.remote)
          select.setSelected();
      });
      vue.watch(() => props.value, (val, oldVal) => {
        const { remote, valueKey } = select.props;
        if (!Object.is(val, oldVal)) {
          select.onOptionDestroy(oldVal, instance.proxy);
          select.onOptionCreate(instance.proxy);
        }
        if (!props.created && !remote) {
          if (valueKey && typeof val === "object" && typeof oldVal === "object" && val[valueKey] === oldVal[valueKey]) {
            return;
          }
          select.setSelected();
        }
      });
      vue.watch(() => selectGroup.disabled, () => {
        states.groupDisabled = selectGroup.disabled;
      }, { immediate: true });
      const { queryChange } = vue.toRaw(select);
      vue.watch(queryChange, (changes) => {
        const { query } = vue.unref(changes);
        const regexp = new RegExp(escapeStringRegexp(query), "i");
        states.visible = regexp.test(currentLabel.value) || props.created;
        if (!states.visible) {
          select.filteredOptionsCount--;
        }
      });
      return {
        select,
        currentLabel,
        currentValue,
        itemSelected,
        isDisabled,
        hoverItem
      };
    }
  
    const _sfc_main$O = vue.defineComponent({
      name: "ElOption",
      componentName: "ElOption",
      props: {
        value: {
          required: true,
          type: [String, Number, Boolean, Object]
        },
        label: [String, Number],
        created: Boolean,
        disabled: {
          type: Boolean,
          default: false
        }
      },
      setup(props) {
        const ns = useNamespace("select");
        const states = vue.reactive({
          index: -1,
          groupDisabled: false,
          visible: true,
          hitState: false,
          hover: false
        });
        const { currentLabel, itemSelected, isDisabled, select, hoverItem } = useOption$1(props, states);
        const { visible, hover } = vue.toRefs(states);
        const vm = vue.getCurrentInstance().proxy;
        select.onOptionCreate(vm);
        vue.onBeforeUnmount(() => {
          const key = vm.value;
          const { selected } = select;
          const selectedOptions = select.props.multiple ? selected : [selected];
          const doesSelected = selectedOptions.some((item) => {
            return item.value === vm.value;
          });
          vue.nextTick(() => {
            if (select.cachedOptions.get(key) === vm && !doesSelected) {
              select.cachedOptions.delete(key);
            }
          });
          select.onOptionDestroy(key, vm);
        });
        function selectOptionClick() {
          if (props.disabled !== true && states.groupDisabled !== true) {
            select.handleOptionSelect(vm, true);
          }
        }
        return {
          ns,
          currentLabel,
          itemSelected,
          isDisabled,
          select,
          hoverItem,
          visible,
          hover,
          selectOptionClick,
          states
        };
      }
    });
    function _sfc_render$b(_ctx, _cache, $props, $setup, $data, $options) {
      return vue.withDirectives((vue.openBlock(), vue.createElementBlock("li", {
        class: vue.normalizeClass([
          _ctx.ns.be("dropdown", "item"),
          _ctx.ns.is("disabled", _ctx.isDisabled),
          {
            selected: _ctx.itemSelected,
            hover: _ctx.hover
          }
        ]),
        onMouseenter: _cache[0] || (_cache[0] = (...args) => _ctx.hoverItem && _ctx.hoverItem(...args)),
        onClick: _cache[1] || (_cache[1] = vue.withModifiers((...args) => _ctx.selectOptionClick && _ctx.selectOptionClick(...args), ["stop"]))
      }, [
        vue.renderSlot(_ctx.$slots, "default", {}, () => [
          vue.createElementVNode("span", null, vue.toDisplayString(_ctx.currentLabel), 1)
        ])
      ], 34)), [
        [vue.vShow, _ctx.visible]
      ]);
    }
    var Option = /* @__PURE__ */ _export_sfc(_sfc_main$O, [["render", _sfc_render$b], ["__file", "option.vue"]]);
  
    const _sfc_main$N = vue.defineComponent({
      name: "ElSelectDropdown",
      componentName: "ElSelectDropdown",
      setup() {
        const select = vue.inject(selectKey);
        const ns = useNamespace("select");
        const popperClass = vue.computed(() => select.props.popperClass);
        const isMultiple = vue.computed(() => select.props.multiple);
        const isFitInputWidth = vue.computed(() => select.props.fitInputWidth);
        const minWidth = vue.ref("");
        function updateMinWidth() {
          var _a;
          minWidth.value = `${(_a = select.selectWrapper) == null ? void 0 : _a.offsetWidth}px`;
        }
        vue.onMounted(() => {
          updateMinWidth();
          useResizeObserver(select.selectWrapper, updateMinWidth);
        });
        return {
          ns,
          minWidth,
          popperClass,
          isMultiple,
          isFitInputWidth
        };
      }
    });
    function _sfc_render$a(_ctx, _cache, $props, $setup, $data, $options) {
      return vue.openBlock(), vue.createElementBlock("div", {
        class: vue.normalizeClass([_ctx.ns.b("dropdown"), _ctx.ns.is("multiple", _ctx.isMultiple), _ctx.popperClass]),
        style: vue.normalizeStyle({ [_ctx.isFitInputWidth ? "width" : "minWidth"]: _ctx.minWidth })
      }, [
        vue.renderSlot(_ctx.$slots, "default")
      ], 6);
    }
    var ElSelectMenu$1 = /* @__PURE__ */ _export_sfc(_sfc_main$N, [["render", _sfc_render$a], ["__file", "select-dropdown.vue"]]);
  
    function useSelectStates(props) {
      const { t } = useLocale();
      return vue.reactive({
        options: /* @__PURE__ */ new Map(),
        cachedOptions: /* @__PURE__ */ new Map(),
        createdLabel: null,
        createdSelected: false,
        selected: props.multiple ? [] : {},
        inputLength: 20,
        inputWidth: 0,
        optionsCount: 0,
        filteredOptionsCount: 0,
        visible: false,
        softFocus: false,
        selectedLabel: "",
        hoverIndex: -1,
        query: "",
        previousQuery: null,
        inputHovering: false,
        cachedPlaceHolder: "",
        currentPlaceholder: t("el.select.placeholder"),
        menuVisibleOnFocus: false,
        isOnComposition: false,
        isSilentBlur: false,
        prefixWidth: 11,
        tagInMultiLine: false,
        mouseEnter: false
      });
    }
    const useSelect$3 = (props, states, ctx) => {
      const { t } = useLocale();
      const ns = useNamespace("select");
      useDeprecated({
        from: "suffixTransition",
        replacement: "override style scheme",
        version: "2.3.0",
        scope: "props",
        ref: "https://element-plus.org/en-US/component/select.html#select-attributes"
      }, vue.computed(() => props.suffixTransition === false));
      const reference = vue.ref(null);
      const input = vue.ref(null);
      const tooltipRef = vue.ref(null);
      const tags = vue.ref(null);
      const selectWrapper = vue.ref(null);
      const scrollbar = vue.ref(null);
      const hoverOption = vue.ref(-1);
      const queryChange = vue.shallowRef({ query: "" });
      const groupQueryChange = vue.shallowRef("");
      const { form, formItem } = useFormItem();
      const readonly = vue.computed(() => !props.filterable || props.multiple || !states.visible);
      const selectDisabled = vue.computed(() => props.disabled || (form == null ? void 0 : form.disabled));
      const showClose = vue.computed(() => {
        const hasValue = props.multiple ? Array.isArray(props.modelValue) && props.modelValue.length > 0 : props.modelValue !== void 0 && props.modelValue !== null && props.modelValue !== "";
        const criteria = props.clearable && !selectDisabled.value && states.inputHovering && hasValue;
        return criteria;
      });
      const iconComponent = vue.computed(() => props.remote && props.filterable && !props.remoteShowSuffix ? "" : props.suffixIcon);
      const iconReverse = vue.computed(() => ns.is("reverse", iconComponent.value && states.visible && props.suffixTransition));
      const debounce$1 = vue.computed(() => props.remote ? 300 : 0);
      const emptyText = vue.computed(() => {
        if (props.loading) {
          return props.loadingText || t("el.select.loading");
        } else {
          if (props.remote && states.query === "" && states.options.size === 0)
            return false;
          if (props.filterable && states.query && states.options.size > 0 && states.filteredOptionsCount === 0) {
            return props.noMatchText || t("el.select.noMatch");
          }
          if (states.options.size === 0) {
            return props.noDataText || t("el.select.noData");
          }
        }
        return null;
      });
      const optionsArray = vue.computed(() => Array.from(states.options.values()));
      const cachedOptionsArray = vue.computed(() => Array.from(states.cachedOptions.values()));
      const showNewOption = vue.computed(() => {
        const hasExistingOption = optionsArray.value.filter((option) => {
          return !option.created;
        }).some((option) => {
          return option.currentLabel === states.query;
        });
        return props.filterable && props.allowCreate && states.query !== "" && !hasExistingOption;
      });
      const selectSize = useSize();
      const collapseTagSize = vue.computed(() => ["small"].includes(selectSize.value) ? "small" : "default");
      const dropMenuVisible = vue.computed({
        get() {
          return states.visible && emptyText.value !== false;
        },
        set(val) {
          states.visible = val;
        }
      });
      vue.watch([() => selectDisabled.value, () => selectSize.value, () => form == null ? void 0 : form.size], () => {
        vue.nextTick(() => {
          resetInputHeight();
        });
      });
      vue.watch(() => props.placeholder, (val) => {
        states.cachedPlaceHolder = states.currentPlaceholder = val;
      });
      vue.watch(() => props.modelValue, (val, oldVal) => {
        if (props.multiple) {
          resetInputHeight();
          if (val && val.length > 0 || input.value && states.query !== "") {
            states.currentPlaceholder = "";
          } else {
            states.currentPlaceholder = states.cachedPlaceHolder;
          }
          if (props.filterable && !props.reserveKeyword) {
            states.query = "";
            handleQueryChange(states.query);
          }
        }
        setSelected();
        if (props.filterable && !props.multiple) {
          states.inputLength = 20;
        }
        if (!isEqual$1(val, oldVal) && props.validateEvent) {
          formItem == null ? void 0 : formItem.validate("change").catch((err) => debugWarn());
        }
      }, {
        flush: "post",
        deep: true
      });
      vue.watch(() => states.visible, (val) => {
        var _a, _b, _c;
        if (!val) {
          if (props.filterable) {
            if (isFunction(props.filterMethod)) {
              props.filterMethod("");
            }
            if (isFunction(props.remoteMethod)) {
              props.remoteMethod("");
            }
          }
          input.value && input.value.blur();
          states.query = "";
          states.previousQuery = null;
          states.selectedLabel = "";
          states.inputLength = 20;
          states.menuVisibleOnFocus = false;
          resetHoverIndex();
          vue.nextTick(() => {
            if (input.value && input.value.value === "" && states.selected.length === 0) {
              states.currentPlaceholder = states.cachedPlaceHolder;
            }
          });
          if (!props.multiple) {
            if (states.selected) {
              if (props.filterable && props.allowCreate && states.createdSelected && states.createdLabel) {
                states.selectedLabel = states.createdLabel;
              } else {
                states.selectedLabel = states.selected.currentLabel;
              }
              if (props.filterable)
                states.query = states.selectedLabel;
            }
            if (props.filterable) {
              states.currentPlaceholder = states.cachedPlaceHolder;
            }
          }
        } else {
          (_b = (_a = tooltipRef.value) == null ? void 0 : _a.updatePopper) == null ? void 0 : _b.call(_a);
          if (props.filterable) {
            states.filteredOptionsCount = states.optionsCount;
            states.query = props.remote ? "" : states.selectedLabel;
            if (props.multiple) {
              (_c = input.value) == null ? void 0 : _c.focus();
            } else {
              if (states.selectedLabel) {
                states.currentPlaceholder = `${states.selectedLabel}`;
                states.selectedLabel = "";
              }
            }
            handleQueryChange(states.query);
            if (!props.multiple && !props.remote) {
              queryChange.value.query = "";
              vue.triggerRef(queryChange);
              vue.triggerRef(groupQueryChange);
            }
          }
        }
        ctx.emit("visible-change", val);
      });
      vue.watch(() => states.options.entries(), () => {
        var _a, _b, _c;
        if (!isClient)
          return;
        (_b = (_a = tooltipRef.value) == null ? void 0 : _a.updatePopper) == null ? void 0 : _b.call(_a);
        if (props.multiple) {
          resetInputHeight();
        }
        const inputs = ((_c = selectWrapper.value) == null ? void 0 : _c.querySelectorAll("input")) || [];
        if (!Array.from(inputs).includes(document.activeElement)) {
          setSelected();
        }
        if (props.defaultFirstOption && (props.filterable || props.remote) && states.filteredOptionsCount) {
          checkDefaultFirstOption();
        }
      }, {
        flush: "post"
      });
      vue.watch(() => states.hoverIndex, (val) => {
        if (isNumber(val) && val > -1) {
          hoverOption.value = optionsArray.value[val] || {};
        } else {
          hoverOption.value = {};
        }
        optionsArray.value.forEach((option) => {
          option.hover = hoverOption.value === option;
        });
      });
      const resetInputHeight = () => {
        if (props.collapseTags && !props.filterable)
          return;
        vue.nextTick(() => {
          var _a, _b;
          if (!reference.value)
            return;
          const input2 = reference.value.$el.querySelector("input");
          const _tags = tags.value;
          const sizeInMap = getComponentSize(selectSize.value || (form == null ? void 0 : form.size));
          input2.style.height = `${(states.selected.length === 0 ? sizeInMap : Math.max(_tags ? _tags.clientHeight + (_tags.clientHeight > sizeInMap ? 6 : 0) : 0, sizeInMap)) - 2}px`;
          states.tagInMultiLine = Number.parseFloat(input2.style.height) >= sizeInMap;
          if (states.visible && emptyText.value !== false) {
            (_b = (_a = tooltipRef.value) == null ? void 0 : _a.updatePopper) == null ? void 0 : _b.call(_a);
          }
        });
      };
      const handleQueryChange = async (val) => {
        if (states.previousQuery === val || states.isOnComposition)
          return;
        if (states.previousQuery === null && (isFunction(props.filterMethod) || isFunction(props.remoteMethod))) {
          states.previousQuery = val;
          return;
        }
        states.previousQuery = val;
        vue.nextTick(() => {
          var _a, _b;
          if (states.visible)
            (_b = (_a = tooltipRef.value) == null ? void 0 : _a.updatePopper) == null ? void 0 : _b.call(_a);
        });
        states.hoverIndex = -1;
        if (props.multiple && props.filterable) {
          vue.nextTick(() => {
            const length = input.value.value.length * 15 + 20;
            states.inputLength = props.collapseTags ? Math.min(50, length) : length;
            managePlaceholder();
            resetInputHeight();
          });
        }
        if (props.remote && isFunction(props.remoteMethod)) {
          states.hoverIndex = -1;
          props.remoteMethod(val);
        } else if (isFunction(props.filterMethod)) {
          props.filterMethod(val);
          vue.triggerRef(groupQueryChange);
        } else {
          states.filteredOptionsCount = states.optionsCount;
          queryChange.value.query = val;
          vue.triggerRef(queryChange);
          vue.triggerRef(groupQueryChange);
        }
        if (props.defaultFirstOption && (props.filterable || props.remote) && states.filteredOptionsCount) {
          await vue.nextTick();
          checkDefaultFirstOption();
        }
      };
      const managePlaceholder = () => {
        if (states.currentPlaceholder !== "") {
          states.currentPlaceholder = input.value.value ? "" : states.cachedPlaceHolder;
        }
      };
      const checkDefaultFirstOption = () => {
        const optionsInDropdown = optionsArray.value.filter((n) => n.visible && !n.disabled && !n.states.groupDisabled);
        const userCreatedOption = optionsInDropdown.find((n) => n.created);
        const firstOriginOption = optionsInDropdown[0];
        states.hoverIndex = getValueIndex(optionsArray.value, userCreatedOption || firstOriginOption);
      };
      const setSelected = () => {
        var _a;
        if (!props.multiple) {
          const option = getOption(props.modelValue);
          if ((_a = option.props) == null ? void 0 : _a.created) {
            states.createdLabel = option.props.value;
            states.createdSelected = true;
          } else {
            states.createdSelected = false;
          }
          states.selectedLabel = option.currentLabel;
          states.selected = option;
          if (props.filterable)
            states.query = states.selectedLabel;
          return;
        } else {
          states.selectedLabel = "";
        }
        const result = [];
        if (Array.isArray(props.modelValue)) {
          props.modelValue.forEach((value) => {
            result.push(getOption(value));
          });
        }
        states.selected = result;
        vue.nextTick(() => {
          resetInputHeight();
        });
      };
      const getOption = (value) => {
        let option;
        const isObjectValue = toRawType(value).toLowerCase() === "object";
        const isNull = toRawType(value).toLowerCase() === "null";
        const isUndefined = toRawType(value).toLowerCase() === "undefined";
        for (let i = states.cachedOptions.size - 1; i >= 0; i--) {
          const cachedOption = cachedOptionsArray.value[i];
          const isEqualValue = isObjectValue ? get(cachedOption.value, props.valueKey) === get(value, props.valueKey) : cachedOption.value === value;
          if (isEqualValue) {
            option = {
              value,
              currentLabel: cachedOption.currentLabel,
              isDisabled: cachedOption.isDisabled
            };
            break;
          }
        }
        if (option)
          return option;
        const label = isObjectValue ? value.label : !isNull && !isUndefined ? value : "";
        const newOption = {
          value,
          currentLabel: label
        };
        if (props.multiple) {
          newOption.hitState = false;
        }
        return newOption;
      };
      const resetHoverIndex = () => {
        setTimeout(() => {
          const valueKey = props.valueKey;
          if (!props.multiple) {
            states.hoverIndex = optionsArray.value.findIndex((item) => {
              return getValueKey(item) === getValueKey(states.selected);
            });
          } else {
            if (states.selected.length > 0) {
              states.hoverIndex = Math.min.apply(null, states.selected.map((selected) => {
                return optionsArray.value.findIndex((item) => {
                  return get(item, valueKey) === get(selected, valueKey);
                });
              }));
            } else {
              states.hoverIndex = -1;
            }
          }
        }, 300);
      };
      const handleResize = () => {
        var _a, _b;
        resetInputWidth();
        (_b = (_a = tooltipRef.value) == null ? void 0 : _a.updatePopper) == null ? void 0 : _b.call(_a);
        if (props.multiple && !props.filterable)
          resetInputHeight();
      };
      const resetInputWidth = () => {
        var _a;
        states.inputWidth = (_a = reference.value) == null ? void 0 : _a.$el.getBoundingClientRect().width;
      };
      const onInputChange = () => {
        if (props.filterable && states.query !== states.selectedLabel) {
          states.query = states.selectedLabel;
          handleQueryChange(states.query);
        }
      };
      const debouncedOnInputChange = debounce(() => {
        onInputChange();
      }, debounce$1.value);
      const debouncedQueryChange = debounce((e) => {
        handleQueryChange(e.target.value);
      }, debounce$1.value);
      const emitChange = (val) => {
        if (!isEqual$1(props.modelValue, val)) {
          ctx.emit(CHANGE_EVENT, val);
        }
      };
      const deletePrevTag = (e) => {
        if (e.target.value.length <= 0 && !toggleLastOptionHitState()) {
          const value = props.modelValue.slice();
          value.pop();
          ctx.emit(UPDATE_MODEL_EVENT, value);
          emitChange(value);
        }
        if (e.target.value.length === 1 && props.modelValue.length === 0) {
          states.currentPlaceholder = states.cachedPlaceHolder;
        }
      };
      const deleteTag = (event, tag) => {
        const index = states.selected.indexOf(tag);
        if (index > -1 && !selectDisabled.value) {
          const value = props.modelValue.slice();
          value.splice(index, 1);
          ctx.emit(UPDATE_MODEL_EVENT, value);
          emitChange(value);
          ctx.emit("remove-tag", tag.value);
        }
        event.stopPropagation();
      };
      const deleteSelected = (event) => {
        event.stopPropagation();
        const value = props.multiple ? [] : "";
        if (!isString(value)) {
          for (const item of states.selected) {
            if (item.isDisabled)
              value.push(item.value);
          }
        }
        ctx.emit(UPDATE_MODEL_EVENT, value);
        emitChange(value);
        states.hoverIndex = -1;
        states.visible = false;
        ctx.emit("clear");
      };
      const handleOptionSelect = (option, byClick) => {
        var _a;
        if (props.multiple) {
          const value = (props.modelValue || []).slice();
          const optionIndex = getValueIndex(value, option.value);
          if (optionIndex > -1) {
            value.splice(optionIndex, 1);
          } else if (props.multipleLimit <= 0 || value.length < props.multipleLimit) {
            value.push(option.value);
          }
          ctx.emit(UPDATE_MODEL_EVENT, value);
          emitChange(value);
          if (option.created) {
            states.query = "";
            handleQueryChange("");
            states.inputLength = 20;
          }
          if (props.filterable)
            (_a = input.value) == null ? void 0 : _a.focus();
        } else {
          ctx.emit(UPDATE_MODEL_EVENT, option.value);
          emitChange(option.value);
          states.visible = false;
        }
        states.isSilentBlur = byClick;
        setSoftFocus();
        if (states.visible)
          return;
        vue.nextTick(() => {
          scrollToOption(option);
        });
      };
      const getValueIndex = (arr = [], value) => {
        if (!isObject$1(value))
          return arr.indexOf(value);
        const valueKey = props.valueKey;
        let index = -1;
        arr.some((item, i) => {
          if (vue.toRaw(get(item, valueKey)) === get(value, valueKey)) {
            index = i;
            return true;
          }
          return false;
        });
        return index;
      };
      const setSoftFocus = () => {
        states.softFocus = true;
        const _input = input.value || reference.value;
        if (_input) {
          _input == null ? void 0 : _input.focus();
        }
      };
      const scrollToOption = (option) => {
        var _a, _b, _c, _d, _e;
        const targetOption = Array.isArray(option) ? option[0] : option;
        let target = null;
        if (targetOption == null ? void 0 : targetOption.value) {
          const options = optionsArray.value.filter((item) => item.value === targetOption.value);
          if (options.length > 0) {
            target = options[0].$el;
          }
        }
        if (tooltipRef.value && target) {
          const menu = (_d = (_c = (_b = (_a = tooltipRef.value) == null ? void 0 : _a.popperRef) == null ? void 0 : _b.contentRef) == null ? void 0 : _c.querySelector) == null ? void 0 : _d.call(_c, `.${ns.be("dropdown", "wrap")}`);
          if (menu) {
            scrollIntoView(menu, target);
          }
        }
        (_e = scrollbar.value) == null ? void 0 : _e.handleScroll();
      };
      const onOptionCreate = (vm) => {
        states.optionsCount++;
        states.filteredOptionsCount++;
        states.options.set(vm.value, vm);
        states.cachedOptions.set(vm.value, vm);
      };
      const onOptionDestroy = (key, vm) => {
        if (states.options.get(key) === vm) {
          states.optionsCount--;
          states.filteredOptionsCount--;
          states.options.delete(key);
        }
      };
      const resetInputState = (e) => {
        if (e.code !== EVENT_CODE.backspace)
          toggleLastOptionHitState(false);
        states.inputLength = input.value.value.length * 15 + 20;
        resetInputHeight();
      };
      const toggleLastOptionHitState = (hit) => {
        if (!Array.isArray(states.selected))
          return;
        const option = states.selected[states.selected.length - 1];
        if (!option)
          return;
        if (hit === true || hit === false) {
          option.hitState = hit;
          return hit;
        }
        option.hitState = !option.hitState;
        return option.hitState;
      };
      const handleComposition = (event) => {
        const text = event.target.value;
        if (event.type === "compositionend") {
          states.isOnComposition = false;
          vue.nextTick(() => handleQueryChange(text));
        } else {
          const lastCharacter = text[text.length - 1] || "";
          states.isOnComposition = !isKorean(lastCharacter);
        }
      };
      const handleMenuEnter = () => {
        vue.nextTick(() => scrollToOption(states.selected));
      };
      const handleFocus = (event) => {
        if (!states.softFocus) {
          if (props.automaticDropdown || props.filterable) {
            if (props.filterable && !states.visible) {
              states.menuVisibleOnFocus = true;
            }
            states.visible = true;
          }
          ctx.emit("focus", event);
        } else {
          states.softFocus = false;
        }
      };
      const blur = () => {
        var _a;
        states.visible = false;
        (_a = reference.value) == null ? void 0 : _a.blur();
      };
      const handleBlur = (event) => {
        vue.nextTick(() => {
          if (states.isSilentBlur) {
            states.isSilentBlur = false;
          } else {
            ctx.emit("blur", event);
          }
        });
        states.softFocus = false;
      };
      const handleClearClick = (event) => {
        deleteSelected(event);
      };
      const handleClose = () => {
        states.visible = false;
      };
      const handleKeydownEscape = (event) => {
        if (states.visible) {
          event.preventDefault();
          event.stopPropagation();
          states.visible = false;
        }
      };
      const toggleMenu = (e) => {
        var _a;
        if (e && !states.mouseEnter) {
          return;
        }
        if (!selectDisabled.value) {
          if (states.menuVisibleOnFocus) {
            states.menuVisibleOnFocus = false;
          } else {
            if (!tooltipRef.value || !tooltipRef.value.isFocusInsideContent()) {
              states.visible = !states.visible;
            }
          }
          if (states.visible) {
            (_a = input.value || reference.value) == null ? void 0 : _a.focus();
          }
        }
      };
      const selectOption = () => {
        if (!states.visible) {
          toggleMenu();
        } else {
          if (optionsArray.value[states.hoverIndex]) {
            handleOptionSelect(optionsArray.value[states.hoverIndex], void 0);
          }
        }
      };
      const getValueKey = (item) => {
        return isObject$1(item.value) ? get(item.value, props.valueKey) : item.value;
      };
      const optionsAllDisabled = vue.computed(() => optionsArray.value.filter((option) => option.visible).every((option) => option.disabled));
      const navigateOptions = (direction) => {
        if (!states.visible) {
          states.visible = true;
          return;
        }
        if (states.options.size === 0 || states.filteredOptionsCount === 0)
          return;
        if (states.isOnComposition)
          return;
        if (!optionsAllDisabled.value) {
          if (direction === "next") {
            states.hoverIndex++;
            if (states.hoverIndex === states.options.size) {
              states.hoverIndex = 0;
            }
          } else if (direction === "prev") {
            states.hoverIndex--;
            if (states.hoverIndex < 0) {
              states.hoverIndex = states.options.size - 1;
            }
          }
          const option = optionsArray.value[states.hoverIndex];
          if (option.disabled === true || option.states.groupDisabled === true || !option.visible) {
            navigateOptions(direction);
          }
          vue.nextTick(() => scrollToOption(hoverOption.value));
        }
      };
      const handleMouseEnter = () => {
        states.mouseEnter = true;
      };
      const handleMouseLeave = () => {
        states.mouseEnter = false;
      };
      return {
        optionsArray,
        selectSize,
        handleResize,
        debouncedOnInputChange,
        debouncedQueryChange,
        deletePrevTag,
        deleteTag,
        deleteSelected,
        handleOptionSelect,
        scrollToOption,
        readonly,
        resetInputHeight,
        showClose,
        iconComponent,
        iconReverse,
        showNewOption,
        collapseTagSize,
        setSelected,
        managePlaceholder,
        selectDisabled,
        emptyText,
        toggleLastOptionHitState,
        resetInputState,
        handleComposition,
        onOptionCreate,
        onOptionDestroy,
        handleMenuEnter,
        handleFocus,
        blur,
        handleBlur,
        handleClearClick,
        handleClose,
        handleKeydownEscape,
        toggleMenu,
        selectOption,
        getValueKey,
        navigateOptions,
        dropMenuVisible,
        queryChange,
        groupQueryChange,
        reference,
        input,
        tooltipRef,
        tags,
        selectWrapper,
        scrollbar,
        handleMouseEnter,
        handleMouseLeave
      };
    };
  
    const COMPONENT_NAME$9 = "ElSelect";
    const _sfc_main$M = vue.defineComponent({
      name: COMPONENT_NAME$9,
      componentName: COMPONENT_NAME$9,
      components: {
        ElInput,
        ElSelectMenu: ElSelectMenu$1,
        ElOption: Option,
        ElTag,
        ElScrollbar,
        ElTooltip,
        ElIcon
      },
      directives: { ClickOutside },
      props: {
        name: String,
        id: String,
        modelValue: {
          type: [Array, String, Number, Boolean, Object],
          default: void 0
        },
        autocomplete: {
          type: String,
          default: "off"
        },
        automaticDropdown: Boolean,
        size: {
          type: String,
          validator: isValidComponentSize
        },
        effect: {
          type: String,
          default: "light"
        },
        disabled: Boolean,
        clearable: Boolean,
        filterable: Boolean,
        allowCreate: Boolean,
        loading: Boolean,
        popperClass: {
          type: String,
          default: ""
        },
        remote: Boolean,
        loadingText: String,
        noMatchText: String,
        noDataText: String,
        remoteMethod: Function,
        filterMethod: Function,
        multiple: Boolean,
        multipleLimit: {
          type: Number,
          default: 0
        },
        placeholder: {
          type: String
        },
        defaultFirstOption: Boolean,
        reserveKeyword: {
          type: Boolean,
          default: true
        },
        valueKey: {
          type: String,
          default: "value"
        },
        collapseTags: Boolean,
        collapseTagsTooltip: {
          type: Boolean,
          default: false
        },
        teleported: useTooltipContentProps.teleported,
        persistent: {
          type: Boolean,
          default: true
        },
        clearIcon: {
          type: iconPropType,
          default: circle_close_default
        },
        fitInputWidth: {
          type: Boolean,
          default: false
        },
        suffixIcon: {
          type: iconPropType,
          default: arrow_down_default
        },
        tagType: { ...tagProps.type, default: "info" },
        validateEvent: {
          type: Boolean,
          default: true
        },
        remoteShowSuffix: {
          type: Boolean,
          default: false
        },
        suffixTransition: {
          type: Boolean,
          default: true
        },
        placement: {
          type: String,
          values: Ee,
          default: "bottom-start"
        }
      },
      emits: [
        UPDATE_MODEL_EVENT,
        CHANGE_EVENT,
        "remove-tag",
        "clear",
        "visible-change",
        "focus",
        "blur"
      ],
      setup(props, ctx) {
        const nsSelect = useNamespace("select");
        const nsInput = useNamespace("input");
        const { t } = useLocale();
        const states = useSelectStates(props);
        const {
          optionsArray,
          selectSize,
          readonly,
          handleResize,
          collapseTagSize,
          debouncedOnInputChange,
          debouncedQueryChange,
          deletePrevTag,
          deleteTag,
          deleteSelected,
          handleOptionSelect,
          scrollToOption,
          setSelected,
          resetInputHeight,
          managePlaceholder,
          showClose,
          selectDisabled,
          iconComponent,
          iconReverse,
          showNewOption,
          emptyText,
          toggleLastOptionHitState,
          resetInputState,
          handleComposition,
          onOptionCreate,
          onOptionDestroy,
          handleMenuEnter,
          handleFocus,
          blur,
          handleBlur,
          handleClearClick,
          handleClose,
          handleKeydownEscape,
          toggleMenu,
          selectOption,
          getValueKey,
          navigateOptions,
          dropMenuVisible,
          reference,
          input,
          tooltipRef,
          tags,
          selectWrapper,
          scrollbar,
          queryChange,
          groupQueryChange,
          handleMouseEnter,
          handleMouseLeave
        } = useSelect$3(props, states, ctx);
        const { focus } = useFocus(reference);
        const {
          inputWidth,
          selected,
          inputLength,
          filteredOptionsCount,
          visible,
          softFocus,
          selectedLabel,
          hoverIndex,
          query,
          inputHovering,
          currentPlaceholder,
          menuVisibleOnFocus,
          isOnComposition,
          isSilentBlur,
          options,
          cachedOptions,
          optionsCount,
          prefixWidth,
          tagInMultiLine
        } = vue.toRefs(states);
        const wrapperKls = vue.computed(() => {
          const classList = [nsSelect.b()];
          const _selectSize = vue.unref(selectSize);
          if (_selectSize) {
            classList.push(nsSelect.m(_selectSize));
          }
          if (props.disabled) {
            classList.push(nsSelect.m("disabled"));
          }
          return classList;
        });
        const selectTagsStyle = vue.computed(() => ({
          maxWidth: `${vue.unref(inputWidth) - 32}px`,
          width: "100%"
        }));
        const tagTextStyle = vue.computed(() => {
          const maxWidth = vue.unref(inputWidth) > 123 ? vue.unref(inputWidth) - 123 : vue.unref(inputWidth) - 75;
          return { maxWidth: `${maxWidth}px` };
        });
        vue.provide(selectKey, vue.reactive({
          props,
          options,
          optionsArray,
          cachedOptions,
          optionsCount,
          filteredOptionsCount,
          hoverIndex,
          handleOptionSelect,
          onOptionCreate,
          onOptionDestroy,
          selectWrapper,
          selected,
          setSelected,
          queryChange,
          groupQueryChange
        }));
        vue.onMounted(() => {
          states.cachedPlaceHolder = currentPlaceholder.value = props.placeholder || t("el.select.placeholder");
          if (props.multiple && Array.isArray(props.modelValue) && props.modelValue.length > 0) {
            currentPlaceholder.value = "";
          }
          useResizeObserver(selectWrapper, handleResize);
          if (props.remote && props.multiple) {
            resetInputHeight();
          }
          vue.nextTick(() => {
            const refEl = reference.value && reference.value.$el;
            if (!refEl)
              return;
            inputWidth.value = refEl.getBoundingClientRect().width;
            if (ctx.slots.prefix) {
              const prefix = refEl.querySelector(`.${nsInput.e("prefix")}`);
              prefixWidth.value = Math.max(prefix.getBoundingClientRect().width + 5, 30);
            }
          });
          setSelected();
        });
        if (props.multiple && !Array.isArray(props.modelValue)) {
          ctx.emit(UPDATE_MODEL_EVENT, []);
        }
        if (!props.multiple && Array.isArray(props.modelValue)) {
          ctx.emit(UPDATE_MODEL_EVENT, "");
        }
        const popperPaneRef = vue.computed(() => {
          var _a, _b;
          return (_b = (_a = tooltipRef.value) == null ? void 0 : _a.popperRef) == null ? void 0 : _b.contentRef;
        });
        return {
          tagInMultiLine,
          prefixWidth,
          selectSize,
          readonly,
          handleResize,
          collapseTagSize,
          debouncedOnInputChange,
          debouncedQueryChange,
          deletePrevTag,
          deleteTag,
          deleteSelected,
          handleOptionSelect,
          scrollToOption,
          inputWidth,
          selected,
          inputLength,
          filteredOptionsCount,
          visible,
          softFocus,
          selectedLabel,
          hoverIndex,
          query,
          inputHovering,
          currentPlaceholder,
          menuVisibleOnFocus,
          isOnComposition,
          isSilentBlur,
          options,
          resetInputHeight,
          managePlaceholder,
          showClose,
          selectDisabled,
          iconComponent,
          iconReverse,
          showNewOption,
          emptyText,
          toggleLastOptionHitState,
          resetInputState,
          handleComposition,
          handleMenuEnter,
          handleFocus,
          blur,
          handleBlur,
          handleClearClick,
          handleClose,
          handleKeydownEscape,
          toggleMenu,
          selectOption,
          getValueKey,
          navigateOptions,
          dropMenuVisible,
          focus,
          reference,
          input,
          tooltipRef,
          popperPaneRef,
          tags,
          selectWrapper,
          scrollbar,
          wrapperKls,
          selectTagsStyle,
          nsSelect,
          tagTextStyle,
          handleMouseEnter,
          handleMouseLeave
        };
      }
    });
    const _hoisted_1$n = ["disabled", "autocomplete"];
    const _hoisted_2$f = { style: { "height": "100%", "display": "flex", "justify-content": "center", "align-items": "center" } };
    function _sfc_render$9(_ctx, _cache, $props, $setup, $data, $options) {
      const _component_el_tag = vue.resolveComponent("el-tag");
      const _component_el_tooltip = vue.resolveComponent("el-tooltip");
      const _component_el_icon = vue.resolveComponent("el-icon");
      const _component_el_input = vue.resolveComponent("el-input");
      const _component_el_option = vue.resolveComponent("el-option");
      const _component_el_scrollbar = vue.resolveComponent("el-scrollbar");
      const _component_el_select_menu = vue.resolveComponent("el-select-menu");
      const _directive_click_outside = vue.resolveDirective("click-outside");
      return vue.withDirectives((vue.openBlock(), vue.createElementBlock("div", {
        ref: "selectWrapper",
        class: vue.normalizeClass(_ctx.wrapperKls),
        onMouseenter: _cache[22] || (_cache[22] = (...args) => _ctx.handleMouseEnter && _ctx.handleMouseEnter(...args)),
        onMouseleave: _cache[23] || (_cache[23] = (...args) => _ctx.handleMouseLeave && _ctx.handleMouseLeave(...args)),
        onClick: _cache[24] || (_cache[24] = vue.withModifiers((...args) => _ctx.toggleMenu && _ctx.toggleMenu(...args), ["stop"]))
      }, [
        vue.createVNode(_component_el_tooltip, {
          ref: "tooltipRef",
          visible: _ctx.dropMenuVisible,
          placement: _ctx.placement,
          teleported: _ctx.teleported,
          "popper-class": [_ctx.nsSelect.e("popper"), _ctx.popperClass],
          "fallback-placements": ["bottom-start", "top-start", "right", "left"],
          effect: _ctx.effect,
          pure: "",
          trigger: "click",
          transition: `${_ctx.nsSelect.namespace.value}-zoom-in-top`,
          "stop-popper-mouse-event": false,
          "gpu-acceleration": false,
          persistent: _ctx.persistent,
          onShow: _ctx.handleMenuEnter
        }, {
          default: vue.withCtx(() => [
            vue.createElementVNode("div", {
              class: "select-trigger",
              onMouseenter: _cache[20] || (_cache[20] = ($event) => _ctx.inputHovering = true),
              onMouseleave: _cache[21] || (_cache[21] = ($event) => _ctx.inputHovering = false)
            }, [
              _ctx.multiple ? (vue.openBlock(), vue.createElementBlock("div", {
                key: 0,
                ref: "tags",
                class: vue.normalizeClass(_ctx.nsSelect.e("tags")),
                style: vue.normalizeStyle(_ctx.selectTagsStyle)
              }, [
                _ctx.collapseTags && _ctx.selected.length ? (vue.openBlock(), vue.createElementBlock("span", {
                  key: 0,
                  class: vue.normalizeClass([
                    _ctx.nsSelect.b("tags-wrapper"),
                    { "has-prefix": _ctx.prefixWidth && _ctx.selected.length }
                  ])
                }, [
                  vue.createVNode(_component_el_tag, {
                    closable: !_ctx.selectDisabled && !_ctx.selected[0].isDisabled,
                    size: _ctx.collapseTagSize,
                    hit: _ctx.selected[0].hitState,
                    type: _ctx.tagType,
                    "disable-transitions": "",
                    onClose: _cache[0] || (_cache[0] = ($event) => _ctx.deleteTag($event, _ctx.selected[0]))
                  }, {
                    default: vue.withCtx(() => [
                      vue.createElementVNode("span", {
                        class: vue.normalizeClass(_ctx.nsSelect.e("tags-text")),
                        style: vue.normalizeStyle(_ctx.tagTextStyle)
                      }, vue.toDisplayString(_ctx.selected[0].currentLabel), 7)
                    ]),
                    _: 1
                  }, 8, ["closable", "size", "hit", "type"]),
                  _ctx.selected.length > 1 ? (vue.openBlock(), vue.createBlock(_component_el_tag, {
                    key: 0,
                    closable: false,
                    size: _ctx.collapseTagSize,
                    type: _ctx.tagType,
                    "disable-transitions": ""
                  }, {
                    default: vue.withCtx(() => [
                      _ctx.collapseTagsTooltip ? (vue.openBlock(), vue.createBlock(_component_el_tooltip, {
                        key: 0,
                        disabled: _ctx.dropMenuVisible,
                        "fallback-placements": ["bottom", "top", "right", "left"],
                        effect: _ctx.effect,
                        placement: "bottom",
                        teleported: _ctx.teleported
                      }, {
                        default: vue.withCtx(() => [
                          vue.createElementVNode("span", {
                            class: vue.normalizeClass(_ctx.nsSelect.e("tags-text"))
                          }, "+ " + vue.toDisplayString(_ctx.selected.length - 1), 3)
                        ]),
                        content: vue.withCtx(() => [
                          vue.createElementVNode("div", {
                            class: vue.normalizeClass(_ctx.nsSelect.e("collapse-tags"))
                          }, [
                            (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(_ctx.selected.slice(1), (item, idx) => {
                              return vue.openBlock(), vue.createElementBlock("div", {
                                key: idx,
                                class: vue.normalizeClass(_ctx.nsSelect.e("collapse-tag"))
                              }, [
                                (vue.openBlock(), vue.createBlock(_component_el_tag, {
                                  key: _ctx.getValueKey(item),
                                  class: "in-tooltip",
                                  closable: !_ctx.selectDisabled && !item.isDisabled,
                                  size: _ctx.collapseTagSize,
                                  hit: item.hitState,
                                  type: _ctx.tagType,
                                  "disable-transitions": "",
                                  style: { margin: "2px" },
                                  onClose: ($event) => _ctx.deleteTag($event, item)
                                }, {
                                  default: vue.withCtx(() => [
                                    vue.createElementVNode("span", {
                                      class: vue.normalizeClass(_ctx.nsSelect.e("tags-text")),
                                      style: vue.normalizeStyle({
                                        maxWidth: _ctx.inputWidth - 75 + "px"
                                      })
                                    }, vue.toDisplayString(item.currentLabel), 7)
                                  ]),
                                  _: 2
                                }, 1032, ["closable", "size", "hit", "type", "onClose"]))
                              ], 2);
                            }), 128))
                          ], 2)
                        ]),
                        _: 1
                      }, 8, ["disabled", "effect", "teleported"])) : (vue.openBlock(), vue.createElementBlock("span", {
                        key: 1,
                        class: vue.normalizeClass(_ctx.nsSelect.e("tags-text"))
                      }, "+ " + vue.toDisplayString(_ctx.selected.length - 1), 3))
                    ]),
                    _: 1
                  }, 8, ["size", "type"])) : vue.createCommentVNode("v-if", true)
                ], 2)) : vue.createCommentVNode("v-if", true),
                vue.createCommentVNode(" <div> "),
                !_ctx.collapseTags ? (vue.openBlock(), vue.createBlock(vue.Transition, {
                  key: 1,
                  onAfterLeave: _ctx.resetInputHeight
                }, {
                  default: vue.withCtx(() => [
                    vue.createElementVNode("span", {
                      class: vue.normalizeClass([
                        _ctx.nsSelect.b("tags-wrapper"),
                        { "has-prefix": _ctx.prefixWidth && _ctx.selected.length }
                      ])
                    }, [
                      (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(_ctx.selected, (item) => {
                        return vue.openBlock(), vue.createBlock(_component_el_tag, {
                          key: _ctx.getValueKey(item),
                          closable: !_ctx.selectDisabled && !item.isDisabled,
                          size: _ctx.collapseTagSize,
                          hit: item.hitState,
                          type: _ctx.tagType,
                          "disable-transitions": "",
                          onClose: ($event) => _ctx.deleteTag($event, item)
                        }, {
                          default: vue.withCtx(() => [
                            vue.createElementVNode("span", {
                              class: vue.normalizeClass(_ctx.nsSelect.e("tags-text")),
                              style: vue.normalizeStyle({ maxWidth: _ctx.inputWidth - 75 + "px" })
                            }, vue.toDisplayString(item.currentLabel), 7)
                          ]),
                          _: 2
                        }, 1032, ["closable", "size", "hit", "type", "onClose"]);
                      }), 128))
                    ], 2)
                  ]),
                  _: 1
                }, 8, ["onAfterLeave"])) : vue.createCommentVNode("v-if", true),
                vue.createCommentVNode(" </div> "),
                _ctx.filterable ? vue.withDirectives((vue.openBlock(), vue.createElementBlock("input", {
                  key: 2,
                  ref: "input",
                  "onUpdate:modelValue": _cache[1] || (_cache[1] = ($event) => _ctx.query = $event),
                  type: "text",
                  class: vue.normalizeClass([_ctx.nsSelect.e("input"), _ctx.nsSelect.is(_ctx.selectSize)]),
                  disabled: _ctx.selectDisabled,
                  autocomplete: _ctx.autocomplete,
                  style: vue.normalizeStyle({
                    marginLeft: _ctx.prefixWidth && !_ctx.selected.length || _ctx.tagInMultiLine ? `${_ctx.prefixWidth}px` : "",
                    flexGrow: 1,
                    width: `${_ctx.inputLength / (_ctx.inputWidth - 32)}%`,
                    maxWidth: `${_ctx.inputWidth - 42}px`
                  }),
                  onFocus: _cache[2] || (_cache[2] = (...args) => _ctx.handleFocus && _ctx.handleFocus(...args)),
                  onBlur: _cache[3] || (_cache[3] = (...args) => _ctx.handleBlur && _ctx.handleBlur(...args)),
                  onKeyup: _cache[4] || (_cache[4] = (...args) => _ctx.managePlaceholder && _ctx.managePlaceholder(...args)),
                  onKeydown: [
                    _cache[5] || (_cache[5] = (...args) => _ctx.resetInputState && _ctx.resetInputState(...args)),
                    _cache[6] || (_cache[6] = vue.withKeys(vue.withModifiers(($event) => _ctx.navigateOptions("next"), ["prevent"]), ["down"])),
                    _cache[7] || (_cache[7] = vue.withKeys(vue.withModifiers(($event) => _ctx.navigateOptions("prev"), ["prevent"]), ["up"])),
                    _cache[8] || (_cache[8] = vue.withKeys((...args) => _ctx.handleKeydownEscape && _ctx.handleKeydownEscape(...args), ["esc"])),
                    _cache[9] || (_cache[9] = vue.withKeys(vue.withModifiers((...args) => _ctx.selectOption && _ctx.selectOption(...args), ["stop", "prevent"]), ["enter"])),
                    _cache[10] || (_cache[10] = vue.withKeys((...args) => _ctx.deletePrevTag && _ctx.deletePrevTag(...args), ["delete"])),
                    _cache[11] || (_cache[11] = vue.withKeys(($event) => _ctx.visible = false, ["tab"]))
                  ],
                  onCompositionstart: _cache[12] || (_cache[12] = (...args) => _ctx.handleComposition && _ctx.handleComposition(...args)),
                  onCompositionupdate: _cache[13] || (_cache[13] = (...args) => _ctx.handleComposition && _ctx.handleComposition(...args)),
                  onCompositionend: _cache[14] || (_cache[14] = (...args) => _ctx.handleComposition && _ctx.handleComposition(...args)),
                  onInput: _cache[15] || (_cache[15] = (...args) => _ctx.debouncedQueryChange && _ctx.debouncedQueryChange(...args))
                }, null, 46, _hoisted_1$n)), [
                  [vue.vModelText, _ctx.query]
                ]) : vue.createCommentVNode("v-if", true)
              ], 6)) : vue.createCommentVNode("v-if", true),
              vue.createVNode(_component_el_input, {
                id: _ctx.id,
                ref: "reference",
                modelValue: _ctx.selectedLabel,
                "onUpdate:modelValue": _cache[16] || (_cache[16] = ($event) => _ctx.selectedLabel = $event),
                type: "text",
                placeholder: _ctx.currentPlaceholder,
                name: _ctx.name,
                autocomplete: _ctx.autocomplete,
                size: _ctx.selectSize,
                disabled: _ctx.selectDisabled,
                readonly: _ctx.readonly,
                "validate-event": false,
                class: vue.normalizeClass([_ctx.nsSelect.is("focus", _ctx.visible)]),
                tabindex: _ctx.multiple && _ctx.filterable ? -1 : void 0,
                onFocus: _ctx.handleFocus,
                onBlur: _ctx.handleBlur,
                onInput: _ctx.debouncedOnInputChange,
                onPaste: _ctx.debouncedOnInputChange,
                onCompositionstart: _ctx.handleComposition,
                onCompositionupdate: _ctx.handleComposition,
                onCompositionend: _ctx.handleComposition,
                onKeydown: [
                  _cache[17] || (_cache[17] = vue.withKeys(vue.withModifiers(($event) => _ctx.navigateOptions("next"), ["stop", "prevent"]), ["down"])),
                  _cache[18] || (_cache[18] = vue.withKeys(vue.withModifiers(($event) => _ctx.navigateOptions("prev"), ["stop", "prevent"]), ["up"])),
                  vue.withKeys(vue.withModifiers(_ctx.selectOption, ["stop", "prevent"]), ["enter"]),
                  vue.withKeys(_ctx.handleKeydownEscape, ["esc"]),
                  _cache[19] || (_cache[19] = vue.withKeys(($event) => _ctx.visible = false, ["tab"]))
                ]
              }, vue.createSlots({
                suffix: vue.withCtx(() => [
                  _ctx.iconComponent && !_ctx.showClose ? (vue.openBlock(), vue.createBlock(_component_el_icon, {
                    key: 0,
                    class: vue.normalizeClass([_ctx.nsSelect.e("caret"), _ctx.nsSelect.e("icon"), _ctx.iconReverse])
                  }, {
                    default: vue.withCtx(() => [
                      (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(_ctx.iconComponent)))
                    ]),
                    _: 1
                  }, 8, ["class"])) : vue.createCommentVNode("v-if", true),
                  _ctx.showClose && _ctx.clearIcon ? (vue.openBlock(), vue.createBlock(_component_el_icon, {
                    key: 1,
                    class: vue.normalizeClass([_ctx.nsSelect.e("caret"), _ctx.nsSelect.e("icon")]),
                    onClick: _ctx.handleClearClick
                  }, {
                    default: vue.withCtx(() => [
                      (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(_ctx.clearIcon)))
                    ]),
                    _: 1
                  }, 8, ["class", "onClick"])) : vue.createCommentVNode("v-if", true)
                ]),
                _: 2
              }, [
                _ctx.$slots.prefix ? {
                  name: "prefix",
                  fn: vue.withCtx(() => [
                    vue.createElementVNode("div", _hoisted_2$f, [
                      vue.renderSlot(_ctx.$slots, "prefix")
                    ])
                  ])
                } : void 0
              ]), 1032, ["id", "modelValue", "placeholder", "name", "autocomplete", "size", "disabled", "readonly", "class", "tabindex", "onFocus", "onBlur", "onInput", "onPaste", "onCompositionstart", "onCompositionupdate", "onCompositionend", "onKeydown"])
            ], 32)
          ]),
          content: vue.withCtx(() => [
            vue.createVNode(_component_el_select_menu, null, {
              default: vue.withCtx(() => [
                vue.withDirectives(vue.createVNode(_component_el_scrollbar, {
                  ref: "scrollbar",
                  tag: "ul",
                  "wrap-class": _ctx.nsSelect.be("dropdown", "wrap"),
                  "view-class": _ctx.nsSelect.be("dropdown", "list"),
                  class: vue.normalizeClass([
                    _ctx.nsSelect.is("empty", !_ctx.allowCreate && Boolean(_ctx.query) && _ctx.filteredOptionsCount === 0)
                  ])
                }, {
                  default: vue.withCtx(() => [
                    _ctx.showNewOption ? (vue.openBlock(), vue.createBlock(_component_el_option, {
                      key: 0,
                      value: _ctx.query,
                      created: true
                    }, null, 8, ["value"])) : vue.createCommentVNode("v-if", true),
                    vue.renderSlot(_ctx.$slots, "default")
                  ]),
                  _: 3
                }, 8, ["wrap-class", "view-class", "class"]), [
                  [vue.vShow, _ctx.options.size > 0 && !_ctx.loading]
                ]),
                _ctx.emptyText && (!_ctx.allowCreate || _ctx.loading || _ctx.allowCreate && _ctx.options.size === 0) ? (vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: 0 }, [
                  _ctx.$slots.empty ? vue.renderSlot(_ctx.$slots, "empty", { key: 0 }) : (vue.openBlock(), vue.createElementBlock("p", {
                    key: 1,
                    class: vue.normalizeClass(_ctx.nsSelect.be("dropdown", "empty"))
                  }, vue.toDisplayString(_ctx.emptyText), 3))
                ], 64)) : vue.createCommentVNode("v-if", true)
              ]),
              _: 3
            })
          ]),
          _: 3
        }, 8, ["visible", "placement", "teleported", "popper-class", "effect", "transition", "persistent", "onShow"])
      ], 34)), [
        [_directive_click_outside, _ctx.handleClose, _ctx.popperPaneRef]
      ]);
    }
    var Select$1 = /* @__PURE__ */ _export_sfc(_sfc_main$M, [["render", _sfc_render$9], ["__file", "select.vue"]]);
  
    const _sfc_main$L = vue.defineComponent({
      name: "ElOptionGroup",
      componentName: "ElOptionGroup",
      props: {
        label: String,
        disabled: {
          type: Boolean,
          default: false
        }
      },
      setup(props) {
        const ns = useNamespace("select");
        const visible = vue.ref(true);
        const instance = vue.getCurrentInstance();
        const children = vue.ref([]);
        vue.provide(selectGroupKey, vue.reactive({
          ...vue.toRefs(props)
        }));
        const select = vue.inject(selectKey);
        vue.onMounted(() => {
          children.value = flattedChildren(instance.subTree);
        });
        const flattedChildren = (node) => {
          const children2 = [];
          if (Array.isArray(node.children)) {
            node.children.forEach((child) => {
              var _a;
              if (child.type && child.type.name === "ElOption" && child.component && child.component.proxy) {
                children2.push(child.component.proxy);
              } else if ((_a = child.children) == null ? void 0 : _a.length) {
                children2.push(...flattedChildren(child));
              }
            });
          }
          return children2;
        };
        const { groupQueryChange } = vue.toRaw(select);
        vue.watch(groupQueryChange, () => {
          visible.value = children.value.some((option) => option.visible === true);
        }, { flush: "post" });
        return {
          visible,
          ns
        };
      }
    });
    function _sfc_render$8(_ctx, _cache, $props, $setup, $data, $options) {
      return vue.withDirectives((vue.openBlock(), vue.createElementBlock("ul", {
        class: vue.normalizeClass(_ctx.ns.be("group", "wrap"))
      }, [
        vue.createElementVNode("li", {
          class: vue.normalizeClass(_ctx.ns.be("group", "title"))
        }, vue.toDisplayString(_ctx.label), 3),
        vue.createElementVNode("li", null, [
          vue.createElementVNode("ul", {
            class: vue.normalizeClass(_ctx.ns.b("group"))
          }, [
            vue.renderSlot(_ctx.$slots, "default")
          ], 2)
        ])
      ], 2)), [
        [vue.vShow, _ctx.visible]
      ]);
    }
    var OptionGroup = /* @__PURE__ */ _export_sfc(_sfc_main$L, [["render", _sfc_render$8], ["__file", "option-group.vue"]]);
  
    const ElSelect = withInstall(Select$1, {
      Option,
      OptionGroup
    });
    const ElOption = withNoopInstall(Option);
    const ElOptionGroup = withNoopInstall(OptionGroup);
  
    const usePagination = () => vue.inject(elPaginationKey, {});
  
    const paginationSizesProps = buildProps({
      pageSize: {
        type: Number,
        required: true
      },
      pageSizes: {
        type: definePropType(Array),
        default: () => mutable([10, 20, 30, 40, 50, 100])
      },
      popperClass: {
        type: String
      },
      disabled: Boolean,
      size: {
        type: String,
        values: componentSizes
      }
    });
  
    const __default__$A = vue.defineComponent({
      name: "ElPaginationSizes"
    });
    const _sfc_main$K = /* @__PURE__ */ vue.defineComponent({
      ...__default__$A,
      props: paginationSizesProps,
      emits: ["page-size-change"],
      setup(__props, { emit }) {
        const props = __props;
        const { t } = useLocale();
        const ns = useNamespace("pagination");
        const pagination = usePagination();
        const innerPageSize = vue.ref(props.pageSize);
        vue.watch(() => props.pageSizes, (newVal, oldVal) => {
          if (isEqual$1(newVal, oldVal))
            return;
          if (Array.isArray(newVal)) {
            const pageSize = newVal.includes(props.pageSize) ? props.pageSize : props.pageSizes[0];
            emit("page-size-change", pageSize);
          }
        });
        vue.watch(() => props.pageSize, (newVal) => {
          innerPageSize.value = newVal;
        });
        const innerPageSizes = vue.computed(() => props.pageSizes);
        function handleChange(val) {
          var _a;
          if (val !== innerPageSize.value) {
            innerPageSize.value = val;
            (_a = pagination.handleSizeChange) == null ? void 0 : _a.call(pagination, Number(val));
          }
        }
        return (_ctx, _cache) => {
          return vue.openBlock(), vue.createElementBlock("span", {
            class: vue.normalizeClass(vue.unref(ns).e("sizes"))
          }, [
            vue.createVNode(vue.unref(ElSelect), {
              "model-value": innerPageSize.value,
              disabled: _ctx.disabled,
              "popper-class": _ctx.popperClass,
              size: _ctx.size,
              "validate-event": false,
              onChange: handleChange
            }, {
              default: vue.withCtx(() => [
                (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(vue.unref(innerPageSizes), (item) => {
                  return vue.openBlock(), vue.createBlock(vue.unref(ElOption), {
                    key: item,
                    value: item,
                    label: item + vue.unref(t)("el.pagination.pagesize")
                  }, null, 8, ["value", "label"]);
                }), 128))
              ]),
              _: 1
            }, 8, ["model-value", "disabled", "popper-class", "size"])
          ], 2);
        };
      }
    });
    var Sizes = /* @__PURE__ */ _export_sfc(_sfc_main$K, [["__file", "sizes.vue"]]);
  
    const _hoisted_1$m = ["disabled"];
    const __default__$z = vue.defineComponent({
      name: "ElPaginationJumper"
    });
    const _sfc_main$J = /* @__PURE__ */ vue.defineComponent({
      ...__default__$z,
      setup(__props) {
        const { t } = useLocale();
        const ns = useNamespace("pagination");
        const { pageCount, disabled, currentPage, changeEvent } = usePagination();
        const userInput = vue.ref();
        const innerValue = vue.computed(() => {
          var _a;
          return (_a = userInput.value) != null ? _a : currentPage == null ? void 0 : currentPage.value;
        });
        function handleInput(val) {
          userInput.value = +val;
        }
        function handleChange(val) {
          val = Math.trunc(+val);
          changeEvent == null ? void 0 : changeEvent(+val);
          userInput.value = void 0;
        }
        return (_ctx, _cache) => {
          return vue.openBlock(), vue.createElementBlock("span", {
            class: vue.normalizeClass(vue.unref(ns).e("jump")),
            disabled: vue.unref(disabled)
          }, [
            vue.createTextVNode(vue.toDisplayString(vue.unref(t)("el.pagination.goto")) + " ", 1),
            vue.createVNode(vue.unref(ElInput), {
              size: "small",
              class: vue.normalizeClass([vue.unref(ns).e("editor"), vue.unref(ns).is("in-pagination")]),
              min: 1,
              max: vue.unref(pageCount),
              disabled: vue.unref(disabled),
              "model-value": vue.unref(innerValue),
              "validate-event": false,
              type: "number",
              "onUpdate:modelValue": handleInput,
              onChange: handleChange
            }, null, 8, ["class", "max", "disabled", "model-value"]),
            vue.createTextVNode(" " + vue.toDisplayString(vue.unref(t)("el.pagination.pageClassifier")), 1)
          ], 10, _hoisted_1$m);
        };
      }
    });
    var Jumper = /* @__PURE__ */ _export_sfc(_sfc_main$J, [["__file", "jumper.vue"]]);
  
    const paginationTotalProps = buildProps({
      total: {
        type: Number,
        default: 1e3
      }
    });
  
    const _hoisted_1$l = ["disabled"];
    const __default__$y = vue.defineComponent({
      name: "ElPaginationTotal"
    });
    const _sfc_main$I = /* @__PURE__ */ vue.defineComponent({
      ...__default__$y,
      props: paginationTotalProps,
      setup(__props) {
        const { t } = useLocale();
        const ns = useNamespace("pagination");
        const { disabled } = usePagination();
        return (_ctx, _cache) => {
          return vue.openBlock(), vue.createElementBlock("span", {
            class: vue.normalizeClass(vue.unref(ns).e("total")),
            disabled: vue.unref(disabled)
          }, vue.toDisplayString(vue.unref(t)("el.pagination.total", {
            total: _ctx.total
          })), 11, _hoisted_1$l);
        };
      }
    });
    var Total = /* @__PURE__ */ _export_sfc(_sfc_main$I, [["__file", "total.vue"]]);
  
    const paginationPagerProps = buildProps({
      currentPage: {
        type: Number,
        default: 1
      },
      pageCount: {
        type: Number,
        required: true
      },
      pagerCount: {
        type: Number,
        default: 7
      },
      disabled: Boolean
    });
  
    const _hoisted_1$k = ["onKeyup"];
    const _hoisted_2$e = ["aria-current", "tabindex"];
    const _hoisted_3$7 = ["tabindex"];
    const _hoisted_4$5 = ["aria-current", "tabindex"];
    const _hoisted_5$4 = ["tabindex"];
    const _hoisted_6 = ["aria-current", "tabindex"];
    const __default__$x = vue.defineComponent({
      name: "ElPaginationPager"
    });
    const _sfc_main$H = /* @__PURE__ */ vue.defineComponent({
      ...__default__$x,
      props: paginationPagerProps,
      emits: ["change"],
      setup(__props, { emit }) {
        const props = __props;
        const nsPager = useNamespace("pager");
        const nsIcon = useNamespace("icon");
        const showPrevMore = vue.ref(false);
        const showNextMore = vue.ref(false);
        const quickPrevHover = vue.ref(false);
        const quickNextHover = vue.ref(false);
        const quickPrevFocus = vue.ref(false);
        const quickNextFocus = vue.ref(false);
        const pagers = vue.computed(() => {
          const pagerCount = props.pagerCount;
          const halfPagerCount = (pagerCount - 1) / 2;
          const currentPage = Number(props.currentPage);
          const pageCount = Number(props.pageCount);
          let showPrevMore2 = false;
          let showNextMore2 = false;
          if (pageCount > pagerCount) {
            if (currentPage > pagerCount - halfPagerCount) {
              showPrevMore2 = true;
            }
            if (currentPage < pageCount - halfPagerCount) {
              showNextMore2 = true;
            }
          }
          const array = [];
          if (showPrevMore2 && !showNextMore2) {
            const startPage = pageCount - (pagerCount - 2);
            for (let i = startPage; i < pageCount; i++) {
              array.push(i);
            }
          } else if (!showPrevMore2 && showNextMore2) {
            for (let i = 2; i < pagerCount; i++) {
              array.push(i);
            }
          } else if (showPrevMore2 && showNextMore2) {
            const offset = Math.floor(pagerCount / 2) - 1;
            for (let i = currentPage - offset; i <= currentPage + offset; i++) {
              array.push(i);
            }
          } else {
            for (let i = 2; i < pageCount; i++) {
              array.push(i);
            }
          }
          return array;
        });
        const tabindex = vue.computed(() => props.disabled ? -1 : 0);
        vue.watchEffect(() => {
          const halfPagerCount = (props.pagerCount - 1) / 2;
          showPrevMore.value = false;
          showNextMore.value = false;
          if (props.pageCount > props.pagerCount) {
            if (props.currentPage > props.pagerCount - halfPagerCount) {
              showPrevMore.value = true;
            }
            if (props.currentPage < props.pageCount - halfPagerCount) {
              showNextMore.value = true;
            }
          }
        });
        function onMouseEnter(forward = false) {
          if (props.disabled)
            return;
          if (forward) {
            quickPrevHover.value = true;
          } else {
            quickNextHover.value = true;
          }
        }
        function onFocus(forward = false) {
          if (forward) {
            quickPrevFocus.value = true;
          } else {
            quickNextFocus.value = true;
          }
        }
        function onEnter(e) {
          const target = e.target;
          if (target.tagName.toLowerCase() === "li" && Array.from(target.classList).includes("number")) {
            const newPage = Number(target.textContent);
            if (newPage !== props.currentPage) {
              emit("change", newPage);
            }
          } else if (target.tagName.toLowerCase() === "li" && Array.from(target.classList).includes("more")) {
            onPagerClick(e);
          }
        }
        function onPagerClick(event) {
          const target = event.target;
          if (target.tagName.toLowerCase() === "ul" || props.disabled) {
            return;
          }
          let newPage = Number(target.textContent);
          const pageCount = props.pageCount;
          const currentPage = props.currentPage;
          const pagerCountOffset = props.pagerCount - 2;
          if (target.className.includes("more")) {
            if (target.className.includes("quickprev")) {
              newPage = currentPage - pagerCountOffset;
            } else if (target.className.includes("quicknext")) {
              newPage = currentPage + pagerCountOffset;
            }
          }
          if (!Number.isNaN(+newPage)) {
            if (newPage < 1) {
              newPage = 1;
            }
            if (newPage > pageCount) {
              newPage = pageCount;
            }
          }
          if (newPage !== currentPage) {
            emit("change", newPage);
          }
        }
        return (_ctx, _cache) => {
          return vue.openBlock(), vue.createElementBlock("ul", {
            class: vue.normalizeClass(vue.unref(nsPager).b()),
            onClick: onPagerClick,
            onKeyup: vue.withKeys(onEnter, ["enter"])
          }, [
            _ctx.pageCount > 0 ? (vue.openBlock(), vue.createElementBlock("li", {
              key: 0,
              class: vue.normalizeClass([[
                vue.unref(nsPager).is("active", _ctx.currentPage === 1),
                vue.unref(nsPager).is("disabled", _ctx.disabled)
              ], "number"]),
              "aria-current": _ctx.currentPage === 1,
              tabindex: vue.unref(tabindex)
            }, " 1 ", 10, _hoisted_2$e)) : vue.createCommentVNode("v-if", true),
            showPrevMore.value ? (vue.openBlock(), vue.createElementBlock("li", {
              key: 1,
              class: vue.normalizeClass([
                "more",
                "btn-quickprev",
                vue.unref(nsIcon).b(),
                vue.unref(nsPager).is("disabled", _ctx.disabled)
              ]),
              tabindex: vue.unref(tabindex),
              onMouseenter: _cache[0] || (_cache[0] = ($event) => onMouseEnter(true)),
              onMouseleave: _cache[1] || (_cache[1] = ($event) => quickPrevHover.value = false),
              onFocus: _cache[2] || (_cache[2] = ($event) => onFocus(true)),
              onBlur: _cache[3] || (_cache[3] = ($event) => quickPrevFocus.value = false)
            }, [
              quickPrevHover.value || quickPrevFocus.value ? (vue.openBlock(), vue.createBlock(vue.unref(d_arrow_left_default), { key: 0 })) : (vue.openBlock(), vue.createBlock(vue.unref(more_filled_default), { key: 1 }))
            ], 42, _hoisted_3$7)) : vue.createCommentVNode("v-if", true),
            (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(vue.unref(pagers), (pager) => {
              return vue.openBlock(), vue.createElementBlock("li", {
                key: pager,
                class: vue.normalizeClass([[
                  vue.unref(nsPager).is("active", _ctx.currentPage === pager),
                  vue.unref(nsPager).is("disabled", _ctx.disabled)
                ], "number"]),
                "aria-current": _ctx.currentPage === pager,
                tabindex: vue.unref(tabindex)
              }, vue.toDisplayString(pager), 11, _hoisted_4$5);
            }), 128)),
            showNextMore.value ? (vue.openBlock(), vue.createElementBlock("li", {
              key: 2,
              class: vue.normalizeClass([
                "more",
                "btn-quicknext",
                vue.unref(nsIcon).b(),
                vue.unref(nsPager).is("disabled", _ctx.disabled)
              ]),
              tabindex: vue.unref(tabindex),
              onMouseenter: _cache[4] || (_cache[4] = ($event) => onMouseEnter()),
              onMouseleave: _cache[5] || (_cache[5] = ($event) => quickNextHover.value = false),
              onFocus: _cache[6] || (_cache[6] = ($event) => onFocus()),
              onBlur: _cache[7] || (_cache[7] = ($event) => quickNextFocus.value = false)
            }, [
              quickNextHover.value || quickNextFocus.value ? (vue.openBlock(), vue.createBlock(vue.unref(d_arrow_right_default), { key: 0 })) : (vue.openBlock(), vue.createBlock(vue.unref(more_filled_default), { key: 1 }))
            ], 42, _hoisted_5$4)) : vue.createCommentVNode("v-if", true),
            _ctx.pageCount > 1 ? (vue.openBlock(), vue.createElementBlock("li", {
              key: 3,
              class: vue.normalizeClass([[
                vue.unref(nsPager).is("active", _ctx.currentPage === _ctx.pageCount),
                vue.unref(nsPager).is("disabled", _ctx.disabled)
              ], "number"]),
              "aria-current": _ctx.currentPage === _ctx.pageCount,
              tabindex: vue.unref(tabindex)
            }, vue.toDisplayString(_ctx.pageCount), 11, _hoisted_6)) : vue.createCommentVNode("v-if", true)
          ], 42, _hoisted_1$k);
        };
      }
    });
    var Pager = /* @__PURE__ */ _export_sfc(_sfc_main$H, [["__file", "pager.vue"]]);
  
    const isAbsent = (v) => typeof v !== "number";
    const paginationProps = buildProps({
      total: Number,
      pageSize: Number,
      defaultPageSize: Number,
      currentPage: Number,
      defaultCurrentPage: Number,
      pageCount: Number,
      pagerCount: {
        type: Number,
        validator: (value) => {
          return typeof value === "number" && Math.trunc(value) === value && value > 4 && value < 22 && value % 2 === 1;
        },
        default: 7
      },
      layout: {
        type: String,
        default: ["prev", "pager", "next", "jumper", "->", "total"].join(", ")
      },
      pageSizes: {
        type: definePropType(Array),
        default: () => mutable([10, 20, 30, 40, 50, 100])
      },
      popperClass: {
        type: String,
        default: ""
      },
      prevText: {
        type: String,
        default: ""
      },
      prevIcon: {
        type: iconPropType,
        default: () => arrow_left_default
      },
      nextText: {
        type: String,
        default: ""
      },
      nextIcon: {
        type: iconPropType,
        default: () => arrow_right_default
      },
      small: Boolean,
      background: Boolean,
      disabled: Boolean,
      hideOnSinglePage: Boolean
    });
    const paginationEmits = {
      "update:current-page": (val) => typeof val === "number",
      "update:page-size": (val) => typeof val === "number",
      "size-change": (val) => typeof val === "number",
      "current-change": (val) => typeof val === "number",
      "prev-click": (val) => typeof val === "number",
      "next-click": (val) => typeof val === "number"
    };
    const componentName = "ElPagination";
    var Pagination = vue.defineComponent({
      name: componentName,
      props: paginationProps,
      emits: paginationEmits,
      setup(props, { emit, slots }) {
        const { t } = useLocale();
        const ns = useNamespace("pagination");
        const vnodeProps = vue.getCurrentInstance().vnode.props || {};
        const hasCurrentPageListener = "onUpdate:currentPage" in vnodeProps || "onUpdate:current-page" in vnodeProps || "onCurrentChange" in vnodeProps;
        const hasPageSizeListener = "onUpdate:pageSize" in vnodeProps || "onUpdate:page-size" in vnodeProps || "onSizeChange" in vnodeProps;
        const assertValidUsage = vue.computed(() => {
          if (isAbsent(props.total) && isAbsent(props.pageCount))
            return false;
          if (!isAbsent(props.currentPage) && !hasCurrentPageListener)
            return false;
          if (props.layout.includes("sizes")) {
            if (!isAbsent(props.pageCount)) {
              if (!hasPageSizeListener)
                return false;
            } else if (!isAbsent(props.total)) {
              if (!isAbsent(props.pageSize)) {
                if (!hasPageSizeListener) {
                  return false;
                }
              }
            }
          }
          return true;
        });
        const innerPageSize = vue.ref(isAbsent(props.defaultPageSize) ? 10 : props.defaultPageSize);
        const innerCurrentPage = vue.ref(isAbsent(props.defaultCurrentPage) ? 1 : props.defaultCurrentPage);
        const pageSizeBridge = vue.computed({
          get() {
            return isAbsent(props.pageSize) ? innerPageSize.value : props.pageSize;
          },
          set(v) {
            if (isAbsent(props.pageSize)) {
              innerPageSize.value = v;
            }
            if (hasPageSizeListener) {
              emit("update:page-size", v);
              emit("size-change", v);
            }
          }
        });
        const pageCountBridge = vue.computed(() => {
          let pageCount = 0;
          if (!isAbsent(props.pageCount)) {
            pageCount = props.pageCount;
          } else if (!isAbsent(props.total)) {
            pageCount = Math.max(1, Math.ceil(props.total / pageSizeBridge.value));
          }
          return pageCount;
        });
        const currentPageBridge = vue.computed({
          get() {
            return isAbsent(props.currentPage) ? innerCurrentPage.value : props.currentPage;
          },
          set(v) {
            let newCurrentPage = v;
            if (v < 1) {
              newCurrentPage = 1;
            } else if (v > pageCountBridge.value) {
              newCurrentPage = pageCountBridge.value;
            }
            if (isAbsent(props.currentPage)) {
              innerCurrentPage.value = newCurrentPage;
            }
            if (hasCurrentPageListener) {
              emit("update:current-page", newCurrentPage);
              emit("current-change", newCurrentPage);
            }
          }
        });
        vue.watch(pageCountBridge, (val) => {
          if (currentPageBridge.value > val)
            currentPageBridge.value = val;
        });
        function handleCurrentChange(val) {
          currentPageBridge.value = val;
        }
        function handleSizeChange(val) {
          pageSizeBridge.value = val;
          const newPageCount = pageCountBridge.value;
          if (currentPageBridge.value > newPageCount) {
            currentPageBridge.value = newPageCount;
          }
        }
        function prev() {
          if (props.disabled)
            return;
          currentPageBridge.value -= 1;
          emit("prev-click", currentPageBridge.value);
        }
        function next() {
          if (props.disabled)
            return;
          currentPageBridge.value += 1;
          emit("next-click", currentPageBridge.value);
        }
        function addClass(element, cls) {
          if (element) {
            if (!element.props) {
              element.props = {};
            }
            element.props.class = [element.props.class, cls].join(" ");
          }
        }
        vue.provide(elPaginationKey, {
          pageCount: pageCountBridge,
          disabled: vue.computed(() => props.disabled),
          currentPage: currentPageBridge,
          changeEvent: handleCurrentChange,
          handleSizeChange
        });
        return () => {
          var _a, _b;
          if (!assertValidUsage.value) {
            debugWarn(componentName, t("el.pagination.deprecationWarning"));
            return null;
          }
          if (!props.layout)
            return null;
          if (props.hideOnSinglePage && pageCountBridge.value <= 1)
            return null;
          const rootChildren = [];
          const rightWrapperChildren = [];
          const rightWrapperRoot = vue.h("div", { class: ns.e("rightwrapper") }, rightWrapperChildren);
          const TEMPLATE_MAP = {
            prev: vue.h(Prev, {
              disabled: props.disabled,
              currentPage: currentPageBridge.value,
              prevText: props.prevText,
              prevIcon: props.prevIcon,
              onClick: prev
            }),
            jumper: vue.h(Jumper),
            pager: vue.h(Pager, {
              currentPage: currentPageBridge.value,
              pageCount: pageCountBridge.value,
              pagerCount: props.pagerCount,
              onChange: handleCurrentChange,
              disabled: props.disabled
            }),
            next: vue.h(Next, {
              disabled: props.disabled,
              currentPage: currentPageBridge.value,
              pageCount: pageCountBridge.value,
              nextText: props.nextText,
              nextIcon: props.nextIcon,
              onClick: next
            }),
            sizes: vue.h(Sizes, {
              pageSize: pageSizeBridge.value,
              pageSizes: props.pageSizes,
              popperClass: props.popperClass,
              disabled: props.disabled,
              size: props.small ? "small" : "default"
            }),
            slot: (_b = (_a = slots == null ? void 0 : slots.default) == null ? void 0 : _a.call(slots)) != null ? _b : null,
            total: vue.h(Total, { total: isAbsent(props.total) ? 0 : props.total })
          };
          const components = props.layout.split(",").map((item) => item.trim());
          let haveRightWrapper = false;
          components.forEach((c) => {
            if (c === "->") {
              haveRightWrapper = true;
              return;
            }
            if (!haveRightWrapper) {
              rootChildren.push(TEMPLATE_MAP[c]);
            } else {
              rightWrapperChildren.push(TEMPLATE_MAP[c]);
            }
          });
          addClass(rootChildren[0], ns.is("first"));
          addClass(rootChildren[rootChildren.length - 1], ns.is("last"));
          if (haveRightWrapper && rightWrapperChildren.length > 0) {
            addClass(rightWrapperChildren[0], ns.is("first"));
            addClass(rightWrapperChildren[rightWrapperChildren.length - 1], ns.is("last"));
            rootChildren.push(rightWrapperRoot);
          }
          return vue.h("div", {
            role: "pagination",
            "aria-label": "pagination",
            class: [
              ns.b(),
              ns.is("background", props.background),
              {
                [ns.m("small")]: props.small
              }
            ]
          }, rootChildren);
        };
      }
    });
  
    const ElPagination = withInstall(Pagination);
  
    const popconfirmProps = buildProps({
      title: String,
      confirmButtonText: String,
      cancelButtonText: String,
      confirmButtonType: {
        type: String,
        values: buttonTypes,
        default: "primary"
      },
      cancelButtonType: {
        type: String,
        values: buttonTypes,
        default: "text"
      },
      icon: {
        type: iconPropType,
        default: () => question_filled_default
      },
      iconColor: {
        type: String,
        default: "#f90"
      },
      hideIcon: {
        type: Boolean,
        default: false
      },
      hideAfter: {
        type: Number,
        default: 200
      },
      onConfirm: {
        type: definePropType(Function)
      },
      onCancel: {
        type: definePropType(Function)
      },
      teleported: useTooltipContentProps.teleported,
      persistent: useTooltipContentProps.persistent,
      width: {
        type: [String, Number],
        default: 150
      }
    });
  
    const __default__$w = vue.defineComponent({
      name: "ElPopconfirm"
    });
    const _sfc_main$G = /* @__PURE__ */ vue.defineComponent({
      ...__default__$w,
      props: popconfirmProps,
      setup(__props) {
        const props = __props;
        const { t } = useLocale();
        const ns = useNamespace("popconfirm");
        const tooltipRef = vue.ref();
        const hidePopper = () => {
          var _a, _b;
          (_b = (_a = tooltipRef.value) == null ? void 0 : _a.onClose) == null ? void 0 : _b.call(_a);
        };
        const style = vue.computed(() => {
          return {
            width: addUnit(props.width)
          };
        });
        const confirm = (e) => {
          var _a;
          (_a = props.onConfirm) == null ? void 0 : _a.call(props, e);
          hidePopper();
        };
        const cancel = (e) => {
          var _a;
          (_a = props.onCancel) == null ? void 0 : _a.call(props, e);
          hidePopper();
        };
        const finalConfirmButtonText = vue.computed(() => props.confirmButtonText || t("el.popconfirm.confirmButtonText"));
        const finalCancelButtonText = vue.computed(() => props.cancelButtonText || t("el.popconfirm.cancelButtonText"));
        return (_ctx, _cache) => {
          return vue.openBlock(), vue.createBlock(vue.unref(ElTooltip), vue.mergeProps({
            ref_key: "tooltipRef",
            ref: tooltipRef,
            trigger: "click",
            effect: "light"
          }, _ctx.$attrs, {
            "popper-class": `${vue.unref(ns).namespace.value}-popover`,
            "popper-style": vue.unref(style),
            teleported: _ctx.teleported,
            "fallback-placements": ["bottom", "top", "right", "left"],
            "hide-after": _ctx.hideAfter,
            persistent: _ctx.persistent
          }), {
            content: vue.withCtx(() => [
              vue.createElementVNode("div", {
                class: vue.normalizeClass(vue.unref(ns).b())
              }, [
                vue.createElementVNode("div", {
                  class: vue.normalizeClass(vue.unref(ns).e("main"))
                }, [
                  !_ctx.hideIcon && _ctx.icon ? (vue.openBlock(), vue.createBlock(vue.unref(ElIcon), {
                    key: 0,
                    class: vue.normalizeClass(vue.unref(ns).e("icon")),
                    style: vue.normalizeStyle({ color: _ctx.iconColor })
                  }, {
                    default: vue.withCtx(() => [
                      (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(_ctx.icon)))
                    ]),
                    _: 1
                  }, 8, ["class", "style"])) : vue.createCommentVNode("v-if", true),
                  vue.createTextVNode(" " + vue.toDisplayString(_ctx.title), 1)
                ], 2),
                vue.createElementVNode("div", {
                  class: vue.normalizeClass(vue.unref(ns).e("action"))
                }, [
                  vue.createVNode(vue.unref(ElButton), {
                    size: "small",
                    type: _ctx.cancelButtonType === "text" ? "" : _ctx.cancelButtonType,
                    text: _ctx.cancelButtonType === "text",
                    onClick: cancel
                  }, {
                    default: vue.withCtx(() => [
                      vue.createTextVNode(vue.toDisplayString(vue.unref(finalCancelButtonText)), 1)
                    ]),
                    _: 1
                  }, 8, ["type", "text"]),
                  vue.createVNode(vue.unref(ElButton), {
                    size: "small",
                    type: _ctx.confirmButtonType === "text" ? "" : _ctx.confirmButtonType,
                    text: _ctx.confirmButtonType === "text",
                    onClick: confirm
                  }, {
                    default: vue.withCtx(() => [
                      vue.createTextVNode(vue.toDisplayString(vue.unref(finalConfirmButtonText)), 1)
                    ]),
                    _: 1
                  }, 8, ["type", "text"])
                ], 2)
              ], 2)
            ]),
            default: vue.withCtx(() => [
              _ctx.$slots.reference ? vue.renderSlot(_ctx.$slots, "reference", { key: 0 }) : vue.createCommentVNode("v-if", true)
            ]),
            _: 3
          }, 16, ["popper-class", "popper-style", "teleported", "hide-after", "persistent"]);
        };
      }
    });
    var Popconfirm = /* @__PURE__ */ _export_sfc(_sfc_main$G, [["__file", "popconfirm.vue"]]);
  
    const ElPopconfirm = withInstall(Popconfirm);
  
    const popoverProps = buildProps({
      trigger: useTooltipTriggerProps.trigger,
      placement: dropdownProps.placement,
      disabled: useTooltipTriggerProps.disabled,
      visible: useTooltipContentProps.visible,
      transition: useTooltipContentProps.transition,
      popperOptions: dropdownProps.popperOptions,
      tabindex: dropdownProps.tabindex,
      content: useTooltipContentProps.content,
      popperStyle: useTooltipContentProps.popperStyle,
      popperClass: useTooltipContentProps.popperClass,
      enterable: {
        ...useTooltipContentProps.enterable,
        default: true
      },
      effect: {
        ...useTooltipContentProps.effect,
        default: "light"
      },
      teleported: useTooltipContentProps.teleported,
      title: String,
      width: {
        type: [String, Number],
        default: 150
      },
      offset: {
        type: Number,
        default: void 0
      },
      showAfter: {
        type: Number,
        default: 0
      },
      hideAfter: {
        type: Number,
        default: 200
      },
      autoClose: {
        type: Number,
        default: 0
      },
      showArrow: {
        type: Boolean,
        default: true
      },
      persistent: {
        type: Boolean,
        default: true
      },
      "onUpdate:visible": {
        type: Function
      }
    });
    const popoverEmits = {
      "update:visible": (value) => isBoolean(value),
      "before-enter": () => true,
      "before-leave": () => true,
      "after-enter": () => true,
      "after-leave": () => true
    };
  
    const updateEventKeyRaw = `onUpdate:visible`;
    const __default__$v = vue.defineComponent({
      name: "ElPopover"
    });
    const _sfc_main$F = /* @__PURE__ */ vue.defineComponent({
      ...__default__$v,
      props: popoverProps,
      emits: popoverEmits,
      setup(__props, { expose, emit }) {
        const props = __props;
        const onUpdateVisible = vue.computed(() => {
          return props[updateEventKeyRaw];
        });
        const ns = useNamespace("popover");
        const tooltipRef = vue.ref();
        const popperRef = vue.computed(() => {
          var _a;
          return (_a = vue.unref(tooltipRef)) == null ? void 0 : _a.popperRef;
        });
        const style = vue.computed(() => {
          return [
            {
              width: addUnit(props.width)
            },
            props.popperStyle
          ];
        });
        const kls = vue.computed(() => {
          return [ns.b(), props.popperClass, { [ns.m("plain")]: !!props.content }];
        });
        const gpuAcceleration = vue.computed(() => {
          return props.transition === `${ns.namespace.value}-fade-in-linear`;
        });
        const hide = () => {
          var _a;
          (_a = tooltipRef.value) == null ? void 0 : _a.hide();
        };
        const beforeEnter = () => {
          emit("before-enter");
        };
        const beforeLeave = () => {
          emit("before-leave");
        };
        const afterEnter = () => {
          emit("after-enter");
        };
        const afterLeave = () => {
          emit("update:visible", false);
          emit("after-leave");
        };
        expose({
          popperRef,
          hide
        });
        return (_ctx, _cache) => {
          return vue.openBlock(), vue.createBlock(vue.unref(ElTooltip), vue.mergeProps({
            ref_key: "tooltipRef",
            ref: tooltipRef
          }, _ctx.$attrs, {
            trigger: _ctx.trigger,
            placement: _ctx.placement,
            disabled: _ctx.disabled,
            visible: _ctx.visible,
            transition: _ctx.transition,
            "popper-options": _ctx.popperOptions,
            tabindex: _ctx.tabindex,
            content: _ctx.content,
            offset: _ctx.offset,
            "show-after": _ctx.showAfter,
            "hide-after": _ctx.hideAfter,
            "auto-close": _ctx.autoClose,
            "show-arrow": _ctx.showArrow,
            "aria-label": _ctx.title,
            effect: _ctx.effect,
            enterable: _ctx.enterable,
            "popper-class": vue.unref(kls),
            "popper-style": vue.unref(style),
            teleported: _ctx.teleported,
            persistent: _ctx.persistent,
            "gpu-acceleration": vue.unref(gpuAcceleration),
            "onUpdate:visible": vue.unref(onUpdateVisible),
            onBeforeShow: beforeEnter,
            onBeforeHide: beforeLeave,
            onShow: afterEnter,
            onHide: afterLeave
          }), {
            content: vue.withCtx(() => [
              _ctx.title ? (vue.openBlock(), vue.createElementBlock("div", {
                key: 0,
                class: vue.normalizeClass(vue.unref(ns).e("title")),
                role: "title"
              }, vue.toDisplayString(_ctx.title), 3)) : vue.createCommentVNode("v-if", true),
              vue.renderSlot(_ctx.$slots, "default", {}, () => [
                vue.createTextVNode(vue.toDisplayString(_ctx.content), 1)
              ])
            ]),
            default: vue.withCtx(() => [
              _ctx.$slots.reference ? vue.renderSlot(_ctx.$slots, "reference", { key: 0 }) : vue.createCommentVNode("v-if", true)
            ]),
            _: 3
          }, 16, ["trigger", "placement", "disabled", "visible", "transition", "popper-options", "tabindex", "content", "offset", "show-after", "hide-after", "auto-close", "show-arrow", "aria-label", "effect", "enterable", "popper-class", "popper-style", "teleported", "persistent", "gpu-acceleration", "onUpdate:visible"]);
        };
      }
    });
    var Popover = /* @__PURE__ */ _export_sfc(_sfc_main$F, [["__file", "popover.vue"]]);
  
    const attachEvents = (el, binding) => {
      const popperComponent = binding.arg || binding.value;
      const popover = popperComponent == null ? void 0 : popperComponent.popperRef;
      if (popover) {
        popover.triggerRef = el;
      }
    };
    var PopoverDirective = {
      mounted(el, binding) {
        attachEvents(el, binding);
      },
      updated(el, binding) {
        attachEvents(el, binding);
      }
    };
    const VPopover = "popover";
  
    const ElPopoverDirective = withInstallDirective(PopoverDirective, VPopover);
    const ElPopover = withInstall(Popover, {
      directive: ElPopoverDirective
    });
  
    const progressProps = buildProps({
      type: {
        type: String,
        default: "line",
        values: ["line", "circle", "dashboard"]
      },
      percentage: {
        type: Number,
        default: 0,
        validator: (val) => val >= 0 && val <= 100
      },
      status: {
        type: String,
        default: "",
        values: ["", "success", "exception", "warning"]
      },
      indeterminate: {
        type: Boolean,
        default: false
      },
      duration: {
        type: Number,
        default: 3
      },
      strokeWidth: {
        type: Number,
        default: 6
      },
      strokeLinecap: {
        type: definePropType(String),
        default: "round"
      },
      textInside: {
        type: Boolean,
        default: false
      },
      width: {
        type: Number,
        default: 126
      },
      showText: {
        type: Boolean,
        default: true
      },
      color: {
        type: definePropType([
          String,
          Array,
          Function
        ]),
        default: ""
      },
      format: {
        type: definePropType(Function),
        default: (percentage) => `${percentage}%`
      }
    });
  
    const _hoisted_1$j = ["aria-valuenow"];
    const _hoisted_2$d = { viewBox: "0 0 100 100" };
    const _hoisted_3$6 = ["d", "stroke", "stroke-width"];
    const _hoisted_4$4 = ["d", "stroke", "opacity", "stroke-linecap", "stroke-width"];
    const _hoisted_5$3 = { key: 0 };
    const __default__$u = vue.defineComponent({
      name: "ElProgress"
    });
    const _sfc_main$E = /* @__PURE__ */ vue.defineComponent({
      ...__default__$u,
      props: progressProps,
      setup(__props) {
        const props = __props;
        const STATUS_COLOR_MAP = {
          success: "#13ce66",
          exception: "#ff4949",
          warning: "#e6a23c",
          default: "#20a0ff"
        };
        const ns = useNamespace("progress");
        const barStyle = vue.computed(() => ({
          width: `${props.percentage}%`,
          animationDuration: `${props.duration}s`,
          backgroundColor: getCurrentColor(props.percentage)
        }));
        const relativeStrokeWidth = vue.computed(() => (props.strokeWidth / props.width * 100).toFixed(1));
        const radius = vue.computed(() => {
          if (["circle", "dashboard"].includes(props.type)) {
            return Number.parseInt(`${50 - Number.parseFloat(relativeStrokeWidth.value) / 2}`, 10);
          }
          return 0;
        });
        const trackPath = vue.computed(() => {
          const r = radius.value;
          const isDashboard = props.type === "dashboard";
          return `
            M 50 50
            m 0 ${isDashboard ? "" : "-"}${r}
            a ${r} ${r} 0 1 1 0 ${isDashboard ? "-" : ""}${r * 2}
            a ${r} ${r} 0 1 1 0 ${isDashboard ? "" : "-"}${r * 2}
            `;
        });
        const perimeter = vue.computed(() => 2 * Math.PI * radius.value);
        const rate = vue.computed(() => props.type === "dashboard" ? 0.75 : 1);
        const strokeDashoffset = vue.computed(() => {
          const offset = -1 * perimeter.value * (1 - rate.value) / 2;
          return `${offset}px`;
        });
        const trailPathStyle = vue.computed(() => ({
          strokeDasharray: `${perimeter.value * rate.value}px, ${perimeter.value}px`,
          strokeDashoffset: strokeDashoffset.value
        }));
        const circlePathStyle = vue.computed(() => ({
          strokeDasharray: `${perimeter.value * rate.value * (props.percentage / 100)}px, ${perimeter.value}px`,
          strokeDashoffset: strokeDashoffset.value,
          transition: "stroke-dasharray 0.6s ease 0s, stroke 0.6s ease, opacity ease 0.6s"
        }));
        const stroke = vue.computed(() => {
          let ret;
          if (props.color) {
            ret = getCurrentColor(props.percentage);
          } else {
            ret = STATUS_COLOR_MAP[props.status] || STATUS_COLOR_MAP.default;
          }
          return ret;
        });
        const statusIcon = vue.computed(() => {
          if (props.status === "warning") {
            return warning_filled_default;
          }
          if (props.type === "line") {
            return props.status === "success" ? circle_check_default : circle_close_default;
          } else {
            return props.status === "success" ? check_default : close_default;
          }
        });
        const progressTextSize = vue.computed(() => {
          return props.type === "line" ? 12 + props.strokeWidth * 0.4 : props.width * 0.111111 + 2;
        });
        const content = vue.computed(() => props.format(props.percentage));
        function getColors(color) {
          const span = 100 / color.length;
          const seriesColors = color.map((seriesColor, index) => {
            if (isString(seriesColor)) {
              return {
                color: seriesColor,
                percentage: (index + 1) * span
              };
            }
            return seriesColor;
          });
          return seriesColors.sort((a, b) => a.percentage - b.percentage);
        }
        const getCurrentColor = (percentage) => {
          var _a;
          const { color } = props;
          if (isFunction(color)) {
            return color(percentage);
          } else if (isString(color)) {
            return color;
          } else {
            const colors = getColors(color);
            for (const color2 of colors) {
              if (color2.percentage > percentage)
                return color2.color;
            }
            return (_a = colors[colors.length - 1]) == null ? void 0 : _a.color;
          }
        };
        return (_ctx, _cache) => {
          return vue.openBlock(), vue.createElementBlock("div", {
            class: vue.normalizeClass([
              vue.unref(ns).b(),
              vue.unref(ns).m(_ctx.type),
              vue.unref(ns).is(_ctx.status),
              {
                [vue.unref(ns).m("without-text")]: !_ctx.showText,
                [vue.unref(ns).m("text-inside")]: _ctx.textInside
              }
            ]),
            role: "progressbar",
            "aria-valuenow": _ctx.percentage,
            "aria-valuemin": "0",
            "aria-valuemax": "100"
          }, [
            _ctx.type === "line" ? (vue.openBlock(), vue.createElementBlock("div", {
              key: 0,
              class: vue.normalizeClass(vue.unref(ns).b("bar"))
            }, [
              vue.createElementVNode("div", {
                class: vue.normalizeClass(vue.unref(ns).be("bar", "outer")),
                style: vue.normalizeStyle({ height: `${_ctx.strokeWidth}px` })
              }, [
                vue.createElementVNode("div", {
                  class: vue.normalizeClass([
                    vue.unref(ns).be("bar", "inner"),
                    { [vue.unref(ns).bem("bar", "inner", "indeterminate")]: _ctx.indeterminate }
                  ]),
                  style: vue.normalizeStyle(vue.unref(barStyle))
                }, [
                  (_ctx.showText || _ctx.$slots.default) && _ctx.textInside ? (vue.openBlock(), vue.createElementBlock("div", {
                    key: 0,
                    class: vue.normalizeClass(vue.unref(ns).be("bar", "innerText"))
                  }, [
                    vue.renderSlot(_ctx.$slots, "default", { percentage: _ctx.percentage }, () => [
                      vue.createElementVNode("span", null, vue.toDisplayString(vue.unref(content)), 1)
                    ])
                  ], 2)) : vue.createCommentVNode("v-if", true)
                ], 6)
              ], 6)
            ], 2)) : (vue.openBlock(), vue.createElementBlock("div", {
              key: 1,
              class: vue.normalizeClass(vue.unref(ns).b("circle")),
              style: vue.normalizeStyle({ height: `${_ctx.width}px`, width: `${_ctx.width}px` })
            }, [
              (vue.openBlock(), vue.createElementBlock("svg", _hoisted_2$d, [
                vue.createElementVNode("path", {
                  class: vue.normalizeClass(vue.unref(ns).be("circle", "track")),
                  d: vue.unref(trackPath),
                  stroke: `var(${vue.unref(ns).cssVarName("fill-color-light")}, #e5e9f2)`,
                  "stroke-width": vue.unref(relativeStrokeWidth),
                  fill: "none",
                  style: vue.normalizeStyle(vue.unref(trailPathStyle))
                }, null, 14, _hoisted_3$6),
                vue.createElementVNode("path", {
                  class: vue.normalizeClass(vue.unref(ns).be("circle", "path")),
                  d: vue.unref(trackPath),
                  stroke: vue.unref(stroke),
                  fill: "none",
                  opacity: _ctx.percentage ? 1 : 0,
                  "stroke-linecap": _ctx.strokeLinecap,
                  "stroke-width": vue.unref(relativeStrokeWidth),
                  style: vue.normalizeStyle(vue.unref(circlePathStyle))
                }, null, 14, _hoisted_4$4)
              ]))
            ], 6)),
            (_ctx.showText || _ctx.$slots.default) && !_ctx.textInside ? (vue.openBlock(), vue.createElementBlock("div", {
              key: 2,
              class: vue.normalizeClass(vue.unref(ns).e("text")),
              style: vue.normalizeStyle({ fontSize: `${vue.unref(progressTextSize)}px` })
            }, [
              vue.renderSlot(_ctx.$slots, "default", { percentage: _ctx.percentage }, () => [
                !_ctx.status ? (vue.openBlock(), vue.createElementBlock("span", _hoisted_5$3, vue.toDisplayString(vue.unref(content)), 1)) : (vue.openBlock(), vue.createBlock(vue.unref(ElIcon), { key: 1 }, {
                  default: vue.withCtx(() => [
                    (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(vue.unref(statusIcon))))
                  ]),
                  _: 1
                }))
              ])
            ], 6)) : vue.createCommentVNode("v-if", true)
          ], 10, _hoisted_1$j);
        };
      }
    });
    var Progress = /* @__PURE__ */ _export_sfc(_sfc_main$E, [["__file", "progress.vue"]]);
  
    const ElProgress = withInstall(Progress);
  
    const rateProps = buildProps({
      modelValue: {
        type: Number,
        default: 0
      },
      id: {
        type: String,
        default: void 0
      },
      lowThreshold: {
        type: Number,
        default: 2
      },
      highThreshold: {
        type: Number,
        default: 4
      },
      max: {
        type: Number,
        default: 5
      },
      colors: {
        type: definePropType([Array, Object]),
        default: () => mutable(["", "", ""])
      },
      voidColor: {
        type: String,
        default: ""
      },
      disabledVoidColor: {
        type: String,
        default: ""
      },
      icons: {
        type: definePropType([Array, Object]),
        default: () => [star_filled_default, star_filled_default, star_filled_default]
      },
      voidIcon: {
        type: iconPropType,
        default: () => star_default
      },
      disabledVoidIcon: {
        type: iconPropType,
        default: () => star_filled_default
      },
      disabled: {
        type: Boolean
      },
      allowHalf: {
        type: Boolean
      },
      showText: {
        type: Boolean
      },
      showScore: {
        type: Boolean
      },
      textColor: {
        type: String,
        default: ""
      },
      texts: {
        type: definePropType(Array),
        default: () => mutable([
          "Extremely bad",
          "Disappointed",
          "Fair",
          "Satisfied",
          "Surprise"
        ])
      },
      scoreTemplate: {
        type: String,
        default: "{value}"
      },
      size: {
        type: String,
        validator: isValidComponentSize
      },
      label: {
        type: String,
        default: void 0
      },
      clearable: {
        type: Boolean,
        default: false
      }
    });
    const rateEmits = {
      [CHANGE_EVENT]: (value) => isNumber(value),
      [UPDATE_MODEL_EVENT]: (value) => isNumber(value)
    };
  
    const _hoisted_1$i = ["id", "aria-label", "aria-labelledby", "aria-valuenow", "aria-valuetext", "aria-valuemax"];
    const _hoisted_2$c = ["onMousemove", "onClick"];
    const __default__$t = vue.defineComponent({
      name: "ElRate"
    });
    const _sfc_main$D = /* @__PURE__ */ vue.defineComponent({
      ...__default__$t,
      props: rateProps,
      emits: rateEmits,
      setup(__props, { expose, emit }) {
        const props = __props;
        function getValueFromMap(value, map) {
          const isExcludedObject = (val) => isObject$1(val);
          const matchedKeys = Object.keys(map).map((key) => +key).filter((key) => {
            const val = map[key];
            const excluded = isExcludedObject(val) ? val.excluded : false;
            return excluded ? value < key : value <= key;
          }).sort((a, b) => a - b);
          const matchedValue = map[matchedKeys[0]];
          return isExcludedObject(matchedValue) && matchedValue.value || matchedValue;
        }
        const formContext = vue.inject(formContextKey, void 0);
        const formItemContext = vue.inject(formItemContextKey, void 0);
        const rateSize = useSize();
        const ns = useNamespace("rate");
        const { inputId, isLabeledByFormItem } = useFormItemInputId(props, {
          formItemContext
        });
        const currentValue = vue.ref(props.modelValue);
        const hoverIndex = vue.ref(-1);
        const pointerAtLeftHalf = vue.ref(true);
        const rateClasses = vue.computed(() => [ns.b(), ns.m(rateSize.value)]);
        const rateDisabled = vue.computed(() => props.disabled || (formContext == null ? void 0 : formContext.disabled));
        const rateStyles = vue.computed(() => {
          return ns.cssVarBlock({
            "void-color": props.voidColor,
            "disabled-void-color": props.disabledVoidColor,
            "fill-color": activeColor.value
          });
        });
        const text = vue.computed(() => {
          let result = "";
          if (props.showScore) {
            result = props.scoreTemplate.replace(/\{\s*value\s*\}/, rateDisabled.value ? `${props.modelValue}` : `${currentValue.value}`);
          } else if (props.showText) {
            result = props.texts[Math.ceil(currentValue.value) - 1];
          }
          return result;
        });
        const valueDecimal = vue.computed(() => props.modelValue * 100 - Math.floor(props.modelValue) * 100);
        const colorMap = vue.computed(() => isArray(props.colors) ? {
          [props.lowThreshold]: props.colors[0],
          [props.highThreshold]: { value: props.colors[1], excluded: true },
          [props.max]: props.colors[2]
        } : props.colors);
        const activeColor = vue.computed(() => {
          const color = getValueFromMap(currentValue.value, colorMap.value);
          return isObject$1(color) ? "" : color;
        });
        const decimalStyle = vue.computed(() => {
          let width = "";
          if (rateDisabled.value) {
            width = `${valueDecimal.value}%`;
          } else if (props.allowHalf) {
            width = "50%";
          }
          return {
            color: activeColor.value,
            width
          };
        });
        const componentMap = vue.computed(() => {
          let icons = isArray(props.icons) ? [...props.icons] : { ...props.icons };
          icons = vue.markRaw(icons);
          return isArray(icons) ? {
            [props.lowThreshold]: icons[0],
            [props.highThreshold]: {
              value: icons[1],
              excluded: true
            },
            [props.max]: icons[2]
          } : icons;
        });
        const decimalIconComponent = vue.computed(() => getValueFromMap(props.modelValue, componentMap.value));
        const voidComponent = vue.computed(() => rateDisabled.value ? isString(props.disabledVoidIcon) ? props.disabledVoidIcon : vue.markRaw(props.disabledVoidIcon) : isString(props.voidIcon) ? props.voidIcon : vue.markRaw(props.voidIcon));
        const activeComponent = vue.computed(() => getValueFromMap(currentValue.value, componentMap.value));
        function showDecimalIcon(item) {
          const showWhenDisabled = rateDisabled.value && valueDecimal.value > 0 && item - 1 < props.modelValue && item > props.modelValue;
          const showWhenAllowHalf = props.allowHalf && pointerAtLeftHalf.value && item - 0.5 <= currentValue.value && item > currentValue.value;
          return showWhenDisabled || showWhenAllowHalf;
        }
        function emitValue(value) {
          if (props.clearable && value === props.modelValue) {
            value = 0;
          }
          emit(UPDATE_MODEL_EVENT, value);
          if (props.modelValue !== value) {
            emit("change", value);
          }
        }
        function selectValue(value) {
          if (rateDisabled.value) {
            return;
          }
          if (props.allowHalf && pointerAtLeftHalf.value) {
            emitValue(currentValue.value);
          } else {
            emitValue(value);
          }
        }
        function handleKey(e) {
          if (rateDisabled.value) {
            return;
          }
          let _currentValue = currentValue.value;
          const code = e.code;
          if (code === EVENT_CODE.up || code === EVENT_CODE.right) {
            if (props.allowHalf) {
              _currentValue += 0.5;
            } else {
              _currentValue += 1;
            }
            e.stopPropagation();
            e.preventDefault();
          } else if (code === EVENT_CODE.left || code === EVENT_CODE.down) {
            if (props.allowHalf) {
              _currentValue -= 0.5;
            } else {
              _currentValue -= 1;
            }
            e.stopPropagation();
            e.preventDefault();
          }
          _currentValue = _currentValue < 0 ? 0 : _currentValue;
          _currentValue = _currentValue > props.max ? props.max : _currentValue;
          emit(UPDATE_MODEL_EVENT, _currentValue);
          emit("change", _currentValue);
          return _currentValue;
        }
        function setCurrentValue(value, event) {
          if (rateDisabled.value) {
            return;
          }
          if (props.allowHalf) {
            let target = event.target;
            if (hasClass(target, ns.e("item"))) {
              target = target.querySelector(`.${ns.e("icon")}`);
            }
            if (target.clientWidth === 0 || hasClass(target, ns.e("decimal"))) {
              target = target.parentNode;
            }
            pointerAtLeftHalf.value = event.offsetX * 2 <= target.clientWidth;
            currentValue.value = pointerAtLeftHalf.value ? value - 0.5 : value;
          } else {
            currentValue.value = value;
          }
          hoverIndex.value = value;
        }
        function resetCurrentValue() {
          if (rateDisabled.value) {
            return;
          }
          if (props.allowHalf) {
            pointerAtLeftHalf.value = props.modelValue !== Math.floor(props.modelValue);
          }
          currentValue.value = props.modelValue;
          hoverIndex.value = -1;
        }
        vue.watch(() => props.modelValue, (val) => {
          currentValue.value = val;
          pointerAtLeftHalf.value = props.modelValue !== Math.floor(props.modelValue);
        });
        if (!props.modelValue) {
          emit(UPDATE_MODEL_EVENT, 0);
        }
        expose({
          setCurrentValue,
          resetCurrentValue
        });
        return (_ctx, _cache) => {
          var _a;
          return vue.openBlock(), vue.createElementBlock("div", {
            id: vue.unref(inputId),
            class: vue.normalizeClass([vue.unref(rateClasses), vue.unref(ns).is("disabled", vue.unref(rateDisabled))]),
            role: "slider",
            "aria-label": !vue.unref(isLabeledByFormItem) ? _ctx.label || "rating" : void 0,
            "aria-labelledby": vue.unref(isLabeledByFormItem) ? (_a = vue.unref(formItemContext)) == null ? void 0 : _a.labelId : void 0,
            "aria-valuenow": currentValue.value,
            "aria-valuetext": vue.unref(text) || void 0,
            "aria-valuemin": "0",
            "aria-valuemax": _ctx.max,
            tabindex: "0",
            style: vue.normalizeStyle(vue.unref(rateStyles)),
            onKeydown: handleKey
          }, [
            (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(_ctx.max, (item, key) => {
              return vue.openBlock(), vue.createElementBlock("span", {
                key,
                class: vue.normalizeClass(vue.unref(ns).e("item")),
                onMousemove: ($event) => setCurrentValue(item, $event),
                onMouseleave: resetCurrentValue,
                onClick: ($event) => selectValue(item)
              }, [
                vue.createVNode(vue.unref(ElIcon), {
                  class: vue.normalizeClass([
                    vue.unref(ns).e("icon"),
                    { hover: hoverIndex.value === item },
                    vue.unref(ns).is("active", item <= currentValue.value)
                  ])
                }, {
                  default: vue.withCtx(() => [
                    !showDecimalIcon(item) ? (vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: 0 }, [
                      vue.withDirectives((vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(vue.unref(activeComponent)), null, null, 512)), [
                        [vue.vShow, item <= currentValue.value]
                      ]),
                      vue.withDirectives((vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(vue.unref(voidComponent)), null, null, 512)), [
                        [vue.vShow, !(item <= currentValue.value)]
                      ])
                    ], 64)) : vue.createCommentVNode("v-if", true),
                    showDecimalIcon(item) ? (vue.openBlock(), vue.createBlock(vue.unref(ElIcon), {
                      key: 1,
                      style: vue.normalizeStyle(vue.unref(decimalStyle)),
                      class: vue.normalizeClass([vue.unref(ns).e("icon"), vue.unref(ns).e("decimal")])
                    }, {
                      default: vue.withCtx(() => [
                        (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(vue.unref(decimalIconComponent))))
                      ]),
                      _: 1
                    }, 8, ["style", "class"])) : vue.createCommentVNode("v-if", true)
                  ]),
                  _: 2
                }, 1032, ["class"])
              ], 42, _hoisted_2$c);
            }), 128)),
            _ctx.showText || _ctx.showScore ? (vue.openBlock(), vue.createElementBlock("span", {
              key: 0,
              class: vue.normalizeClass(vue.unref(ns).e("text"))
            }, vue.toDisplayString(vue.unref(text)), 3)) : vue.createCommentVNode("v-if", true)
          ], 46, _hoisted_1$i);
        };
      }
    });
    var Rate = /* @__PURE__ */ _export_sfc(_sfc_main$D, [["__file", "rate.vue"]]);
  
    const ElRate = withInstall(Rate);
  
    const IconMap = {
      success: "icon-success",
      warning: "icon-warning",
      error: "icon-error",
      info: "icon-info"
    };
    const IconComponentMap = {
      [IconMap.success]: circle_check_filled_default,
      [IconMap.warning]: warning_filled_default,
      [IconMap.error]: circle_close_filled_default,
      [IconMap.info]: info_filled_default
    };
    const resultProps = buildProps({
      title: {
        type: String,
        default: ""
      },
      subTitle: {
        type: String,
        default: ""
      },
      icon: {
        type: String,
        values: ["success", "warning", "info", "error"],
        default: "info"
      }
    });
  
    const __default__$s = vue.defineComponent({
      name: "ElResult"
    });
    const _sfc_main$C = /* @__PURE__ */ vue.defineComponent({
      ...__default__$s,
      props: resultProps,
      setup(__props) {
        const props = __props;
        const ns = useNamespace("result");
        const resultIcon = vue.computed(() => {
          const icon = props.icon;
          const iconClass = icon && IconMap[icon] ? IconMap[icon] : "icon-info";
          const iconComponent = IconComponentMap[iconClass] || IconComponentMap["icon-info"];
          return {
            class: iconClass,
            component: iconComponent
          };
        });
        return (_ctx, _cache) => {
          return vue.openBlock(), vue.createElementBlock("div", {
            class: vue.normalizeClass(vue.unref(ns).b())
          }, [
            vue.createElementVNode("div", {
              class: vue.normalizeClass(vue.unref(ns).e("icon"))
            }, [
              vue.renderSlot(_ctx.$slots, "icon", {}, () => [
                vue.unref(resultIcon).component ? (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(vue.unref(resultIcon).component), {
                  key: 0,
                  class: vue.normalizeClass(vue.unref(resultIcon).class)
                }, null, 8, ["class"])) : vue.createCommentVNode("v-if", true)
              ])
            ], 2),
            _ctx.title || _ctx.$slots.title ? (vue.openBlock(), vue.createElementBlock("div", {
              key: 0,
              class: vue.normalizeClass(vue.unref(ns).e("title"))
            }, [
              vue.renderSlot(_ctx.$slots, "title", {}, () => [
                vue.createElementVNode("p", null, vue.toDisplayString(_ctx.title), 1)
              ])
            ], 2)) : vue.createCommentVNode("v-if", true),
            _ctx.subTitle || _ctx.$slots["sub-title"] ? (vue.openBlock(), vue.createElementBlock("div", {
              key: 1,
              class: vue.normalizeClass(vue.unref(ns).e("subtitle"))
            }, [
              vue.renderSlot(_ctx.$slots, "sub-title", {}, () => [
                vue.createElementVNode("p", null, vue.toDisplayString(_ctx.subTitle), 1)
              ])
            ], 2)) : vue.createCommentVNode("v-if", true),
            _ctx.$slots.extra ? (vue.openBlock(), vue.createElementBlock("div", {
              key: 2,
              class: vue.normalizeClass(vue.unref(ns).e("extra"))
            }, [
              vue.renderSlot(_ctx.$slots, "extra")
            ], 2)) : vue.createCommentVNode("v-if", true)
          ], 2);
        };
      }
    });
    var Result = /* @__PURE__ */ _export_sfc(_sfc_main$C, [["__file", "result.vue"]]);
  
    const ElResult = withInstall(Result);
  
    const RowJustify = [
      "start",
      "center",
      "end",
      "space-around",
      "space-between",
      "space-evenly"
    ];
    const RowAlign = ["top", "middle", "bottom"];
    const rowProps = buildProps({
      tag: {
        type: String,
        default: "div"
      },
      gutter: {
        type: Number,
        default: 0
      },
      justify: {
        type: String,
        values: RowJustify,
        default: "start"
      },
      align: {
        type: String,
        values: RowAlign,
        default: "top"
      }
    });
  
    const __default__$r = vue.defineComponent({
      name: "ElRow"
    });
    const _sfc_main$B = /* @__PURE__ */ vue.defineComponent({
      ...__default__$r,
      props: rowProps,
      setup(__props) {
        const props = __props;
        const ns = useNamespace("row");
        const gutter = vue.computed(() => props.gutter);
        vue.provide(rowContextKey, {
          gutter
        });
        const style = vue.computed(() => {
          const styles = {};
          if (!props.gutter) {
            return styles;
          }
          styles.marginRight = styles.marginLeft = `-${props.gutter / 2}px`;
          return styles;
        });
        return (_ctx, _cache) => {
          return vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(_ctx.tag), {
            class: vue.normalizeClass([
              vue.unref(ns).b(),
              vue.unref(ns).is(`justify-${props.justify}`, _ctx.justify !== "start"),
              vue.unref(ns).is(`align-${props.align}`, _ctx.align !== "top")
            ]),
            style: vue.normalizeStyle(vue.unref(style))
          }, {
            default: vue.withCtx(() => [
              vue.renderSlot(_ctx.$slots, "default")
            ]),
            _: 3
          }, 8, ["class", "style"]);
        };
      }
    });
    var Row$1 = /* @__PURE__ */ _export_sfc(_sfc_main$B, [["__file", "row.vue"]]);
  
    const ElRow = withInstall(Row$1);
  
    var safeIsNaN = Number.isNaN || function ponyfill(value) {
      return typeof value === "number" && value !== value;
    };
    function isEqual(first, second) {
      if (first === second) {
        return true;
      }
      if (safeIsNaN(first) && safeIsNaN(second)) {
        return true;
      }
      return false;
    }
    function areInputsEqual(newInputs, lastInputs) {
      if (newInputs.length !== lastInputs.length) {
        return false;
      }
      for (var i = 0; i < newInputs.length; i++) {
        if (!isEqual(newInputs[i], lastInputs[i])) {
          return false;
        }
      }
      return true;
    }
    function memoizeOne(resultFn, isEqual2) {
      if (isEqual2 === void 0) {
        isEqual2 = areInputsEqual;
      }
      var cache = null;
      function memoized() {
        var newArgs = [];
        for (var _i = 0; _i < arguments.length; _i++) {
          newArgs[_i] = arguments[_i];
        }
        if (cache && cache.lastThis === this && isEqual2(newArgs, cache.lastArgs)) {
          return cache.lastResult;
        }
        var lastResult = resultFn.apply(this, newArgs);
        cache = {
          lastResult,
          lastArgs: newArgs,
          lastThis: this
        };
        return lastResult;
      }
      memoized.clear = function clear() {
        cache = null;
      };
      return memoized;
    }
  
    const useCache = () => {
      const vm = vue.getCurrentInstance();
      const props = vm.proxy.$props;
      return vue.computed(() => {
        const _getItemStyleCache = (_, __, ___) => ({});
        return props.perfMode ? memoize(_getItemStyleCache) : memoizeOne(_getItemStyleCache);
      });
    };
  
    const DEFAULT_DYNAMIC_LIST_ITEM_SIZE = 50;
    const ITEM_RENDER_EVT = "itemRendered";
    const SCROLL_EVT = "scroll";
    const FORWARD = "forward";
    const BACKWARD = "backward";
    const AUTO_ALIGNMENT = "auto";
    const SMART_ALIGNMENT = "smart";
    const START_ALIGNMENT = "start";
    const CENTERED_ALIGNMENT = "center";
    const END_ALIGNMENT = "end";
    const HORIZONTAL = "horizontal";
    const VERTICAL = "vertical";
    const LTR = "ltr";
    const RTL = "rtl";
    const RTL_OFFSET_NAG = "negative";
    const RTL_OFFSET_POS_ASC = "positive-ascending";
    const RTL_OFFSET_POS_DESC = "positive-descending";
    const ScrollbarDirKey = {
      [HORIZONTAL]: "left",
      [VERTICAL]: "top"
    };
    const SCROLLBAR_MIN_SIZE = 20;
  
    const LayoutKeys = {
      [HORIZONTAL]: "deltaX",
      [VERTICAL]: "deltaY"
    };
    const useWheel = ({ atEndEdge, atStartEdge, layout }, onWheelDelta) => {
      let frameHandle;
      let offset = 0;
      const hasReachedEdge = (offset2) => {
        const edgeReached = offset2 < 0 && atStartEdge.value || offset2 > 0 && atEndEdge.value;
        return edgeReached;
      };
      const onWheel = (e) => {
        cAF(frameHandle);
        const newOffset = e[LayoutKeys[layout.value]];
        if (hasReachedEdge(offset) && hasReachedEdge(offset + newOffset))
          return;
        offset += newOffset;
        if (!isFirefox()) {
          e.preventDefault();
        }
        frameHandle = rAF(() => {
          onWheelDelta(offset);
          offset = 0;
        });
      };
      return {
        hasReachedEdge,
        onWheel
      };
    };
    var useWheel$1 = useWheel;
  
    const itemSize$1 = buildProp({
      type: definePropType([Number, Function]),
      required: true
    });
    const estimatedItemSize = buildProp({
      type: Number
    });
    const cache = buildProp({
      type: Number,
      default: 2
    });
    const direction = buildProp({
      type: String,
      values: ["ltr", "rtl"],
      default: "ltr"
    });
    const initScrollOffset = buildProp({
      type: Number,
      default: 0
    });
    const total = buildProp({
      type: Number,
      required: true
    });
    const layout = buildProp({
      type: String,
      values: ["horizontal", "vertical"],
      default: VERTICAL
    });
    const virtualizedProps = buildProps({
      className: {
        type: String,
        default: ""
      },
      containerElement: {
        type: definePropType([String, Object]),
        default: "div"
      },
      data: {
        type: definePropType(Array),
        default: () => mutable([])
      },
      direction,
      height: {
        type: [String, Number],
        required: true
      },
      innerElement: {
        type: [String, Object],
        default: "div"
      },
      style: {
        type: definePropType([Object, String, Array])
      },
      useIsScrolling: {
        type: Boolean,
        default: false
      },
      width: {
        type: [Number, String],
        required: false
      },
      perfMode: {
        type: Boolean,
        default: true
      },
      scrollbarAlwaysOn: {
        type: Boolean,
        default: false
      }
    });
    const virtualizedListProps = buildProps({
      cache,
      estimatedItemSize,
      layout,
      initScrollOffset,
      total,
      itemSize: itemSize$1,
      ...virtualizedProps
    });
    const scrollbarSize = {
      type: Number,
      default: 6
    };
    const startGap = { type: Number, default: 0 };
    const endGap = { type: Number, default: 2 };
    const virtualizedGridProps = buildProps({
      columnCache: cache,
      columnWidth: itemSize$1,
      estimatedColumnWidth: estimatedItemSize,
      estimatedRowHeight: estimatedItemSize,
      initScrollLeft: initScrollOffset,
      initScrollTop: initScrollOffset,
      itemKey: {
        type: definePropType(Function),
        default: ({
          columnIndex,
          rowIndex
        }) => `${rowIndex}:${columnIndex}`
      },
      rowCache: cache,
      rowHeight: itemSize$1,
      totalColumn: total,
      totalRow: total,
      hScrollbarSize: scrollbarSize,
      vScrollbarSize: scrollbarSize,
      scrollbarStartGap: startGap,
      scrollbarEndGap: endGap,
      ...virtualizedProps
    });
    const virtualizedScrollbarProps = buildProps({
      alwaysOn: Boolean,
      class: String,
      layout,
      total,
      ratio: {
        type: Number,
        required: true
      },
      clientSize: {
        type: Number,
        required: true
      },
      scrollFrom: {
        type: Number,
        required: true
      },
      scrollbarSize,
      startGap,
      endGap,
      visible: Boolean
    });
  
    const getScrollDir = (prev, cur) => prev < cur ? FORWARD : BACKWARD;
    const isHorizontal = (dir) => dir === LTR || dir === RTL || dir === HORIZONTAL;
    const isRTL = (dir) => dir === RTL;
    let cachedRTLResult = null;
    function getRTLOffsetType(recalculate = false) {
      if (cachedRTLResult === null || recalculate) {
        const outerDiv = document.createElement("div");
        const outerStyle = outerDiv.style;
        outerStyle.width = "50px";
        outerStyle.height = "50px";
        outerStyle.overflow = "scroll";
        outerStyle.direction = "rtl";
        const innerDiv = document.createElement("div");
        const innerStyle = innerDiv.style;
        innerStyle.width = "100px";
        innerStyle.height = "100px";
        outerDiv.appendChild(innerDiv);
        document.body.appendChild(outerDiv);
        if (outerDiv.scrollLeft > 0) {
          cachedRTLResult = RTL_OFFSET_POS_DESC;
        } else {
          outerDiv.scrollLeft = 1;
          if (outerDiv.scrollLeft === 0) {
            cachedRTLResult = RTL_OFFSET_NAG;
          } else {
            cachedRTLResult = RTL_OFFSET_POS_ASC;
          }
        }
        document.body.removeChild(outerDiv);
        return cachedRTLResult;
      }
      return cachedRTLResult;
    }
    function renderThumbStyle({ move, size, bar }, layout) {
      const style = {};
      const translate = `translate${bar.axis}(${move}px)`;
      style[bar.size] = size;
      style.transform = translate;
      style.msTransform = translate;
      style.webkitTransform = translate;
      if (layout === "horizontal") {
        style.height = "100%";
      } else {
        style.width = "100%";
      }
      return style;
    }
  
    const ScrollBar = vue.defineComponent({
      name: "ElVirtualScrollBar",
      props: virtualizedScrollbarProps,
      emits: ["scroll", "start-move", "stop-move"],
      setup(props, { emit }) {
        const GAP = vue.computed(() => props.startGap + props.endGap);
        const nsVirtualScrollbar = useNamespace("virtual-scrollbar");
        const nsScrollbar = useNamespace("scrollbar");
        const trackRef = vue.ref();
        const thumbRef = vue.ref();
        let frameHandle = null;
        let onselectstartStore = null;
        const state = vue.reactive({
          isDragging: false,
          traveled: 0
        });
        const bar = vue.computed(() => BAR_MAP[props.layout]);
        const trackSize = vue.computed(() => props.clientSize - vue.unref(GAP));
        const trackStyle = vue.computed(() => ({
          position: "absolute",
          width: `${HORIZONTAL === props.layout ? trackSize.value : props.scrollbarSize}px`,
          height: `${HORIZONTAL === props.layout ? props.scrollbarSize : trackSize.value}px`,
          [ScrollbarDirKey[props.layout]]: "2px",
          right: "2px",
          bottom: "2px",
          borderRadius: "4px"
        }));
        const thumbSize = vue.computed(() => {
          const ratio = props.ratio;
          const clientSize = props.clientSize;
          if (ratio >= 100) {
            return Number.POSITIVE_INFINITY;
          }
          if (ratio >= 50) {
            return ratio * clientSize / 100;
          }
          const SCROLLBAR_MAX_SIZE = clientSize / 3;
          return Math.floor(Math.min(Math.max(ratio * clientSize, SCROLLBAR_MIN_SIZE), SCROLLBAR_MAX_SIZE));
        });
        const thumbStyle = vue.computed(() => {
          if (!Number.isFinite(thumbSize.value)) {
            return {
              display: "none"
            };
          }
          const thumb = `${thumbSize.value}px`;
          const style = renderThumbStyle({
            bar: bar.value,
            size: thumb,
            move: state.traveled
          }, props.layout);
          return style;
        });
        const totalSteps = vue.computed(() => Math.floor(props.clientSize - thumbSize.value - vue.unref(GAP)));
        const attachEvents = () => {
          window.addEventListener("mousemove", onMouseMove);
          window.addEventListener("mouseup", onMouseUp);
          const thumbEl = vue.unref(thumbRef);
          if (!thumbEl)
            return;
          onselectstartStore = document.onselectstart;
          document.onselectstart = () => false;
          thumbEl.addEventListener("touchmove", onMouseMove);
          thumbEl.addEventListener("touchend", onMouseUp);
        };
        const detachEvents = () => {
          window.removeEventListener("mousemove", onMouseMove);
          window.removeEventListener("mouseup", onMouseUp);
          document.onselectstart = onselectstartStore;
          onselectstartStore = null;
          const thumbEl = vue.unref(thumbRef);
          if (!thumbEl)
            return;
          thumbEl.removeEventListener("touchmove", onMouseMove);
          thumbEl.removeEventListener("touchend", onMouseUp);
        };
        const onThumbMouseDown = (e) => {
          e.stopImmediatePropagation();
          if (e.ctrlKey || [1, 2].includes(e.button)) {
            return;
          }
          state.isDragging = true;
          state[bar.value.axis] = e.currentTarget[bar.value.offset] - (e[bar.value.client] - e.currentTarget.getBoundingClientRect()[bar.value.direction]);
          emit("start-move");
          attachEvents();
        };
        const onMouseUp = () => {
          state.isDragging = false;
          state[bar.value.axis] = 0;
          emit("stop-move");
          detachEvents();
        };
        const onMouseMove = (e) => {
          const { isDragging } = state;
          if (!isDragging)
            return;
          if (!thumbRef.value || !trackRef.value)
            return;
          const prevPage = state[bar.value.axis];
          if (!prevPage)
            return;
          cAF(frameHandle);
          const offset = (trackRef.value.getBoundingClientRect()[bar.value.direction] - e[bar.value.client]) * -1;
          const thumbClickPosition = thumbRef.value[bar.value.offset] - prevPage;
          const distance = offset - thumbClickPosition;
          frameHandle = rAF(() => {
            state.traveled = Math.max(props.startGap, Math.min(distance, totalSteps.value));
            emit("scroll", distance, totalSteps.value);
          });
        };
        const clickTrackHandler = (e) => {
          const offset = Math.abs(e.target.getBoundingClientRect()[bar.value.direction] - e[bar.value.client]);
          const thumbHalf = thumbRef.value[bar.value.offset] / 2;
          const distance = offset - thumbHalf;
          state.traveled = Math.max(0, Math.min(distance, totalSteps.value));
          emit("scroll", distance, totalSteps.value);
        };
        vue.watch(() => props.scrollFrom, (v) => {
          if (state.isDragging)
            return;
          state.traveled = Math.ceil(v * totalSteps.value);
        });
        vue.onBeforeUnmount(() => {
          detachEvents();
        });
        return () => {
          return vue.h("div", {
            role: "presentation",
            ref: trackRef,
            class: [
              nsVirtualScrollbar.b(),
              props.class,
              (props.alwaysOn || state.isDragging) && "always-on"
            ],
            style: trackStyle.value,
            onMousedown: vue.withModifiers(clickTrackHandler, ["stop", "prevent"]),
            onTouchstartPrevent: onThumbMouseDown
          }, vue.h("div", {
            ref: thumbRef,
            class: nsScrollbar.e("thumb"),
            style: thumbStyle.value,
            onMousedown: onThumbMouseDown
          }, []));
        };
      }
    });
    var Scrollbar = ScrollBar;
  
    const createList = ({
      name,
      getOffset,
      getItemSize,
      getItemOffset,
      getEstimatedTotalSize,
      getStartIndexForOffset,
      getStopIndexForStartIndex,
      initCache,
      clearCache,
      validateProps
    }) => {
      return vue.defineComponent({
        name: name != null ? name : "ElVirtualList",
        props: virtualizedListProps,
        emits: [ITEM_RENDER_EVT, SCROLL_EVT],
        setup(props, { emit, expose }) {
          validateProps(props);
          const instance = vue.getCurrentInstance();
          const ns = useNamespace("vl");
          const dynamicSizeCache = vue.ref(initCache(props, instance));
          const getItemStyleCache = useCache();
          const windowRef = vue.ref();
          const innerRef = vue.ref();
          const scrollbarRef = vue.ref();
          const states = vue.ref({
            isScrolling: false,
            scrollDir: "forward",
            scrollOffset: isNumber(props.initScrollOffset) ? props.initScrollOffset : 0,
            updateRequested: false,
            isScrollbarDragging: false,
            scrollbarAlwaysOn: props.scrollbarAlwaysOn
          });
          const itemsToRender = vue.computed(() => {
            const { total, cache } = props;
            const { isScrolling, scrollDir, scrollOffset } = vue.unref(states);
            if (total === 0) {
              return [0, 0, 0, 0];
            }
            const startIndex = getStartIndexForOffset(props, scrollOffset, vue.unref(dynamicSizeCache));
            const stopIndex = getStopIndexForStartIndex(props, startIndex, scrollOffset, vue.unref(dynamicSizeCache));
            const cacheBackward = !isScrolling || scrollDir === BACKWARD ? Math.max(1, cache) : 1;
            const cacheForward = !isScrolling || scrollDir === FORWARD ? Math.max(1, cache) : 1;
            return [
              Math.max(0, startIndex - cacheBackward),
              Math.max(0, Math.min(total - 1, stopIndex + cacheForward)),
              startIndex,
              stopIndex
            ];
          });
          const estimatedTotalSize = vue.computed(() => getEstimatedTotalSize(props, vue.unref(dynamicSizeCache)));
          const _isHorizontal = vue.computed(() => isHorizontal(props.layout));
          const windowStyle = vue.computed(() => [
            {
              position: "relative",
              [`overflow-${_isHorizontal.value ? "x" : "y"}`]: "scroll",
              WebkitOverflowScrolling: "touch",
              willChange: "transform"
            },
            {
              direction: props.direction,
              height: isNumber(props.height) ? `${props.height}px` : props.height,
              width: isNumber(props.width) ? `${props.width}px` : props.width
            },
            props.style
          ]);
          const innerStyle = vue.computed(() => {
            const size = vue.unref(estimatedTotalSize);
            const horizontal = vue.unref(_isHorizontal);
            return {
              height: horizontal ? "100%" : `${size}px`,
              pointerEvents: vue.unref(states).isScrolling ? "none" : void 0,
              width: horizontal ? `${size}px` : "100%"
            };
          });
          const clientSize = vue.computed(() => _isHorizontal.value ? props.width : props.height);
          const { onWheel } = useWheel$1({
            atStartEdge: vue.computed(() => states.value.scrollOffset <= 0),
            atEndEdge: vue.computed(() => states.value.scrollOffset >= estimatedTotalSize.value),
            layout: vue.computed(() => props.layout)
          }, (offset) => {
            var _a, _b;
            (_b = (_a = scrollbarRef.value).onMouseUp) == null ? void 0 : _b.call(_a);
            scrollTo(Math.min(states.value.scrollOffset + offset, estimatedTotalSize.value - clientSize.value));
          });
          const emitEvents = () => {
            const { total } = props;
            if (total > 0) {
              const [cacheStart, cacheEnd, visibleStart, visibleEnd] = vue.unref(itemsToRender);
              emit(ITEM_RENDER_EVT, cacheStart, cacheEnd, visibleStart, visibleEnd);
            }
            const { scrollDir, scrollOffset, updateRequested } = vue.unref(states);
            emit(SCROLL_EVT, scrollDir, scrollOffset, updateRequested);
          };
          const scrollVertically = (e) => {
            const { clientHeight, scrollHeight, scrollTop } = e.currentTarget;
            const _states = vue.unref(states);
            if (_states.scrollOffset === scrollTop) {
              return;
            }
            const scrollOffset = Math.max(0, Math.min(scrollTop, scrollHeight - clientHeight));
            states.value = {
              ..._states,
              isScrolling: true,
              scrollDir: getScrollDir(_states.scrollOffset, scrollOffset),
              scrollOffset,
              updateRequested: false
            };
            vue.nextTick(resetIsScrolling);
          };
          const scrollHorizontally = (e) => {
            const { clientWidth, scrollLeft, scrollWidth } = e.currentTarget;
            const _states = vue.unref(states);
            if (_states.scrollOffset === scrollLeft) {
              return;
            }
            const { direction } = props;
            let scrollOffset = scrollLeft;
            if (direction === RTL) {
              switch (getRTLOffsetType()) {
                case RTL_OFFSET_NAG: {
                  scrollOffset = -scrollLeft;
                  break;
                }
                case RTL_OFFSET_POS_DESC: {
                  scrollOffset = scrollWidth - clientWidth - scrollLeft;
                  break;
                }
              }
            }
            scrollOffset = Math.max(0, Math.min(scrollOffset, scrollWidth - clientWidth));
            states.value = {
              ..._states,
              isScrolling: true,
              scrollDir: getScrollDir(_states.scrollOffset, scrollOffset),
              scrollOffset,
              updateRequested: false
            };
            vue.nextTick(resetIsScrolling);
          };
          const onScroll = (e) => {
            vue.unref(_isHorizontal) ? scrollHorizontally(e) : scrollVertically(e);
            emitEvents();
          };
          const onScrollbarScroll = (distanceToGo, totalSteps) => {
            const offset = (estimatedTotalSize.value - clientSize.value) / totalSteps * distanceToGo;
            scrollTo(Math.min(estimatedTotalSize.value - clientSize.value, offset));
          };
          const scrollTo = (offset) => {
            offset = Math.max(offset, 0);
            if (offset === vue.unref(states).scrollOffset) {
              return;
            }
            states.value = {
              ...vue.unref(states),
              scrollOffset: offset,
              scrollDir: getScrollDir(vue.unref(states).scrollOffset, offset),
              updateRequested: true
            };
            vue.nextTick(resetIsScrolling);
          };
          const scrollToItem = (idx, alignment = AUTO_ALIGNMENT) => {
            const { scrollOffset } = vue.unref(states);
            idx = Math.max(0, Math.min(idx, props.total - 1));
            scrollTo(getOffset(props, idx, alignment, scrollOffset, vue.unref(dynamicSizeCache)));
          };
          const getItemStyle = (idx) => {
            const { direction, itemSize, layout } = props;
            const itemStyleCache = getItemStyleCache.value(clearCache && itemSize, clearCache && layout, clearCache && direction);
            let style;
            if (hasOwn(itemStyleCache, String(idx))) {
              style = itemStyleCache[idx];
            } else {
              const offset = getItemOffset(props, idx, vue.unref(dynamicSizeCache));
              const size = getItemSize(props, idx, vue.unref(dynamicSizeCache));
              const horizontal = vue.unref(_isHorizontal);
              const isRtl = direction === RTL;
              const offsetHorizontal = horizontal ? offset : 0;
              itemStyleCache[idx] = style = {
                position: "absolute",
                left: isRtl ? void 0 : `${offsetHorizontal}px`,
                right: isRtl ? `${offsetHorizontal}px` : void 0,
                top: !horizontal ? `${offset}px` : 0,
                height: !horizontal ? `${size}px` : "100%",
                width: horizontal ? `${size}px` : "100%"
              };
            }
            return style;
          };
          const resetIsScrolling = () => {
            states.value.isScrolling = false;
            vue.nextTick(() => {
              getItemStyleCache.value(-1, null, null);
            });
          };
          const resetScrollTop = () => {
            const window = windowRef.value;
            if (window) {
              window.scrollTop = 0;
            }
          };
          vue.onMounted(() => {
            if (!isClient)
              return;
            const { initScrollOffset } = props;
            const windowElement = vue.unref(windowRef);
            if (isNumber(initScrollOffset) && windowElement) {
              if (vue.unref(_isHorizontal)) {
                windowElement.scrollLeft = initScrollOffset;
              } else {
                windowElement.scrollTop = initScrollOffset;
              }
            }
            emitEvents();
          });
          vue.onUpdated(() => {
            const { direction, layout } = props;
            const { scrollOffset, updateRequested } = vue.unref(states);
            const windowElement = vue.unref(windowRef);
            if (updateRequested && windowElement) {
              if (layout === HORIZONTAL) {
                if (direction === RTL) {
                  switch (getRTLOffsetType()) {
                    case RTL_OFFSET_NAG: {
                      windowElement.scrollLeft = -scrollOffset;
                      break;
                    }
                    case RTL_OFFSET_POS_ASC: {
                      windowElement.scrollLeft = scrollOffset;
                      break;
                    }
                    default: {
                      const { clientWidth, scrollWidth } = windowElement;
                      windowElement.scrollLeft = scrollWidth - clientWidth - scrollOffset;
                      break;
                    }
                  }
                } else {
                  windowElement.scrollLeft = scrollOffset;
                }
              } else {
                windowElement.scrollTop = scrollOffset;
              }
            }
          });
          const api = {
            ns,
            clientSize,
            estimatedTotalSize,
            windowStyle,
            windowRef,
            innerRef,
            innerStyle,
            itemsToRender,
            scrollbarRef,
            states,
            getItemStyle,
            onScroll,
            onScrollbarScroll,
            onWheel,
            scrollTo,
            scrollToItem,
            resetScrollTop
          };
          expose({
            windowRef,
            innerRef,
            getItemStyleCache,
            scrollTo,
            scrollToItem,
            resetScrollTop,
            states
          });
          return api;
        },
        render(ctx) {
          var _a;
          const {
            $slots,
            className,
            clientSize,
            containerElement,
            data,
            getItemStyle,
            innerElement,
            itemsToRender,
            innerStyle,
            layout,
            total,
            onScroll,
            onScrollbarScroll,
            onWheel,
            states,
            useIsScrolling,
            windowStyle,
            ns
          } = ctx;
          const [start, end] = itemsToRender;
          const Container = vue.resolveDynamicComponent(containerElement);
          const Inner = vue.resolveDynamicComponent(innerElement);
          const children = [];
          if (total > 0) {
            for (let i = start; i <= end; i++) {
              children.push((_a = $slots.default) == null ? void 0 : _a.call($slots, {
                data,
                key: i,
                index: i,
                isScrolling: useIsScrolling ? states.isScrolling : void 0,
                style: getItemStyle(i)
              }));
            }
          }
          const InnerNode = [
            vue.h(Inner, {
              style: innerStyle,
              ref: "innerRef"
            }, !isString(Inner) ? {
              default: () => children
            } : children)
          ];
          const scrollbar = vue.h(Scrollbar, {
            ref: "scrollbarRef",
            clientSize,
            layout,
            onScroll: onScrollbarScroll,
            ratio: clientSize * 100 / this.estimatedTotalSize,
            scrollFrom: states.scrollOffset / (this.estimatedTotalSize - clientSize),
            total
          });
          const listContainer = vue.h(Container, {
            class: [ns.e("window"), className],
            style: windowStyle,
            onScroll,
            onWheel,
            ref: "windowRef",
            key: 0
          }, !isString(Container) ? { default: () => [InnerNode] } : [InnerNode]);
          return vue.h("div", {
            key: 0,
            class: [ns.e("wrapper"), states.scrollbarAlwaysOn ? "always-on" : ""]
          }, [listContainer, scrollbar]);
        }
      });
    };
    var createList$1 = createList;
  
    const FixedSizeList = createList$1({
      name: "ElFixedSizeList",
      getItemOffset: ({ itemSize }, index) => index * itemSize,
      getItemSize: ({ itemSize }) => itemSize,
      getEstimatedTotalSize: ({ total, itemSize }) => itemSize * total,
      getOffset: ({ height, total, itemSize, layout, width }, index, alignment, scrollOffset) => {
        const size = isHorizontal(layout) ? width : height;
        const lastItemOffset = Math.max(0, total * itemSize - size);
        const maxOffset = Math.min(lastItemOffset, index * itemSize);
        const minOffset = Math.max(0, (index + 1) * itemSize - size);
        if (alignment === SMART_ALIGNMENT) {
          if (scrollOffset >= minOffset - size && scrollOffset <= maxOffset + size) {
            alignment = AUTO_ALIGNMENT;
          } else {
            alignment = CENTERED_ALIGNMENT;
          }
        }
        switch (alignment) {
          case START_ALIGNMENT: {
            return maxOffset;
          }
          case END_ALIGNMENT: {
            return minOffset;
          }
          case CENTERED_ALIGNMENT: {
            const middleOffset = Math.round(minOffset + (maxOffset - minOffset) / 2);
            if (middleOffset < Math.ceil(size / 2)) {
              return 0;
            } else if (middleOffset > lastItemOffset + Math.floor(size / 2)) {
              return lastItemOffset;
            } else {
              return middleOffset;
            }
          }
          case AUTO_ALIGNMENT:
          default: {
            if (scrollOffset >= minOffset && scrollOffset <= maxOffset) {
              return scrollOffset;
            } else if (scrollOffset < minOffset) {
              return minOffset;
            } else {
              return maxOffset;
            }
          }
        }
      },
      getStartIndexForOffset: ({ total, itemSize }, offset) => Math.max(0, Math.min(total - 1, Math.floor(offset / itemSize))),
      getStopIndexForStartIndex: ({ height, total, itemSize, layout, width }, startIndex, scrollOffset) => {
        const offset = startIndex * itemSize;
        const size = isHorizontal(layout) ? width : height;
        const numVisibleItems = Math.ceil((size + scrollOffset - offset) / itemSize);
        return Math.max(0, Math.min(total - 1, startIndex + numVisibleItems - 1));
      },
      initCache() {
        return void 0;
      },
      clearCache: true,
      validateProps() {
      }
    });
    var FixedSizeList$1 = FixedSizeList;
  
    const getItemFromCache$1 = (props, index, listCache) => {
      const { itemSize } = props;
      const { items, lastVisitedIndex } = listCache;
      if (index > lastVisitedIndex) {
        let offset = 0;
        if (lastVisitedIndex >= 0) {
          const item = items[lastVisitedIndex];
          offset = item.offset + item.size;
        }
        for (let i = lastVisitedIndex + 1; i <= index; i++) {
          const size = itemSize(i);
          items[i] = {
            offset,
            size
          };
          offset += size;
        }
        listCache.lastVisitedIndex = index;
      }
      return items[index];
    };
    const findItem$1 = (props, listCache, offset) => {
      const { items, lastVisitedIndex } = listCache;
      const lastVisitedOffset = lastVisitedIndex > 0 ? items[lastVisitedIndex].offset : 0;
      if (lastVisitedOffset >= offset) {
        return bs$1(props, listCache, 0, lastVisitedIndex, offset);
      }
      return es$1(props, listCache, Math.max(0, lastVisitedIndex), offset);
    };
    const bs$1 = (props, listCache, low, high, offset) => {
      while (low <= high) {
        const mid = low + Math.floor((high - low) / 2);
        const currentOffset = getItemFromCache$1(props, mid, listCache).offset;
        if (currentOffset === offset) {
          return mid;
        } else if (currentOffset < offset) {
          low = mid + 1;
        } else if (currentOffset > offset) {
          high = mid - 1;
        }
      }
      return Math.max(0, low - 1);
    };
    const es$1 = (props, listCache, index, offset) => {
      const { total } = props;
      let exponent = 1;
      while (index < total && getItemFromCache$1(props, index, listCache).offset < offset) {
        index += exponent;
        exponent *= 2;
      }
      return bs$1(props, listCache, Math.floor(index / 2), Math.min(index, total - 1), offset);
    };
    const getEstimatedTotalSize = ({ total }, { items, estimatedItemSize, lastVisitedIndex }) => {
      let totalSizeOfMeasuredItems = 0;
      if (lastVisitedIndex >= total) {
        lastVisitedIndex = total - 1;
      }
      if (lastVisitedIndex >= 0) {
        const item = items[lastVisitedIndex];
        totalSizeOfMeasuredItems = item.offset + item.size;
      }
      const numUnmeasuredItems = total - lastVisitedIndex - 1;
      const totalSizeOfUnmeasuredItems = numUnmeasuredItems * estimatedItemSize;
      return totalSizeOfMeasuredItems + totalSizeOfUnmeasuredItems;
    };
    const DynamicSizeList = createList$1({
      name: "ElDynamicSizeList",
      getItemOffset: (props, index, listCache) => getItemFromCache$1(props, index, listCache).offset,
      getItemSize: (_, index, { items }) => items[index].size,
      getEstimatedTotalSize,
      getOffset: (props, index, alignment, scrollOffset, listCache) => {
        const { height, layout, width } = props;
        const size = isHorizontal(layout) ? width : height;
        const item = getItemFromCache$1(props, index, listCache);
        const estimatedTotalSize = getEstimatedTotalSize(props, listCache);
        const maxOffset = Math.max(0, Math.min(estimatedTotalSize - size, item.offset));
        const minOffset = Math.max(0, item.offset - size + item.size);
        if (alignment === SMART_ALIGNMENT) {
          if (scrollOffset >= minOffset - size && scrollOffset <= maxOffset + size) {
            alignment = AUTO_ALIGNMENT;
          } else {
            alignment = CENTERED_ALIGNMENT;
          }
        }
        switch (alignment) {
          case START_ALIGNMENT: {
            return maxOffset;
          }
          case END_ALIGNMENT: {
            return minOffset;
          }
          case CENTERED_ALIGNMENT: {
            return Math.round(minOffset + (maxOffset - minOffset) / 2);
          }
          case AUTO_ALIGNMENT:
          default: {
            if (scrollOffset >= minOffset && scrollOffset <= maxOffset) {
              return scrollOffset;
            } else if (scrollOffset < minOffset) {
              return minOffset;
            } else {
              return maxOffset;
            }
          }
        }
      },
      getStartIndexForOffset: (props, offset, listCache) => findItem$1(props, listCache, offset),
      getStopIndexForStartIndex: (props, startIndex, scrollOffset, listCache) => {
        const { height, total, layout, width } = props;
        const size = isHorizontal(layout) ? width : height;
        const item = getItemFromCache$1(props, startIndex, listCache);
        const maxOffset = scrollOffset + size;
        let offset = item.offset + item.size;
        let stopIndex = startIndex;
        while (stopIndex < total - 1 && offset < maxOffset) {
          stopIndex++;
          offset += getItemFromCache$1(props, stopIndex, listCache).size;
        }
        return stopIndex;
      },
      initCache({ estimatedItemSize = DEFAULT_DYNAMIC_LIST_ITEM_SIZE }, instance) {
        const cache = {
          items: {},
          estimatedItemSize,
          lastVisitedIndex: -1
        };
        cache.clearCacheAfterIndex = (index, forceUpdate = true) => {
          var _a, _b;
          cache.lastVisitedIndex = Math.min(cache.lastVisitedIndex, index - 1);
          (_a = instance.exposed) == null ? void 0 : _a.getItemStyleCache(-1);
          if (forceUpdate) {
            (_b = instance.proxy) == null ? void 0 : _b.$forceUpdate();
          }
        };
        return cache;
      },
      clearCache: false,
      validateProps: ({ itemSize }) => {
      }
    });
    var DynamicSizeList$1 = DynamicSizeList;
  
    const useGridWheel = ({ atXEndEdge, atXStartEdge, atYEndEdge, atYStartEdge }, onWheelDelta) => {
      let frameHandle = null;
      let xOffset = 0;
      let yOffset = 0;
      const hasReachedEdge = (x, y) => {
        const xEdgeReached = x < 0 && atXStartEdge.value || x > 0 && atXEndEdge.value;
        const yEdgeReached = y < 0 && atYStartEdge.value || y > 0 && atYEndEdge.value;
        return xEdgeReached && yEdgeReached;
      };
      const onWheel = (e) => {
        cAF(frameHandle);
        let x = e.deltaX;
        let y = e.deltaY;
        if (Math.abs(x) > Math.abs(y)) {
          y = 0;
        } else {
          x = 0;
        }
        if (e.shiftKey && y !== 0) {
          x = y;
          y = 0;
        }
        if (hasReachedEdge(xOffset, yOffset) && hasReachedEdge(xOffset + x, yOffset + y))
          return;
        xOffset += x;
        yOffset += y;
        if (!isFirefox()) {
          e.preventDefault();
        }
        frameHandle = rAF(() => {
          onWheelDelta(xOffset, yOffset);
          xOffset = 0;
          yOffset = 0;
        });
      };
      return {
        hasReachedEdge,
        onWheel
      };
    };
  
    const createGrid = ({
      name,
      clearCache,
      getColumnPosition,
      getColumnStartIndexForOffset,
      getColumnStopIndexForStartIndex,
      getEstimatedTotalHeight,
      getEstimatedTotalWidth,
      getColumnOffset,
      getRowOffset,
      getRowPosition,
      getRowStartIndexForOffset,
      getRowStopIndexForStartIndex,
      initCache,
      injectToInstance,
      validateProps
    }) => {
      return vue.defineComponent({
        name: name != null ? name : "ElVirtualList",
        props: virtualizedGridProps,
        emits: [ITEM_RENDER_EVT, SCROLL_EVT],
        setup(props, { emit, expose, slots }) {
          const ns = useNamespace("vl");
          validateProps(props);
          const instance = vue.getCurrentInstance();
          const cache = vue.ref(initCache(props, instance));
          injectToInstance == null ? void 0 : injectToInstance(instance, cache);
          const windowRef = vue.ref();
          const hScrollbar = vue.ref();
          const vScrollbar = vue.ref();
          const innerRef = vue.ref(null);
          const states = vue.ref({
            isScrolling: false,
            scrollLeft: isNumber(props.initScrollLeft) ? props.initScrollLeft : 0,
            scrollTop: isNumber(props.initScrollTop) ? props.initScrollTop : 0,
            updateRequested: false,
            xAxisScrollDir: FORWARD,
            yAxisScrollDir: FORWARD
          });
          const getItemStyleCache = useCache();
          const parsedHeight = vue.computed(() => Number.parseInt(`${props.height}`, 10));
          const parsedWidth = vue.computed(() => Number.parseInt(`${props.width}`, 10));
          const columnsToRender = vue.computed(() => {
            const { totalColumn, totalRow, columnCache } = props;
            const { isScrolling, xAxisScrollDir, scrollLeft } = vue.unref(states);
            if (totalColumn === 0 || totalRow === 0) {
              return [0, 0, 0, 0];
            }
            const startIndex = getColumnStartIndexForOffset(props, scrollLeft, vue.unref(cache));
            const stopIndex = getColumnStopIndexForStartIndex(props, startIndex, scrollLeft, vue.unref(cache));
            const cacheBackward = !isScrolling || xAxisScrollDir === BACKWARD ? Math.max(1, columnCache) : 1;
            const cacheForward = !isScrolling || xAxisScrollDir === FORWARD ? Math.max(1, columnCache) : 1;
            return [
              Math.max(0, startIndex - cacheBackward),
              Math.max(0, Math.min(totalColumn - 1, stopIndex + cacheForward)),
              startIndex,
              stopIndex
            ];
          });
          const rowsToRender = vue.computed(() => {
            const { totalColumn, totalRow, rowCache } = props;
            const { isScrolling, yAxisScrollDir, scrollTop } = vue.unref(states);
            if (totalColumn === 0 || totalRow === 0) {
              return [0, 0, 0, 0];
            }
            const startIndex = getRowStartIndexForOffset(props, scrollTop, vue.unref(cache));
            const stopIndex = getRowStopIndexForStartIndex(props, startIndex, scrollTop, vue.unref(cache));
            const cacheBackward = !isScrolling || yAxisScrollDir === BACKWARD ? Math.max(1, rowCache) : 1;
            const cacheForward = !isScrolling || yAxisScrollDir === FORWARD ? Math.max(1, rowCache) : 1;
            return [
              Math.max(0, startIndex - cacheBackward),
              Math.max(0, Math.min(totalRow - 1, stopIndex + cacheForward)),
              startIndex,
              stopIndex
            ];
          });
          const estimatedTotalHeight = vue.computed(() => getEstimatedTotalHeight(props, vue.unref(cache)));
          const estimatedTotalWidth = vue.computed(() => getEstimatedTotalWidth(props, vue.unref(cache)));
          const windowStyle = vue.computed(() => {
            var _a;
            return [
              {
                position: "relative",
                overflow: "hidden",
                WebkitOverflowScrolling: "touch",
                willChange: "transform"
              },
              {
                direction: props.direction,
                height: isNumber(props.height) ? `${props.height}px` : props.height,
                width: isNumber(props.width) ? `${props.width}px` : props.width
              },
              (_a = props.style) != null ? _a : {}
            ];
          });
          const innerStyle = vue.computed(() => {
            const width = `${vue.unref(estimatedTotalWidth)}px`;
            const height = `${vue.unref(estimatedTotalHeight)}px`;
            return {
              height,
              pointerEvents: vue.unref(states).isScrolling ? "none" : void 0,
              width
            };
          });
          const emitEvents = () => {
            const { totalColumn, totalRow } = props;
            if (totalColumn > 0 && totalRow > 0) {
              const [
                columnCacheStart,
                columnCacheEnd,
                columnVisibleStart,
                columnVisibleEnd
              ] = vue.unref(columnsToRender);
              const [rowCacheStart, rowCacheEnd, rowVisibleStart, rowVisibleEnd] = vue.unref(rowsToRender);
              emit(ITEM_RENDER_EVT, {
                columnCacheStart,
                columnCacheEnd,
                rowCacheStart,
                rowCacheEnd,
                columnVisibleStart,
                columnVisibleEnd,
                rowVisibleStart,
                rowVisibleEnd
              });
            }
            const {
              scrollLeft,
              scrollTop,
              updateRequested,
              xAxisScrollDir,
              yAxisScrollDir
            } = vue.unref(states);
            emit(SCROLL_EVT, {
              xAxisScrollDir,
              scrollLeft,
              yAxisScrollDir,
              scrollTop,
              updateRequested
            });
          };
          const onScroll = (e) => {
            const {
              clientHeight,
              clientWidth,
              scrollHeight,
              scrollLeft,
              scrollTop,
              scrollWidth
            } = e.currentTarget;
            const _states = vue.unref(states);
            if (_states.scrollTop === scrollTop && _states.scrollLeft === scrollLeft) {
              return;
            }
            let _scrollLeft = scrollLeft;
            if (isRTL(props.direction)) {
              switch (getRTLOffsetType()) {
                case RTL_OFFSET_NAG:
                  _scrollLeft = -scrollLeft;
                  break;
                case RTL_OFFSET_POS_DESC:
                  _scrollLeft = scrollWidth - clientWidth - scrollLeft;
                  break;
              }
            }
            states.value = {
              ..._states,
              isScrolling: true,
              scrollLeft: _scrollLeft,
              scrollTop: Math.max(0, Math.min(scrollTop, scrollHeight - clientHeight)),
              updateRequested: true,
              xAxisScrollDir: getScrollDir(_states.scrollLeft, _scrollLeft),
              yAxisScrollDir: getScrollDir(_states.scrollTop, scrollTop)
            };
            vue.nextTick(() => resetIsScrolling());
            onUpdated();
            emitEvents();
          };
          const onVerticalScroll = (distance, totalSteps) => {
            const height = vue.unref(parsedHeight);
            const offset = (estimatedTotalHeight.value - height) / totalSteps * distance;
            scrollTo({
              scrollTop: Math.min(estimatedTotalHeight.value - height, offset)
            });
          };
          const onHorizontalScroll = (distance, totalSteps) => {
            const width = vue.unref(parsedWidth);
            const offset = (estimatedTotalWidth.value - width) / totalSteps * distance;
            scrollTo({
              scrollLeft: Math.min(estimatedTotalWidth.value - width, offset)
            });
          };
          const { onWheel } = useGridWheel({
            atXStartEdge: vue.computed(() => states.value.scrollLeft <= 0),
            atXEndEdge: vue.computed(() => states.value.scrollLeft >= estimatedTotalWidth.value),
            atYStartEdge: vue.computed(() => states.value.scrollTop <= 0),
            atYEndEdge: vue.computed(() => states.value.scrollTop >= estimatedTotalHeight.value)
          }, (x, y) => {
            var _a, _b, _c, _d;
            (_b = (_a = hScrollbar.value) == null ? void 0 : _a.onMouseUp) == null ? void 0 : _b.call(_a);
            (_d = (_c = hScrollbar.value) == null ? void 0 : _c.onMouseUp) == null ? void 0 : _d.call(_c);
            const width = vue.unref(parsedWidth);
            const height = vue.unref(parsedHeight);
            scrollTo({
              scrollLeft: Math.min(states.value.scrollLeft + x, estimatedTotalWidth.value - width),
              scrollTop: Math.min(states.value.scrollTop + y, estimatedTotalHeight.value - height)
            });
          });
          const scrollTo = ({
            scrollLeft = states.value.scrollLeft,
            scrollTop = states.value.scrollTop
          }) => {
            scrollLeft = Math.max(scrollLeft, 0);
            scrollTop = Math.max(scrollTop, 0);
            const _states = vue.unref(states);
            if (scrollTop === _states.scrollTop && scrollLeft === _states.scrollLeft) {
              return;
            }
            states.value = {
              ..._states,
              xAxisScrollDir: getScrollDir(_states.scrollLeft, scrollLeft),
              yAxisScrollDir: getScrollDir(_states.scrollTop, scrollTop),
              scrollLeft,
              scrollTop,
              updateRequested: true
            };
            vue.nextTick(() => resetIsScrolling());
            onUpdated();
            emitEvents();
          };
          const scrollToItem = (rowIndex = 0, columnIdx = 0, alignment = AUTO_ALIGNMENT) => {
            const _states = vue.unref(states);
            columnIdx = Math.max(0, Math.min(columnIdx, props.totalColumn - 1));
            rowIndex = Math.max(0, Math.min(rowIndex, props.totalRow - 1));
            const scrollBarWidth = getScrollBarWidth(ns.namespace.value);
            const _cache = vue.unref(cache);
            const estimatedHeight = getEstimatedTotalHeight(props, _cache);
            const estimatedWidth = getEstimatedTotalWidth(props, _cache);
            scrollTo({
              scrollLeft: getColumnOffset(props, columnIdx, alignment, _states.scrollLeft, _cache, estimatedWidth > props.width ? scrollBarWidth : 0),
              scrollTop: getRowOffset(props, rowIndex, alignment, _states.scrollTop, _cache, estimatedHeight > props.height ? scrollBarWidth : 0)
            });
          };
          const getItemStyle = (rowIndex, columnIndex) => {
            const { columnWidth, direction, rowHeight } = props;
            const itemStyleCache = getItemStyleCache.value(clearCache && columnWidth, clearCache && rowHeight, clearCache && direction);
            const key = `${rowIndex},${columnIndex}`;
            if (hasOwn(itemStyleCache, key)) {
              return itemStyleCache[key];
            } else {
              const [, left] = getColumnPosition(props, columnIndex, vue.unref(cache));
              const _cache = vue.unref(cache);
              const rtl = isRTL(direction);
              const [height, top] = getRowPosition(props, rowIndex, _cache);
              const [width] = getColumnPosition(props, columnIndex, _cache);
              itemStyleCache[key] = {
                position: "absolute",
                left: rtl ? void 0 : `${left}px`,
                right: rtl ? `${left}px` : void 0,
                top: `${top}px`,
                height: `${height}px`,
                width: `${width}px`
              };
              return itemStyleCache[key];
            }
          };
          const resetIsScrolling = () => {
            states.value.isScrolling = false;
            vue.nextTick(() => {
              getItemStyleCache.value(-1, null, null);
            });
          };
          vue.onMounted(() => {
            if (!isClient)
              return;
            const { initScrollLeft, initScrollTop } = props;
            const windowElement = vue.unref(windowRef);
            if (windowElement) {
              if (isNumber(initScrollLeft)) {
                windowElement.scrollLeft = initScrollLeft;
              }
              if (isNumber(initScrollTop)) {
                windowElement.scrollTop = initScrollTop;
              }
            }
            emitEvents();
          });
          const onUpdated = () => {
            const { direction } = props;
            const { scrollLeft, scrollTop, updateRequested } = vue.unref(states);
            const windowElement = vue.unref(windowRef);
            if (updateRequested && windowElement) {
              if (direction === RTL) {
                switch (getRTLOffsetType()) {
                  case RTL_OFFSET_NAG: {
                    windowElement.scrollLeft = -scrollLeft;
                    break;
                  }
                  case RTL_OFFSET_POS_ASC: {
                    windowElement.scrollLeft = scrollLeft;
                    break;
                  }
                  default: {
                    const { clientWidth, scrollWidth } = windowElement;
                    windowElement.scrollLeft = scrollWidth - clientWidth - scrollLeft;
                    break;
                  }
                }
              } else {
                windowElement.scrollLeft = Math.max(0, scrollLeft);
              }
              windowElement.scrollTop = Math.max(0, scrollTop);
            }
          };
          const { resetAfterColumnIndex, resetAfterRowIndex, resetAfter } = instance.proxy;
          expose({
            windowRef,
            innerRef,
            getItemStyleCache,
            scrollTo,
            scrollToItem,
            states,
            resetAfterColumnIndex,
            resetAfterRowIndex,
            resetAfter
          });
          const renderScrollbars = () => {
            const {
              scrollbarAlwaysOn,
              scrollbarStartGap,
              scrollbarEndGap,
              totalColumn,
              totalRow
            } = props;
            const width = vue.unref(parsedWidth);
            const height = vue.unref(parsedHeight);
            const estimatedWidth = vue.unref(estimatedTotalWidth);
            const estimatedHeight = vue.unref(estimatedTotalHeight);
            const { scrollLeft, scrollTop } = vue.unref(states);
            const horizontalScrollbar = vue.h(Scrollbar, {
              ref: hScrollbar,
              alwaysOn: scrollbarAlwaysOn,
              startGap: scrollbarStartGap,
              endGap: scrollbarEndGap,
              class: ns.e("horizontal"),
              clientSize: width,
              layout: "horizontal",
              onScroll: onHorizontalScroll,
              ratio: width * 100 / estimatedWidth,
              scrollFrom: scrollLeft / (estimatedWidth - width),
              total: totalRow,
              visible: true
            });
            const verticalScrollbar = vue.h(Scrollbar, {
              ref: vScrollbar,
              alwaysOn: scrollbarAlwaysOn,
              startGap: scrollbarStartGap,
              endGap: scrollbarEndGap,
              class: ns.e("vertical"),
              clientSize: height,
              layout: "vertical",
              onScroll: onVerticalScroll,
              ratio: height * 100 / estimatedHeight,
              scrollFrom: scrollTop / (estimatedHeight - height),
              total: totalColumn,
              visible: true
            });
            return {
              horizontalScrollbar,
              verticalScrollbar
            };
          };
          const renderItems = () => {
            var _a;
            const [columnStart, columnEnd] = vue.unref(columnsToRender);
            const [rowStart, rowEnd] = vue.unref(rowsToRender);
            const { data, totalColumn, totalRow, useIsScrolling, itemKey } = props;
            const children = [];
            if (totalRow > 0 && totalColumn > 0) {
              for (let row = rowStart; row <= rowEnd; row++) {
                for (let column = columnStart; column <= columnEnd; column++) {
                  children.push((_a = slots.default) == null ? void 0 : _a.call(slots, {
                    columnIndex: column,
                    data,
                    key: itemKey({ columnIndex: column, data, rowIndex: row }),
                    isScrolling: useIsScrolling ? vue.unref(states).isScrolling : void 0,
                    style: getItemStyle(row, column),
                    rowIndex: row
                  }));
                }
              }
            }
            return children;
          };
          const renderInner = () => {
            const Inner = vue.resolveDynamicComponent(props.innerElement);
            const children = renderItems();
            return [
              vue.h(Inner, {
                style: vue.unref(innerStyle),
                ref: innerRef
              }, !isString(Inner) ? {
                default: () => children
              } : children)
            ];
          };
          const renderWindow = () => {
            const Container = vue.resolveDynamicComponent(props.containerElement);
            const { horizontalScrollbar, verticalScrollbar } = renderScrollbars();
            const Inner = renderInner();
            return vue.h("div", {
              key: 0,
              class: ns.e("wrapper")
            }, [
              vue.h(Container, {
                class: props.className,
                style: vue.unref(windowStyle),
                onScroll,
                onWheel,
                ref: windowRef
              }, !isString(Container) ? { default: () => Inner } : Inner),
              horizontalScrollbar,
              verticalScrollbar
            ]);
          };
          return renderWindow;
        }
      });
    };
    var createGrid$1 = createGrid;
  
    const FixedSizeGrid = createGrid$1({
      name: "ElFixedSizeGrid",
      getColumnPosition: ({ columnWidth }, index) => [
        columnWidth,
        index * columnWidth
      ],
      getRowPosition: ({ rowHeight }, index) => [
        rowHeight,
        index * rowHeight
      ],
      getEstimatedTotalHeight: ({ totalRow, rowHeight }) => rowHeight * totalRow,
      getEstimatedTotalWidth: ({ totalColumn, columnWidth }) => columnWidth * totalColumn,
      getColumnOffset: ({ totalColumn, columnWidth, width }, columnIndex, alignment, scrollLeft, _, scrollBarWidth) => {
        width = Number(width);
        const lastColumnOffset = Math.max(0, totalColumn * columnWidth - width);
        const maxOffset = Math.min(lastColumnOffset, columnIndex * columnWidth);
        const minOffset = Math.max(0, columnIndex * columnWidth - width + scrollBarWidth + columnWidth);
        if (alignment === "smart") {
          if (scrollLeft >= minOffset - width && scrollLeft <= maxOffset + width) {
            alignment = AUTO_ALIGNMENT;
          } else {
            alignment = CENTERED_ALIGNMENT;
          }
        }
        switch (alignment) {
          case START_ALIGNMENT:
            return maxOffset;
          case END_ALIGNMENT:
            return minOffset;
          case CENTERED_ALIGNMENT: {
            const middleOffset = Math.round(minOffset + (maxOffset - minOffset) / 2);
            if (middleOffset < Math.ceil(width / 2)) {
              return 0;
            } else if (middleOffset > lastColumnOffset + Math.floor(width / 2)) {
              return lastColumnOffset;
            } else {
              return middleOffset;
            }
          }
          case AUTO_ALIGNMENT:
          default:
            if (scrollLeft >= minOffset && scrollLeft <= maxOffset) {
              return scrollLeft;
            } else if (minOffset > maxOffset) {
              return minOffset;
            } else if (scrollLeft < minOffset) {
              return minOffset;
            } else {
              return maxOffset;
            }
        }
      },
      getRowOffset: ({ rowHeight, height, totalRow }, rowIndex, align, scrollTop, _, scrollBarWidth) => {
        height = Number(height);
        const lastRowOffset = Math.max(0, totalRow * rowHeight - height);
        const maxOffset = Math.min(lastRowOffset, rowIndex * rowHeight);
        const minOffset = Math.max(0, rowIndex * rowHeight - height + scrollBarWidth + rowHeight);
        if (align === SMART_ALIGNMENT) {
          if (scrollTop >= minOffset - height && scrollTop <= maxOffset + height) {
            align = AUTO_ALIGNMENT;
          } else {
            align = CENTERED_ALIGNMENT;
          }
        }
        switch (align) {
          case START_ALIGNMENT:
            return maxOffset;
          case END_ALIGNMENT:
            return minOffset;
          case CENTERED_ALIGNMENT: {
            const middleOffset = Math.round(minOffset + (maxOffset - minOffset) / 2);
            if (middleOffset < Math.ceil(height / 2)) {
              return 0;
            } else if (middleOffset > lastRowOffset + Math.floor(height / 2)) {
              return lastRowOffset;
            } else {
              return middleOffset;
            }
          }
          case AUTO_ALIGNMENT:
          default:
            if (scrollTop >= minOffset && scrollTop <= maxOffset) {
              return scrollTop;
            } else if (minOffset > maxOffset) {
              return minOffset;
            } else if (scrollTop < minOffset) {
              return minOffset;
            } else {
              return maxOffset;
            }
        }
      },
      getColumnStartIndexForOffset: ({ columnWidth, totalColumn }, scrollLeft) => Math.max(0, Math.min(totalColumn - 1, Math.floor(scrollLeft / columnWidth))),
      getColumnStopIndexForStartIndex: ({ columnWidth, totalColumn, width }, startIndex, scrollLeft) => {
        const left = startIndex * columnWidth;
        const visibleColumnsCount = Math.ceil((width + scrollLeft - left) / columnWidth);
        return Math.max(0, Math.min(totalColumn - 1, startIndex + visibleColumnsCount - 1));
      },
      getRowStartIndexForOffset: ({ rowHeight, totalRow }, scrollTop) => Math.max(0, Math.min(totalRow - 1, Math.floor(scrollTop / rowHeight))),
      getRowStopIndexForStartIndex: ({ rowHeight, totalRow, height }, startIndex, scrollTop) => {
        const top = startIndex * rowHeight;
        const numVisibleRows = Math.ceil((height + scrollTop - top) / rowHeight);
        return Math.max(0, Math.min(totalRow - 1, startIndex + numVisibleRows - 1));
      },
      initCache: () => void 0,
      clearCache: true,
      validateProps: ({ columnWidth, rowHeight }) => {
      }
    });
    var FixedSizeGrid$1 = FixedSizeGrid;
  
    const { max, min, floor } = Math;
    const ACCESS_SIZER_KEY_MAP = {
      column: "columnWidth",
      row: "rowHeight"
    };
    const ACCESS_LAST_VISITED_KEY_MAP = {
      column: "lastVisitedColumnIndex",
      row: "lastVisitedRowIndex"
    };
    const getItemFromCache = (props, index, gridCache, type) => {
      const [cachedItems, sizer, lastVisited] = [
        gridCache[type],
        props[ACCESS_SIZER_KEY_MAP[type]],
        gridCache[ACCESS_LAST_VISITED_KEY_MAP[type]]
      ];
      if (index > lastVisited) {
        let offset = 0;
        if (lastVisited >= 0) {
          const item = cachedItems[lastVisited];
          offset = item.offset + item.size;
        }
        for (let i = lastVisited + 1; i <= index; i++) {
          const size = sizer(i);
          cachedItems[i] = {
            offset,
            size
          };
          offset += size;
        }
        gridCache[ACCESS_LAST_VISITED_KEY_MAP[type]] = index;
      }
      return cachedItems[index];
    };
    const bs = (props, gridCache, low, high, offset, type) => {
      while (low <= high) {
        const mid = low + floor((high - low) / 2);
        const currentOffset = getItemFromCache(props, mid, gridCache, type).offset;
        if (currentOffset === offset) {
          return mid;
        } else if (currentOffset < offset) {
          low = mid + 1;
        } else {
          high = mid - 1;
        }
      }
      return max(0, low - 1);
    };
    const es = (props, gridCache, idx, offset, type) => {
      const total = type === "column" ? props.totalColumn : props.totalRow;
      let exponent = 1;
      while (idx < total && getItemFromCache(props, idx, gridCache, type).offset < offset) {
        idx += exponent;
        exponent *= 2;
      }
      return bs(props, gridCache, floor(idx / 2), min(idx, total - 1), offset, type);
    };
    const findItem = (props, gridCache, offset, type) => {
      const [cache, lastVisitedIndex] = [
        gridCache[type],
        gridCache[ACCESS_LAST_VISITED_KEY_MAP[type]]
      ];
      const lastVisitedItemOffset = lastVisitedIndex > 0 ? cache[lastVisitedIndex].offset : 0;
      if (lastVisitedItemOffset >= offset) {
        return bs(props, gridCache, 0, lastVisitedIndex, offset, type);
      }
      return es(props, gridCache, max(0, lastVisitedIndex), offset, type);
    };
    const getEstimatedTotalHeight = ({ totalRow }, { estimatedRowHeight, lastVisitedRowIndex, row }) => {
      let sizeOfVisitedRows = 0;
      if (lastVisitedRowIndex >= totalRow) {
        lastVisitedRowIndex = totalRow - 1;
      }
      if (lastVisitedRowIndex >= 0) {
        const item = row[lastVisitedRowIndex];
        sizeOfVisitedRows = item.offset + item.size;
      }
      const unvisitedItems = totalRow - lastVisitedRowIndex - 1;
      const sizeOfUnvisitedItems = unvisitedItems * estimatedRowHeight;
      return sizeOfVisitedRows + sizeOfUnvisitedItems;
    };
    const getEstimatedTotalWidth = ({ totalColumn }, { column, estimatedColumnWidth, lastVisitedColumnIndex }) => {
      let sizeOfVisitedColumns = 0;
      if (lastVisitedColumnIndex > totalColumn) {
        lastVisitedColumnIndex = totalColumn - 1;
      }
      if (lastVisitedColumnIndex >= 0) {
        const item = column[lastVisitedColumnIndex];
        sizeOfVisitedColumns = item.offset + item.size;
      }
      const unvisitedItems = totalColumn - lastVisitedColumnIndex - 1;
      const sizeOfUnvisitedItems = unvisitedItems * estimatedColumnWidth;
      return sizeOfVisitedColumns + sizeOfUnvisitedItems;
    };
    const ACCESS_ESTIMATED_SIZE_KEY_MAP = {
      column: getEstimatedTotalWidth,
      row: getEstimatedTotalHeight
    };
    const getOffset$1 = (props, index, alignment, scrollOffset, cache, type, scrollBarWidth) => {
      const [size, estimatedSizeAssociates] = [
        type === "row" ? props.height : props.width,
        ACCESS_ESTIMATED_SIZE_KEY_MAP[type]
      ];
      const item = getItemFromCache(props, index, cache, type);
      const estimatedSize = estimatedSizeAssociates(props, cache);
      const maxOffset = max(0, min(estimatedSize - size, item.offset));
      const minOffset = max(0, item.offset - size + scrollBarWidth + item.size);
      if (alignment === SMART_ALIGNMENT) {
        if (scrollOffset >= minOffset - size && scrollOffset <= maxOffset + size) {
          alignment = AUTO_ALIGNMENT;
        } else {
          alignment = CENTERED_ALIGNMENT;
        }
      }
      switch (alignment) {
        case START_ALIGNMENT: {
          return maxOffset;
        }
        case END_ALIGNMENT: {
          return minOffset;
        }
        case CENTERED_ALIGNMENT: {
          return Math.round(minOffset + (maxOffset - minOffset) / 2);
        }
        case AUTO_ALIGNMENT:
        default: {
          if (scrollOffset >= minOffset && scrollOffset <= maxOffset) {
            return scrollOffset;
          } else if (minOffset > maxOffset) {
            return minOffset;
          } else if (scrollOffset < minOffset) {
            return minOffset;
          } else {
            return maxOffset;
          }
        }
      }
    };
    const DynamicSizeGrid = createGrid$1({
      name: "ElDynamicSizeGrid",
      getColumnPosition: (props, idx, cache) => {
        const item = getItemFromCache(props, idx, cache, "column");
        return [item.size, item.offset];
      },
      getRowPosition: (props, idx, cache) => {
        const item = getItemFromCache(props, idx, cache, "row");
        return [item.size, item.offset];
      },
      getColumnOffset: (props, columnIndex, alignment, scrollLeft, cache, scrollBarWidth) => getOffset$1(props, columnIndex, alignment, scrollLeft, cache, "column", scrollBarWidth),
      getRowOffset: (props, rowIndex, alignment, scrollTop, cache, scrollBarWidth) => getOffset$1(props, rowIndex, alignment, scrollTop, cache, "row", scrollBarWidth),
      getColumnStartIndexForOffset: (props, scrollLeft, cache) => findItem(props, cache, scrollLeft, "column"),
      getColumnStopIndexForStartIndex: (props, startIndex, scrollLeft, cache) => {
        const item = getItemFromCache(props, startIndex, cache, "column");
        const maxOffset = scrollLeft + props.width;
        let offset = item.offset + item.size;
        let stopIndex = startIndex;
        while (stopIndex < props.totalColumn - 1 && offset < maxOffset) {
          stopIndex++;
          offset += getItemFromCache(props, startIndex, cache, "column").size;
        }
        return stopIndex;
      },
      getEstimatedTotalHeight,
      getEstimatedTotalWidth,
      getRowStartIndexForOffset: (props, scrollTop, cache) => findItem(props, cache, scrollTop, "row"),
      getRowStopIndexForStartIndex: (props, startIndex, scrollTop, cache) => {
        const { totalRow, height } = props;
        const item = getItemFromCache(props, startIndex, cache, "row");
        const maxOffset = scrollTop + height;
        let offset = item.size + item.offset;
        let stopIndex = startIndex;
        while (stopIndex < totalRow - 1 && offset < maxOffset) {
          stopIndex++;
          offset += getItemFromCache(props, stopIndex, cache, "row").size;
        }
        return stopIndex;
      },
      injectToInstance: (instance, cache) => {
        const resetAfter = ({ columnIndex, rowIndex }, forceUpdate) => {
          var _a, _b;
          forceUpdate = isUndefined(forceUpdate) ? true : forceUpdate;
          if (isNumber(columnIndex)) {
            cache.value.lastVisitedColumnIndex = Math.min(cache.value.lastVisitedColumnIndex, columnIndex - 1);
          }
          if (isNumber(rowIndex)) {
            cache.value.lastVisitedRowIndex = Math.min(cache.value.lastVisitedRowIndex, rowIndex - 1);
          }
          (_a = instance.exposed) == null ? void 0 : _a.getItemStyleCache.value(-1, null, null);
          if (forceUpdate)
            (_b = instance.proxy) == null ? void 0 : _b.$forceUpdate();
        };
        const resetAfterColumnIndex = (columnIndex, forceUpdate) => {
          resetAfter({
            columnIndex
          }, forceUpdate);
        };
        const resetAfterRowIndex = (rowIndex, forceUpdate) => {
          resetAfter({
            rowIndex
          }, forceUpdate);
        };
        Object.assign(instance.proxy, {
          resetAfterColumnIndex,
          resetAfterRowIndex,
          resetAfter
        });
      },
      initCache: ({
        estimatedColumnWidth = DEFAULT_DYNAMIC_LIST_ITEM_SIZE,
        estimatedRowHeight = DEFAULT_DYNAMIC_LIST_ITEM_SIZE
      }) => {
        const cache = {
          column: {},
          estimatedColumnWidth,
          estimatedRowHeight,
          lastVisitedColumnIndex: -1,
          lastVisitedRowIndex: -1,
          row: {}
        };
        return cache;
      },
      clearCache: false,
      validateProps: ({ columnWidth, rowHeight }) => {
      }
    });
    var DynamicSizeGrid$1 = DynamicSizeGrid;
  
    const _sfc_main$A = vue.defineComponent({
      props: {
        item: {
          type: Object,
          required: true
        },
        style: Object,
        height: Number
      },
      setup() {
        const ns = useNamespace("select");
        return {
          ns
        };
      }
    });
    function _sfc_render$7(_ctx, _cache, $props, $setup, $data, $options) {
      return _ctx.item.isTitle ? (vue.openBlock(), vue.createElementBlock("div", {
        key: 0,
        class: vue.normalizeClass(_ctx.ns.be("group", "title")),
        style: vue.normalizeStyle([_ctx.style, { lineHeight: `${_ctx.height}px` }])
      }, vue.toDisplayString(_ctx.item.label), 7)) : (vue.openBlock(), vue.createElementBlock("div", {
        key: 1,
        class: vue.normalizeClass(_ctx.ns.be("group", "split")),
        style: vue.normalizeStyle(_ctx.style)
      }, [
        vue.createElementVNode("span", {
          class: vue.normalizeClass(_ctx.ns.be("group", "split-dash")),
          style: vue.normalizeStyle({ top: `${_ctx.height / 2}px` })
        }, null, 6)
      ], 6));
    }
    var GroupItem = /* @__PURE__ */ _export_sfc(_sfc_main$A, [["render", _sfc_render$7], ["__file", "group-item.vue"]]);
  
    function useOption(props, { emit }) {
      return {
        hoverItem: () => {
          if (!props.disabled) {
            emit("hover", props.index);
          }
        },
        selectOptionClick: () => {
          if (!props.disabled) {
            emit("select", props.item, props.index);
          }
        }
      };
    }
  
    const SelectProps = {
      allowCreate: Boolean,
      autocomplete: {
        type: String,
        default: "none"
      },
      automaticDropdown: Boolean,
      clearable: Boolean,
      clearIcon: {
        type: [String, Object],
        default: circle_close_default
      },
      effect: {
        type: String,
        default: "light"
      },
      collapseTags: Boolean,
      collapseTagsTooltip: {
        type: Boolean,
        default: false
      },
      defaultFirstOption: Boolean,
      disabled: Boolean,
      estimatedOptionHeight: {
        type: Number,
        default: void 0
      },
      filterable: Boolean,
      filterMethod: Function,
      height: {
        type: Number,
        default: 170
      },
      itemHeight: {
        type: Number,
        default: 34
      },
      id: String,
      loading: Boolean,
      loadingText: String,
      label: String,
      modelValue: [Array, String, Number, Boolean, Object],
      multiple: Boolean,
      multipleLimit: {
        type: Number,
        default: 0
      },
      name: String,
      noDataText: String,
      noMatchText: String,
      remoteMethod: Function,
      reserveKeyword: {
        type: Boolean,
        default: true
      },
      options: {
        type: Array,
        required: true
      },
      placeholder: {
        type: String
      },
      teleported: useTooltipContentProps.teleported,
      persistent: {
        type: Boolean,
        default: true
      },
      popperClass: {
        type: String,
        default: ""
      },
      popperOptions: {
        type: Object,
        default: () => ({})
      },
      remote: Boolean,
      size: {
        type: String,
        validator: isValidComponentSize
      },
      valueKey: {
        type: String,
        default: "value"
      },
      scrollbarAlwaysOn: {
        type: Boolean,
        default: false
      },
      validateEvent: {
        type: Boolean,
        default: true
      },
      placement: {
        type: definePropType(String),
        values: Ee,
        default: "bottom-start"
      }
    };
    const OptionProps = {
      data: Array,
      disabled: Boolean,
      hovering: Boolean,
      item: Object,
      index: Number,
      style: Object,
      selected: Boolean,
      created: Boolean
    };
  
    const _sfc_main$z = vue.defineComponent({
      props: OptionProps,
      emits: ["select", "hover"],
      setup(props, { emit }) {
        const ns = useNamespace("select");
        const { hoverItem, selectOptionClick } = useOption(props, { emit });
        return {
          ns,
          hoverItem,
          selectOptionClick
        };
      }
    });
    const _hoisted_1$h = ["aria-selected"];
    function _sfc_render$6(_ctx, _cache, $props, $setup, $data, $options) {
      return vue.openBlock(), vue.createElementBlock("li", {
        "aria-selected": _ctx.selected,
        style: vue.normalizeStyle(_ctx.style),
        class: vue.normalizeClass([
          _ctx.ns.be("dropdown", "option-item"),
          _ctx.ns.is("selected", _ctx.selected),
          _ctx.ns.is("disabled", _ctx.disabled),
          _ctx.ns.is("created", _ctx.created),
          { hover: _ctx.hovering }
        ]),
        onMouseenter: _cache[0] || (_cache[0] = (...args) => _ctx.hoverItem && _ctx.hoverItem(...args)),
        onClick: _cache[1] || (_cache[1] = vue.withModifiers((...args) => _ctx.selectOptionClick && _ctx.selectOptionClick(...args), ["stop"]))
      }, [
        vue.renderSlot(_ctx.$slots, "default", {
          item: _ctx.item,
          index: _ctx.index,
          disabled: _ctx.disabled
        }, () => [
          vue.createElementVNode("span", null, vue.toDisplayString(_ctx.item.label), 1)
        ])
      ], 46, _hoisted_1$h);
    }
    var OptionItem = /* @__PURE__ */ _export_sfc(_sfc_main$z, [["render", _sfc_render$6], ["__file", "option-item.vue"]]);
  
    const selectV2InjectionKey = "ElSelectV2Injection";
  
    var ElSelectMenu = vue.defineComponent({
      name: "ElSelectDropdown",
      props: {
        data: {
          type: Array,
          required: true
        },
        hoveringIndex: Number,
        width: Number
      },
      setup(props, {
        slots,
        expose
      }) {
        const select = vue.inject(selectV2InjectionKey);
        const ns = useNamespace("select");
        const cachedHeights = vue.ref([]);
        const listRef = vue.ref();
        const size = vue.computed(() => props.data.length);
        vue.watch(() => size.value, () => {
          var _a, _b;
          (_b = (_a = select.popper.value).updatePopper) == null ? void 0 : _b.call(_a);
        });
        const isSized = vue.computed(() => isUndefined(select.props.estimatedOptionHeight));
        const listProps = vue.computed(() => {
          if (isSized.value) {
            return {
              itemSize: select.props.itemHeight
            };
          }
          return {
            estimatedSize: select.props.estimatedOptionHeight,
            itemSize: (idx) => cachedHeights.value[idx]
          };
        });
        const contains = (arr = [], target) => {
          const {
            props: {
              valueKey
            }
          } = select;
          if (!isObject$1(target)) {
            return arr.includes(target);
          }
          return arr && arr.some((item) => {
            return get(item, valueKey) === get(target, valueKey);
          });
        };
        const isEqual = (selected, target) => {
          if (!isObject$1(target)) {
            return selected === target;
          } else {
            const {
              valueKey
            } = select.props;
            return get(selected, valueKey) === get(target, valueKey);
          }
        };
        const isItemSelected = (modelValue, target) => {
          const {
            valueKey
          } = select.props;
          if (select.props.multiple) {
            return contains(modelValue, get(target, valueKey));
          }
          return isEqual(modelValue, get(target, valueKey));
        };
        const isItemDisabled = (modelValue, selected) => {
          const {
            disabled,
            multiple,
            multipleLimit
          } = select.props;
          return disabled || !selected && (multiple ? multipleLimit > 0 && modelValue.length >= multipleLimit : false);
        };
        const isItemHovering = (target) => props.hoveringIndex === target;
        const scrollToItem = (index) => {
          const list = listRef.value;
          if (list) {
            list.scrollToItem(index);
          }
        };
        const resetScrollTop = () => {
          const list = listRef.value;
          if (list) {
            list.resetScrollTop();
          }
        };
        expose({
          listRef,
          isSized,
          isItemDisabled,
          isItemHovering,
          isItemSelected,
          scrollToItem,
          resetScrollTop
        });
        const Item = (itemProps) => {
          const {
            index,
            data,
            style
          } = itemProps;
          const sized = vue.unref(isSized);
          const {
            itemSize,
            estimatedSize
          } = vue.unref(listProps);
          const {
            modelValue
          } = select.props;
          const {
            onSelect,
            onHover
          } = select;
          const item = data[index];
          if (item.type === "Group") {
            return vue.createVNode(GroupItem, {
              "item": item,
              "style": style,
              "height": sized ? itemSize : estimatedSize
            }, null);
          }
          const isSelected = isItemSelected(modelValue, item);
          const isDisabled = isItemDisabled(modelValue, isSelected);
          const isHovering = isItemHovering(index);
          return vue.createVNode(OptionItem, vue.mergeProps(itemProps, {
            "selected": isSelected,
            "disabled": item.disabled || isDisabled,
            "created": !!item.created,
            "hovering": isHovering,
            "item": item,
            "onSelect": onSelect,
            "onHover": onHover
          }), {
            default: (props2) => {
              var _a;
              return ((_a = slots.default) == null ? void 0 : _a.call(slots, props2)) || vue.createVNode("span", null, [item.label]);
            }
          });
        };
        const {
          onKeyboardNavigate,
          onKeyboardSelect
        } = select;
        const onForward = () => {
          onKeyboardNavigate("forward");
        };
        const onBackward = () => {
          onKeyboardNavigate("backward");
        };
        const onEscOrTab = () => {
          select.expanded = false;
        };
        const onKeydown = (e) => {
          const {
            code
          } = e;
          const {
            tab,
            esc,
            down,
            up,
            enter
          } = EVENT_CODE;
          if (code !== tab) {
            e.preventDefault();
            e.stopPropagation();
          }
          switch (code) {
            case tab:
            case esc: {
              onEscOrTab();
              break;
            }
            case down: {
              onForward();
              break;
            }
            case up: {
              onBackward();
              break;
            }
            case enter: {
              onKeyboardSelect();
              break;
            }
          }
        };
        return () => {
          var _a;
          const {
            data,
            width
          } = props;
          const {
            height,
            multiple,
            scrollbarAlwaysOn
          } = select.props;
          if (data.length === 0) {
            return vue.createVNode("div", {
              "class": ns.b("dropdown"),
              "style": {
                width: `${width}px`
              }
            }, [(_a = slots.empty) == null ? void 0 : _a.call(slots)]);
          }
          const List = vue.unref(isSized) ? FixedSizeList$1 : DynamicSizeList$1;
          return vue.createVNode("div", {
            "class": [ns.b("dropdown"), ns.is("multiple", multiple)]
          }, [vue.createVNode(List, vue.mergeProps({
            "ref": listRef
          }, vue.unref(listProps), {
            "className": ns.be("dropdown", "list"),
            "scrollbarAlwaysOn": scrollbarAlwaysOn,
            "data": data,
            "height": height,
            "width": width,
            "total": data.length,
            "onKeydown": onKeydown
          }), {
            default: (props2) => vue.createVNode(Item, props2, null)
          })]);
        };
      }
    });
  
    function useAllowCreate(props, states) {
      const createOptionCount = vue.ref(0);
      const cachedSelectedOption = vue.ref(null);
      const enableAllowCreateMode = vue.computed(() => {
        return props.allowCreate && props.filterable;
      });
      function hasExistingOption(query) {
        const hasValue = (option) => option.value === query;
        return props.options && props.options.some(hasValue) || states.createdOptions.some(hasValue);
      }
      function selectNewOption(option) {
        if (!enableAllowCreateMode.value) {
          return;
        }
        if (props.multiple && option.created) {
          createOptionCount.value++;
        } else {
          cachedSelectedOption.value = option;
        }
      }
      function createNewOption(query) {
        if (enableAllowCreateMode.value) {
          if (query && query.length > 0 && !hasExistingOption(query)) {
            const newOption = {
              value: query,
              label: query,
              created: true,
              disabled: false
            };
            if (states.createdOptions.length >= createOptionCount.value) {
              states.createdOptions[createOptionCount.value] = newOption;
            } else {
              states.createdOptions.push(newOption);
            }
          } else {
            if (props.multiple) {
              states.createdOptions.length = createOptionCount.value;
            } else {
              const selectedOption = cachedSelectedOption.value;
              states.createdOptions.length = 0;
              if (selectedOption && selectedOption.created) {
                states.createdOptions.push(selectedOption);
              }
            }
          }
        }
      }
      function removeNewOption(option) {
        if (!enableAllowCreateMode.value || !option || !option.created || option.created && props.reserveKeyword && states.inputValue === option.label) {
          return;
        }
        const idx = states.createdOptions.findIndex((it) => it.value === option.value);
        if (~idx) {
          states.createdOptions.splice(idx, 1);
          createOptionCount.value--;
        }
      }
      function clearAllNewOption() {
        if (enableAllowCreateMode.value) {
          states.createdOptions.length = 0;
          createOptionCount.value = 0;
        }
      }
      return {
        createNewOption,
        removeNewOption,
        selectNewOption,
        clearAllNewOption
      };
    }
  
    const flattenOptions = (options) => {
      const flattened = [];
      options.forEach((option) => {
        if (isArray(option.options)) {
          flattened.push({
            label: option.label,
            isTitle: true,
            type: "Group"
          });
          option.options.forEach((o) => {
            flattened.push(o);
          });
          flattened.push({
            type: "Group"
          });
        } else {
          flattened.push(option);
        }
      });
      return flattened;
    };
  
    function useInput(handleInput) {
      const isComposing = vue.ref(false);
      const handleCompositionStart = () => {
        isComposing.value = true;
      };
      const handleCompositionUpdate = (event) => {
        const text = event.target.value;
        const lastCharacter = text[text.length - 1] || "";
        isComposing.value = !isKorean(lastCharacter);
      };
      const handleCompositionEnd = (event) => {
        if (isComposing.value) {
          isComposing.value = false;
          if (isFunction(handleInput)) {
            handleInput(event);
          }
        }
      };
      return {
        handleCompositionStart,
        handleCompositionUpdate,
        handleCompositionEnd
      };
    }
  
    const DEFAULT_INPUT_PLACEHOLDER = "";
    const MINIMUM_INPUT_WIDTH = 11;
    const TAG_BASE_WIDTH = {
      larget: 51,
      default: 42,
      small: 33
    };
    const useSelect$1 = (props, emit) => {
      const { t } = useLocale();
      const nsSelectV2 = useNamespace("select-v2");
      const nsInput = useNamespace("input");
      const { form: elForm, formItem: elFormItem } = useFormItem();
      const states = vue.reactive({
        inputValue: DEFAULT_INPUT_PLACEHOLDER,
        displayInputValue: DEFAULT_INPUT_PLACEHOLDER,
        calculatedWidth: 0,
        cachedPlaceholder: "",
        cachedOptions: [],
        createdOptions: [],
        createdLabel: "",
        createdSelected: false,
        currentPlaceholder: "",
        hoveringIndex: -1,
        comboBoxHovering: false,
        isOnComposition: false,
        isSilentBlur: false,
        isComposing: false,
        inputLength: 20,
        selectWidth: 200,
        initialInputHeight: 0,
        previousQuery: null,
        previousValue: void 0,
        query: "",
        selectedLabel: "",
        softFocus: false,
        tagInMultiLine: false
      });
      const selectedIndex = vue.ref(-1);
      const popperSize = vue.ref(-1);
      const controlRef = vue.ref(null);
      const inputRef = vue.ref(null);
      const menuRef = vue.ref(null);
      const popper = vue.ref(null);
      const selectRef = vue.ref(null);
      const selectionRef = vue.ref(null);
      const calculatorRef = vue.ref(null);
      const expanded = vue.ref(false);
      const selectDisabled = vue.computed(() => props.disabled || (elForm == null ? void 0 : elForm.disabled));
      const popupHeight = vue.computed(() => {
        const totalHeight = filteredOptions.value.length * 34;
        return totalHeight > props.height ? props.height : totalHeight;
      });
      const hasModelValue = vue.computed(() => {
        return !isNil(props.modelValue);
      });
      const showClearBtn = vue.computed(() => {
        const hasValue = props.multiple ? Array.isArray(props.modelValue) && props.modelValue.length > 0 : hasModelValue.value;
        const criteria = props.clearable && !selectDisabled.value && states.comboBoxHovering && hasValue;
        return criteria;
      });
      const iconComponent = vue.computed(() => props.remote && props.filterable ? "" : arrow_up_default);
      const iconReverse = vue.computed(() => iconComponent.value && nsSelectV2.is("reverse", expanded.value));
      const validateState = vue.computed(() => (elFormItem == null ? void 0 : elFormItem.validateState) || "");
      const validateIcon = vue.computed(() => ValidateComponentsMap[validateState.value]);
      const debounce$1 = vue.computed(() => props.remote ? 300 : 0);
      const emptyText = vue.computed(() => {
        const options = filteredOptions.value;
        if (props.loading) {
          return props.loadingText || t("el.select.loading");
        } else {
          if (props.remote && states.inputValue === "" && options.length === 0)
            return false;
          if (props.filterable && states.inputValue && options.length > 0) {
            return props.noMatchText || t("el.select.noMatch");
          }
          if (options.length === 0) {
            return props.noDataText || t("el.select.noData");
          }
        }
        return null;
      });
      const filteredOptions = vue.computed(() => {
        const isValidOption = (o) => {
          var _a;
          const query = states.inputValue;
          const containsQueryString = query ? (_a = o.label) == null ? void 0 : _a.includes(query) : true;
          return containsQueryString;
        };
        if (props.loading) {
          return [];
        }
        return flattenOptions(props.options.concat(states.createdOptions).map((v) => {
          if (isArray(v.options)) {
            const filtered = v.options.filter(isValidOption);
            if (filtered.length > 0) {
              return {
                ...v,
                options: filtered
              };
            }
          } else {
            if (props.remote || isValidOption(v)) {
              return v;
            }
          }
          return null;
        }).filter((v) => v !== null));
      });
      const optionsAllDisabled = vue.computed(() => filteredOptions.value.every((option) => option.disabled));
      const selectSize = useSize();
      const collapseTagSize = vue.computed(() => selectSize.value === "small" ? "small" : "default");
      const tagMaxWidth = vue.computed(() => {
        const select = selectionRef.value;
        const size = collapseTagSize.value || "default";
        const paddingLeft = select ? Number.parseInt(getComputedStyle(select).paddingLeft) : 0;
        const paddingRight = select ? Number.parseInt(getComputedStyle(select).paddingRight) : 0;
        return states.selectWidth - paddingRight - paddingLeft - TAG_BASE_WIDTH[size];
      });
      const calculatePopperSize = () => {
        var _a;
        popperSize.value = ((_a = selectRef.value) == null ? void 0 : _a.offsetWidth) || 200;
      };
      const inputWrapperStyle = vue.computed(() => {
        return {
          width: `${states.calculatedWidth === 0 ? MINIMUM_INPUT_WIDTH : Math.ceil(states.calculatedWidth) + MINIMUM_INPUT_WIDTH}px`
        };
      });
      const shouldShowPlaceholder = vue.computed(() => {
        if (isArray(props.modelValue)) {
          return props.modelValue.length === 0 && !states.displayInputValue;
        }
        return props.filterable ? states.displayInputValue.length === 0 : true;
      });
      const currentPlaceholder = vue.computed(() => {
        const _placeholder = props.placeholder || t("el.select.placeholder");
        return props.multiple || isNil(props.modelValue) ? _placeholder : states.selectedLabel;
      });
      const popperRef = vue.computed(() => {
        var _a, _b;
        return (_b = (_a = popper.value) == null ? void 0 : _a.popperRef) == null ? void 0 : _b.contentRef;
      });
      const indexRef = vue.computed(() => {
        if (props.multiple) {
          const len = props.modelValue.length;
          if (props.modelValue.length > 0) {
            return filteredOptions.value.findIndex((o) => o.value === props.modelValue[len - 1]);
          }
        } else {
          if (props.modelValue) {
            return filteredOptions.value.findIndex((o) => o.value === props.modelValue);
          }
        }
        return -1;
      });
      const dropdownMenuVisible = vue.computed({
        get() {
          return expanded.value && emptyText.value !== false;
        },
        set(val) {
          expanded.value = val;
        }
      });
      const {
        createNewOption,
        removeNewOption,
        selectNewOption,
        clearAllNewOption
      } = useAllowCreate(props, states);
      const {
        handleCompositionStart,
        handleCompositionUpdate,
        handleCompositionEnd
      } = useInput((e) => onInput(e));
      const focusAndUpdatePopup = () => {
        var _a, _b, _c;
        (_b = (_a = inputRef.value).focus) == null ? void 0 : _b.call(_a);
        (_c = popper.value) == null ? void 0 : _c.updatePopper();
      };
      const toggleMenu = () => {
        if (props.automaticDropdown)
          return;
        if (!selectDisabled.value) {
          if (states.isComposing)
            states.softFocus = true;
          return vue.nextTick(() => {
            var _a, _b;
            expanded.value = !expanded.value;
            (_b = (_a = inputRef.value) == null ? void 0 : _a.focus) == null ? void 0 : _b.call(_a);
          });
        }
      };
      const onInputChange = () => {
        if (props.filterable && states.inputValue !== states.selectedLabel) {
          states.query = states.selectedLabel;
        }
        handleQueryChange(states.inputValue);
        return vue.nextTick(() => {
          createNewOption(states.inputValue);
        });
      };
      const debouncedOnInputChange = debounce(onInputChange, debounce$1.value);
      const handleQueryChange = (val) => {
        if (states.previousQuery === val) {
          return;
        }
        states.previousQuery = val;
        if (props.filterable && isFunction(props.filterMethod)) {
          props.filterMethod(val);
        } else if (props.filterable && props.remote && isFunction(props.remoteMethod)) {
          props.remoteMethod(val);
        }
      };
      const emitChange = (val) => {
        if (!isEqual$1(props.modelValue, val)) {
          emit(CHANGE_EVENT, val);
        }
      };
      const update = (val) => {
        emit(UPDATE_MODEL_EVENT, val);
        emitChange(val);
        states.previousValue = val == null ? void 0 : val.toString();
      };
      const getValueIndex = (arr = [], value) => {
        if (!isObject$1(value)) {
          return arr.indexOf(value);
        }
        const valueKey = props.valueKey;
        let index = -1;
        arr.some((item, i) => {
          if (get(item, valueKey) === get(value, valueKey)) {
            index = i;
            return true;
          }
          return false;
        });
        return index;
      };
      const getValueKey = (item) => {
        return isObject$1(item) ? get(item, props.valueKey) : item;
      };
      const getLabel = (item) => {
        return isObject$1(item) ? item.label : item;
      };
      const resetInputHeight = () => {
        if (props.collapseTags && !props.filterable) {
          return;
        }
        return vue.nextTick(() => {
          var _a, _b;
          if (!inputRef.value)
            return;
          const selection = selectionRef.value;
          selectRef.value.height = selection.offsetHeight;
          if (expanded.value && emptyText.value !== false) {
            (_b = (_a = popper.value) == null ? void 0 : _a.updatePopper) == null ? void 0 : _b.call(_a);
          }
        });
      };
      const handleResize = () => {
        var _a, _b;
        resetInputWidth();
        calculatePopperSize();
        (_b = (_a = popper.value) == null ? void 0 : _a.updatePopper) == null ? void 0 : _b.call(_a);
        if (props.multiple) {
          return resetInputHeight();
        }
      };
      const resetInputWidth = () => {
        const select = selectionRef.value;
        if (select) {
          states.selectWidth = select.getBoundingClientRect().width;
        }
      };
      const onSelect = (option, idx, byClick = true) => {
        var _a, _b;
        if (props.multiple) {
          let selectedOptions = props.modelValue.slice();
          const index = getValueIndex(selectedOptions, getValueKey(option));
          if (index > -1) {
            selectedOptions = [
              ...selectedOptions.slice(0, index),
              ...selectedOptions.slice(index + 1)
            ];
            states.cachedOptions.splice(index, 1);
            removeNewOption(option);
          } else if (props.multipleLimit <= 0 || selectedOptions.length < props.multipleLimit) {
            selectedOptions = [...selectedOptions, getValueKey(option)];
            states.cachedOptions.push(option);
            selectNewOption(option);
            updateHoveringIndex(idx);
          }
          update(selectedOptions);
          if (option.created) {
            states.query = "";
            handleQueryChange("");
            states.inputLength = 20;
          }
          if (props.filterable && !props.reserveKeyword) {
            (_b = (_a = inputRef.value).focus) == null ? void 0 : _b.call(_a);
            onUpdateInputValue("");
          }
          if (props.filterable) {
            states.calculatedWidth = calculatorRef.value.getBoundingClientRect().width;
          }
          resetInputHeight();
          setSoftFocus();
        } else {
          selectedIndex.value = idx;
          states.selectedLabel = option.label;
          update(getValueKey(option));
          expanded.value = false;
          states.isComposing = false;
          states.isSilentBlur = byClick;
          selectNewOption(option);
          if (!option.created) {
            clearAllNewOption();
          }
          updateHoveringIndex(idx);
        }
      };
      const deleteTag = (event, tag) => {
        const { valueKey } = props;
        const index = props.modelValue.indexOf(get(tag, valueKey));
        if (index > -1 && !selectDisabled.value) {
          const value = [
            ...props.modelValue.slice(0, index),
            ...props.modelValue.slice(index + 1)
          ];
          states.cachedOptions.splice(index, 1);
          update(value);
          emit("remove-tag", get(tag, valueKey));
          states.softFocus = true;
          removeNewOption(tag);
          return vue.nextTick(focusAndUpdatePopup);
        }
        event.stopPropagation();
      };
      const handleFocus = (event) => {
        const focused = states.isComposing;
        states.isComposing = true;
        if (!states.softFocus) {
          if (!focused)
            emit("focus", event);
        } else {
          states.softFocus = false;
        }
      };
      const handleBlur = (event) => {
        states.softFocus = false;
        return vue.nextTick(() => {
          var _a, _b;
          (_b = (_a = inputRef.value) == null ? void 0 : _a.blur) == null ? void 0 : _b.call(_a);
          if (calculatorRef.value) {
            states.calculatedWidth = calculatorRef.value.getBoundingClientRect().width;
          }
          if (states.isSilentBlur) {
            states.isSilentBlur = false;
          } else {
            if (states.isComposing) {
              emit("blur", event);
            }
          }
          states.isComposing = false;
        });
      };
      const handleEsc = () => {
        if (states.displayInputValue.length > 0) {
          onUpdateInputValue("");
        } else {
          expanded.value = false;
        }
      };
      const handleDel = (e) => {
        if (states.displayInputValue.length === 0) {
          e.preventDefault();
          const selected = props.modelValue.slice();
          selected.pop();
          removeNewOption(states.cachedOptions.pop());
          update(selected);
        }
      };
      const handleClear = () => {
        let emptyValue;
        if (isArray(props.modelValue)) {
          emptyValue = [];
        } else {
          emptyValue = void 0;
        }
        states.softFocus = true;
        if (props.multiple) {
          states.cachedOptions = [];
        } else {
          states.selectedLabel = "";
        }
        expanded.value = false;
        update(emptyValue);
        emit("clear");
        clearAllNewOption();
        return vue.nextTick(focusAndUpdatePopup);
      };
      const onUpdateInputValue = (val) => {
        states.displayInputValue = val;
        states.inputValue = val;
      };
      const onKeyboardNavigate = (direction, hoveringIndex = void 0) => {
        const options = filteredOptions.value;
        if (!["forward", "backward"].includes(direction) || selectDisabled.value || options.length <= 0 || optionsAllDisabled.value) {
          return;
        }
        if (!expanded.value) {
          return toggleMenu();
        }
        if (hoveringIndex === void 0) {
          hoveringIndex = states.hoveringIndex;
        }
        let newIndex = -1;
        if (direction === "forward") {
          newIndex = hoveringIndex + 1;
          if (newIndex >= options.length) {
            newIndex = 0;
          }
        } else if (direction === "backward") {
          newIndex = hoveringIndex - 1;
          if (newIndex < 0 || newIndex >= options.length) {
            newIndex = options.length - 1;
          }
        }
        const option = options[newIndex];
        if (option.disabled || option.type === "Group") {
          return onKeyboardNavigate(direction, newIndex);
        } else {
          updateHoveringIndex(newIndex);
          scrollToItem(newIndex);
        }
      };
      const onKeyboardSelect = () => {
        if (!expanded.value) {
          return toggleMenu();
        } else if (~states.hoveringIndex && filteredOptions.value[states.hoveringIndex]) {
          onSelect(filteredOptions.value[states.hoveringIndex], states.hoveringIndex, false);
        }
      };
      const updateHoveringIndex = (idx) => {
        states.hoveringIndex = idx;
      };
      const resetHoveringIndex = () => {
        states.hoveringIndex = -1;
      };
      const setSoftFocus = () => {
        var _a;
        const _input = inputRef.value;
        if (_input) {
          (_a = _input.focus) == null ? void 0 : _a.call(_input);
        }
      };
      const onInput = (event) => {
        const value = event.target.value;
        onUpdateInputValue(value);
        if (states.displayInputValue.length > 0 && !expanded.value) {
          expanded.value = true;
        }
        states.calculatedWidth = calculatorRef.value.getBoundingClientRect().width;
        if (props.multiple) {
          resetInputHeight();
        }
        if (props.remote) {
          debouncedOnInputChange();
        } else {
          return onInputChange();
        }
      };
      const handleClickOutside = () => {
        expanded.value = false;
        return handleBlur();
      };
      const handleMenuEnter = () => {
        states.inputValue = states.displayInputValue;
        return vue.nextTick(() => {
          if (~indexRef.value) {
            updateHoveringIndex(indexRef.value);
            scrollToItem(states.hoveringIndex);
          }
        });
      };
      const scrollToItem = (index) => {
        menuRef.value.scrollToItem(index);
      };
      const initStates = () => {
        resetHoveringIndex();
        if (props.multiple) {
          if (props.modelValue.length > 0) {
            let initHovering = false;
            states.cachedOptions.length = 0;
            states.previousValue = props.modelValue.toString();
            props.modelValue.forEach((selected) => {
              const itemIndex = filteredOptions.value.findIndex((option) => getValueKey(option) === selected);
              if (~itemIndex) {
                states.cachedOptions.push(filteredOptions.value[itemIndex]);
                if (!initHovering) {
                  updateHoveringIndex(itemIndex);
                }
                initHovering = true;
              }
            });
          } else {
            states.cachedOptions = [];
            states.previousValue = void 0;
          }
        } else {
          if (hasModelValue.value) {
            states.previousValue = props.modelValue;
            const options = filteredOptions.value;
            const selectedItemIndex = options.findIndex((option) => getValueKey(option) === getValueKey(props.modelValue));
            if (~selectedItemIndex) {
              states.selectedLabel = options[selectedItemIndex].label;
              updateHoveringIndex(selectedItemIndex);
            } else {
              states.selectedLabel = `${props.modelValue}`;
            }
          } else {
            states.selectedLabel = "";
            states.previousValue = void 0;
          }
        }
        clearAllNewOption();
        calculatePopperSize();
      };
      vue.watch(expanded, (val) => {
        var _a, _b;
        emit("visible-change", val);
        if (val) {
          (_b = (_a = popper.value).update) == null ? void 0 : _b.call(_a);
        } else {
          states.displayInputValue = "";
          states.previousQuery = null;
          createNewOption("");
        }
      });
      vue.watch(() => props.modelValue, (val, oldVal) => {
        var _a;
        if (!val || val.toString() !== states.previousValue) {
          initStates();
        }
        if (!isEqual$1(val, oldVal) && props.validateEvent) {
          (_a = elFormItem == null ? void 0 : elFormItem.validate) == null ? void 0 : _a.call(elFormItem, "change").catch((err) => debugWarn());
        }
      }, {
        deep: true
      });
      vue.watch(() => props.options, () => {
        const input = inputRef.value;
        if (!input || input && document.activeElement !== input) {
          initStates();
        }
      }, {
        deep: true
      });
      vue.watch(filteredOptions, () => {
        return vue.nextTick(menuRef.value.resetScrollTop);
      });
      vue.onMounted(() => {
        initStates();
      });
      useResizeObserver(selectRef, handleResize);
      return {
        collapseTagSize,
        currentPlaceholder,
        expanded,
        emptyText,
        popupHeight,
        debounce: debounce$1,
        filteredOptions,
        iconComponent,
        iconReverse,
        inputWrapperStyle,
        popperSize,
        dropdownMenuVisible,
        hasModelValue,
        shouldShowPlaceholder,
        selectDisabled,
        selectSize,
        showClearBtn,
        states,
        tagMaxWidth,
        nsSelectV2,
        nsInput,
        calculatorRef,
        controlRef,
        inputRef,
        menuRef,
        popper,
        selectRef,
        selectionRef,
        popperRef,
        validateState,
        validateIcon,
        debouncedOnInputChange,
        deleteTag,
        getLabel,
        getValueKey,
        handleBlur,
        handleClear,
        handleClickOutside,
        handleDel,
        handleEsc,
        handleFocus,
        handleMenuEnter,
        handleResize,
        toggleMenu,
        scrollTo: scrollToItem,
        onInput,
        onKeyboardNavigate,
        onKeyboardSelect,
        onSelect,
        onHover: updateHoveringIndex,
        onUpdateInputValue,
        handleCompositionStart,
        handleCompositionEnd,
        handleCompositionUpdate
      };
    };
    var useSelect$2 = useSelect$1;
  
    const _sfc_main$y = vue.defineComponent({
      name: "ElSelectV2",
      components: {
        ElSelectMenu,
        ElTag,
        ElTooltip,
        ElIcon
      },
      directives: { ClickOutside, ModelText: vue.vModelText },
      props: SelectProps,
      emits: [
        UPDATE_MODEL_EVENT,
        CHANGE_EVENT,
        "remove-tag",
        "clear",
        "visible-change",
        "focus",
        "blur"
      ],
      setup(props, { emit }) {
        const API = useSelect$2(props, emit);
        vue.provide(selectV2InjectionKey, {
          props: vue.reactive({
            ...vue.toRefs(props),
            height: API.popupHeight
          }),
          popper: API.popper,
          onSelect: API.onSelect,
          onHover: API.onHover,
          onKeyboardNavigate: API.onKeyboardNavigate,
          onKeyboardSelect: API.onKeyboardSelect
        });
        return API;
      }
    });
    const _hoisted_1$g = { key: 0 };
    const _hoisted_2$b = ["id", "autocomplete", "aria-expanded", "aria-labelledby", "disabled", "readonly", "name", "unselectable"];
    const _hoisted_3$5 = ["textContent"];
    const _hoisted_4$3 = ["id", "aria-labelledby", "aria-expanded", "autocomplete", "disabled", "name", "readonly", "unselectable"];
    const _hoisted_5$2 = ["textContent"];
    function _sfc_render$5(_ctx, _cache, $props, $setup, $data, $options) {
      const _component_el_tag = vue.resolveComponent("el-tag");
      const _component_el_tooltip = vue.resolveComponent("el-tooltip");
      const _component_el_icon = vue.resolveComponent("el-icon");
      const _component_el_select_menu = vue.resolveComponent("el-select-menu");
      const _directive_model_text = vue.resolveDirective("model-text");
      const _directive_click_outside = vue.resolveDirective("click-outside");
      return vue.withDirectives((vue.openBlock(), vue.createElementBlock("div", {
        ref: "selectRef",
        class: vue.normalizeClass([_ctx.nsSelectV2.b(), _ctx.nsSelectV2.m(_ctx.selectSize)]),
        onClick: _cache[25] || (_cache[25] = vue.withModifiers((...args) => _ctx.toggleMenu && _ctx.toggleMenu(...args), ["stop"])),
        onMouseenter: _cache[26] || (_cache[26] = ($event) => _ctx.states.comboBoxHovering = true),
        onMouseleave: _cache[27] || (_cache[27] = ($event) => _ctx.states.comboBoxHovering = false)
      }, [
        vue.createVNode(_component_el_tooltip, {
          ref: "popper",
          visible: _ctx.dropdownMenuVisible,
          teleported: _ctx.teleported,
          "popper-class": [_ctx.nsSelectV2.e("popper"), _ctx.popperClass],
          "gpu-acceleration": false,
          "stop-popper-mouse-event": false,
          "popper-options": _ctx.popperOptions,
          "fallback-placements": ["bottom-start", "top-start", "right", "left"],
          effect: _ctx.effect,
          placement: _ctx.placement,
          pure: "",
          transition: `${_ctx.nsSelectV2.namespace.value}-zoom-in-top`,
          trigger: "click",
          persistent: _ctx.persistent,
          onBeforeShow: _ctx.handleMenuEnter,
          onHide: _cache[24] || (_cache[24] = ($event) => _ctx.states.inputValue = _ctx.states.displayInputValue)
        }, {
          default: vue.withCtx(() => {
            var _a;
            return [
              vue.createElementVNode("div", {
                ref: "selectionRef",
                class: vue.normalizeClass([
                  _ctx.nsSelectV2.e("wrapper"),
                  _ctx.nsSelectV2.is("focused", _ctx.states.isComposing || _ctx.expanded),
                  _ctx.nsSelectV2.is("hovering", _ctx.states.comboBoxHovering),
                  _ctx.nsSelectV2.is("filterable", _ctx.filterable),
                  _ctx.nsSelectV2.is("disabled", _ctx.selectDisabled)
                ])
              }, [
                _ctx.$slots.prefix ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_1$g, [
                  vue.renderSlot(_ctx.$slots, "prefix")
                ])) : vue.createCommentVNode("v-if", true),
                _ctx.multiple ? (vue.openBlock(), vue.createElementBlock("div", {
                  key: 1,
                  class: vue.normalizeClass(_ctx.nsSelectV2.e("selection"))
                }, [
                  _ctx.collapseTags && _ctx.modelValue.length > 0 ? (vue.openBlock(), vue.createElementBlock("div", {
                    key: 0,
                    class: vue.normalizeClass(_ctx.nsSelectV2.e("selected-item"))
                  }, [
                    vue.createVNode(_component_el_tag, {
                      closable: !_ctx.selectDisabled && !((_a = _ctx.states.cachedOptions[0]) == null ? void 0 : _a.disable),
                      size: _ctx.collapseTagSize,
                      type: "info",
                      "disable-transitions": "",
                      onClose: _cache[0] || (_cache[0] = ($event) => _ctx.deleteTag($event, _ctx.states.cachedOptions[0]))
                    }, {
                      default: vue.withCtx(() => {
                        var _a2;
                        return [
                          vue.createElementVNode("span", {
                            class: vue.normalizeClass(_ctx.nsSelectV2.e("tags-text")),
                            style: vue.normalizeStyle({
                              maxWidth: `${_ctx.tagMaxWidth}px`
                            })
                          }, vue.toDisplayString((_a2 = _ctx.states.cachedOptions[0]) == null ? void 0 : _a2.label), 7)
                        ];
                      }),
                      _: 1
                    }, 8, ["closable", "size"]),
                    _ctx.modelValue.length > 1 ? (vue.openBlock(), vue.createBlock(_component_el_tag, {
                      key: 0,
                      closable: false,
                      size: _ctx.collapseTagSize,
                      type: "info",
                      "disable-transitions": ""
                    }, {
                      default: vue.withCtx(() => [
                        _ctx.collapseTagsTooltip ? (vue.openBlock(), vue.createBlock(_component_el_tooltip, {
                          key: 0,
                          disabled: _ctx.dropdownMenuVisible,
                          "fallback-placements": ["bottom", "top", "right", "left"],
                          effect: _ctx.effect,
                          placement: "bottom",
                          teleported: false
                        }, {
                          default: vue.withCtx(() => [
                            vue.createElementVNode("span", {
                              class: vue.normalizeClass(_ctx.nsSelectV2.e("tags-text")),
                              style: vue.normalizeStyle({
                                maxWidth: `${_ctx.tagMaxWidth}px`
                              })
                            }, "+ " + vue.toDisplayString(_ctx.modelValue.length - 1), 7)
                          ]),
                          content: vue.withCtx(() => [
                            vue.createElementVNode("div", {
                              class: vue.normalizeClass(_ctx.nsSelectV2.e("selection"))
                            }, [
                              (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(_ctx.states.cachedOptions.slice(1), (selected, idx) => {
                                return vue.openBlock(), vue.createElementBlock("div", {
                                  key: idx,
                                  class: vue.normalizeClass(_ctx.nsSelectV2.e("selected-item"))
                                }, [
                                  (vue.openBlock(), vue.createBlock(_component_el_tag, {
                                    key: _ctx.getValueKey(selected),
                                    closable: !_ctx.selectDisabled && !selected.disabled,
                                    size: _ctx.collapseTagSize,
                                    class: "in-tooltip",
                                    type: "info",
                                    "disable-transitions": "",
                                    onClose: ($event) => _ctx.deleteTag($event, selected)
                                  }, {
                                    default: vue.withCtx(() => [
                                      vue.createElementVNode("span", {
                                        class: vue.normalizeClass(_ctx.nsSelectV2.e("tags-text")),
                                        style: vue.normalizeStyle({
                                          maxWidth: `${_ctx.tagMaxWidth}px`
                                        })
                                      }, vue.toDisplayString(_ctx.getLabel(selected)), 7)
                                    ]),
                                    _: 2
                                  }, 1032, ["closable", "size", "onClose"]))
                                ], 2);
                              }), 128))
                            ], 2)
                          ]),
                          _: 1
                        }, 8, ["disabled", "effect"])) : (vue.openBlock(), vue.createElementBlock("span", {
                          key: 1,
                          class: vue.normalizeClass(_ctx.nsSelectV2.e("tags-text")),
                          style: vue.normalizeStyle({
                            maxWidth: `${_ctx.tagMaxWidth}px`
                          })
                        }, "+ " + vue.toDisplayString(_ctx.modelValue.length - 1), 7))
                      ]),
                      _: 1
                    }, 8, ["size"])) : vue.createCommentVNode("v-if", true)
                  ], 2)) : (vue.openBlock(true), vue.createElementBlock(vue.Fragment, { key: 1 }, vue.renderList(_ctx.states.cachedOptions, (selected, idx) => {
                    return vue.openBlock(), vue.createElementBlock("div", {
                      key: idx,
                      class: vue.normalizeClass(_ctx.nsSelectV2.e("selected-item"))
                    }, [
                      (vue.openBlock(), vue.createBlock(_component_el_tag, {
                        key: _ctx.getValueKey(selected),
                        closable: !_ctx.selectDisabled && !selected.disabled,
                        size: _ctx.collapseTagSize,
                        type: "info",
                        "disable-transitions": "",
                        onClose: ($event) => _ctx.deleteTag($event, selected)
                      }, {
                        default: vue.withCtx(() => [
                          vue.createElementVNode("span", {
                            class: vue.normalizeClass(_ctx.nsSelectV2.e("tags-text")),
                            style: vue.normalizeStyle({
                              maxWidth: `${_ctx.tagMaxWidth}px`
                            })
                          }, vue.toDisplayString(_ctx.getLabel(selected)), 7)
                        ]),
                        _: 2
                      }, 1032, ["closable", "size", "onClose"]))
                    ], 2);
                  }), 128)),
                  vue.createElementVNode("div", {
                    class: vue.normalizeClass([
                      _ctx.nsSelectV2.e("selected-item"),
                      _ctx.nsSelectV2.e("input-wrapper")
                    ]),
                    style: vue.normalizeStyle(_ctx.inputWrapperStyle)
                  }, [
                    vue.withDirectives(vue.createElementVNode("input", {
                      id: _ctx.id,
                      ref: "inputRef",
                      autocomplete: _ctx.autocomplete,
                      "aria-autocomplete": "list",
                      "aria-haspopup": "listbox",
                      autocapitalize: "off",
                      "aria-expanded": _ctx.expanded,
                      "aria-labelledby": _ctx.label,
                      class: vue.normalizeClass([
                        _ctx.nsSelectV2.is(_ctx.selectSize),
                        _ctx.nsSelectV2.e("combobox-input")
                      ]),
                      disabled: _ctx.disabled,
                      role: "combobox",
                      readonly: !_ctx.filterable,
                      spellcheck: "false",
                      type: "text",
                      name: _ctx.name,
                      unselectable: _ctx.expanded ? "on" : void 0,
                      "onUpdate:modelValue": _cache[1] || (_cache[1] = (...args) => _ctx.onUpdateInputValue && _ctx.onUpdateInputValue(...args)),
                      onFocus: _cache[2] || (_cache[2] = (...args) => _ctx.handleFocus && _ctx.handleFocus(...args)),
                      onBlur: _cache[3] || (_cache[3] = (...args) => _ctx.handleBlur && _ctx.handleBlur(...args)),
                      onInput: _cache[4] || (_cache[4] = (...args) => _ctx.onInput && _ctx.onInput(...args)),
                      onCompositionstart: _cache[5] || (_cache[5] = (...args) => _ctx.handleCompositionStart && _ctx.handleCompositionStart(...args)),
                      onCompositionupdate: _cache[6] || (_cache[6] = (...args) => _ctx.handleCompositionUpdate && _ctx.handleCompositionUpdate(...args)),
                      onCompositionend: _cache[7] || (_cache[7] = (...args) => _ctx.handleCompositionEnd && _ctx.handleCompositionEnd(...args)),
                      onKeydown: [
                        _cache[8] || (_cache[8] = vue.withKeys(vue.withModifiers(($event) => _ctx.onKeyboardNavigate("backward"), ["stop", "prevent"]), ["up"])),
                        _cache[9] || (_cache[9] = vue.withKeys(vue.withModifiers(($event) => _ctx.onKeyboardNavigate("forward"), ["stop", "prevent"]), ["down"])),
                        _cache[10] || (_cache[10] = vue.withKeys(vue.withModifiers((...args) => _ctx.onKeyboardSelect && _ctx.onKeyboardSelect(...args), ["stop", "prevent"]), ["enter"])),
                        _cache[11] || (_cache[11] = vue.withKeys(vue.withModifiers((...args) => _ctx.handleEsc && _ctx.handleEsc(...args), ["stop", "prevent"]), ["esc"])),
                        _cache[12] || (_cache[12] = vue.withKeys(vue.withModifiers((...args) => _ctx.handleDel && _ctx.handleDel(...args), ["stop"]), ["delete"]))
                      ]
                    }, null, 42, _hoisted_2$b), [
                      [_directive_model_text, _ctx.states.displayInputValue]
                    ]),
                    _ctx.filterable ? (vue.openBlock(), vue.createElementBlock("span", {
                      key: 0,
                      ref: "calculatorRef",
                      "aria-hidden": "true",
                      class: vue.normalizeClass(_ctx.nsSelectV2.e("input-calculator")),
                      textContent: vue.toDisplayString(_ctx.states.displayInputValue)
                    }, null, 10, _hoisted_3$5)) : vue.createCommentVNode("v-if", true)
                  ], 6)
                ], 2)) : (vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: 2 }, [
                  vue.createElementVNode("div", {
                    class: vue.normalizeClass([
                      _ctx.nsSelectV2.e("selected-item"),
                      _ctx.nsSelectV2.e("input-wrapper")
                    ])
                  }, [
                    vue.withDirectives(vue.createElementVNode("input", {
                      id: _ctx.id,
                      ref: "inputRef",
                      "aria-autocomplete": "list",
                      "aria-haspopup": "listbox",
                      "aria-labelledby": _ctx.label,
                      "aria-expanded": _ctx.expanded,
                      autocapitalize: "off",
                      autocomplete: _ctx.autocomplete,
                      class: vue.normalizeClass(_ctx.nsSelectV2.e("combobox-input")),
                      disabled: _ctx.disabled,
                      name: _ctx.name,
                      role: "combobox",
                      readonly: !_ctx.filterable,
                      spellcheck: "false",
                      type: "text",
                      unselectable: _ctx.expanded ? "on" : void 0,
                      onCompositionstart: _cache[13] || (_cache[13] = (...args) => _ctx.handleCompositionStart && _ctx.handleCompositionStart(...args)),
                      onCompositionupdate: _cache[14] || (_cache[14] = (...args) => _ctx.handleCompositionUpdate && _ctx.handleCompositionUpdate(...args)),
                      onCompositionend: _cache[15] || (_cache[15] = (...args) => _ctx.handleCompositionEnd && _ctx.handleCompositionEnd(...args)),
                      onFocus: _cache[16] || (_cache[16] = (...args) => _ctx.handleFocus && _ctx.handleFocus(...args)),
                      onBlur: _cache[17] || (_cache[17] = (...args) => _ctx.handleBlur && _ctx.handleBlur(...args)),
                      onInput: _cache[18] || (_cache[18] = (...args) => _ctx.onInput && _ctx.onInput(...args)),
                      onKeydown: [
                        _cache[19] || (_cache[19] = vue.withKeys(vue.withModifiers(($event) => _ctx.onKeyboardNavigate("backward"), ["stop", "prevent"]), ["up"])),
                        _cache[20] || (_cache[20] = vue.withKeys(vue.withModifiers(($event) => _ctx.onKeyboardNavigate("forward"), ["stop", "prevent"]), ["down"])),
                        _cache[21] || (_cache[21] = vue.withKeys(vue.withModifiers((...args) => _ctx.onKeyboardSelect && _ctx.onKeyboardSelect(...args), ["stop", "prevent"]), ["enter"])),
                        _cache[22] || (_cache[22] = vue.withKeys(vue.withModifiers((...args) => _ctx.handleEsc && _ctx.handleEsc(...args), ["stop", "prevent"]), ["esc"]))
                      ],
                      "onUpdate:modelValue": _cache[23] || (_cache[23] = (...args) => _ctx.onUpdateInputValue && _ctx.onUpdateInputValue(...args))
                    }, null, 42, _hoisted_4$3), [
                      [_directive_model_text, _ctx.states.displayInputValue]
                    ])
                  ], 2),
                  _ctx.filterable ? (vue.openBlock(), vue.createElementBlock("span", {
                    key: 0,
                    ref: "calculatorRef",
                    "aria-hidden": "true",
                    class: vue.normalizeClass([
                      _ctx.nsSelectV2.e("selected-item"),
                      _ctx.nsSelectV2.e("input-calculator")
                    ]),
                    textContent: vue.toDisplayString(_ctx.states.displayInputValue)
                  }, null, 10, _hoisted_5$2)) : vue.createCommentVNode("v-if", true)
                ], 64)),
                _ctx.shouldShowPlaceholder ? (vue.openBlock(), vue.createElementBlock("span", {
                  key: 3,
                  class: vue.normalizeClass([
                    _ctx.nsSelectV2.e("placeholder"),
                    _ctx.nsSelectV2.is("transparent", _ctx.multiple ? _ctx.modelValue.length === 0 : !_ctx.hasModelValue)
                  ])
                }, vue.toDisplayString(_ctx.currentPlaceholder), 3)) : vue.createCommentVNode("v-if", true),
                vue.createElementVNode("span", {
                  class: vue.normalizeClass(_ctx.nsSelectV2.e("suffix"))
                }, [
                  _ctx.iconComponent ? vue.withDirectives((vue.openBlock(), vue.createBlock(_component_el_icon, {
                    key: 0,
                    class: vue.normalizeClass([_ctx.nsSelectV2.e("caret"), _ctx.nsInput.e("icon"), _ctx.iconReverse])
                  }, {
                    default: vue.withCtx(() => [
                      (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(_ctx.iconComponent)))
                    ]),
                    _: 1
                  }, 8, ["class"])), [
                    [vue.vShow, !_ctx.showClearBtn]
                  ]) : vue.createCommentVNode("v-if", true),
                  _ctx.showClearBtn && _ctx.clearIcon ? (vue.openBlock(), vue.createBlock(_component_el_icon, {
                    key: 1,
                    class: vue.normalizeClass([_ctx.nsSelectV2.e("caret"), _ctx.nsInput.e("icon")]),
                    onClick: vue.withModifiers(_ctx.handleClear, ["prevent", "stop"])
                  }, {
                    default: vue.withCtx(() => [
                      (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(_ctx.clearIcon)))
                    ]),
                    _: 1
                  }, 8, ["class", "onClick"])) : vue.createCommentVNode("v-if", true),
                  _ctx.validateState && _ctx.validateIcon ? (vue.openBlock(), vue.createBlock(_component_el_icon, {
                    key: 2,
                    class: vue.normalizeClass([_ctx.nsInput.e("icon"), _ctx.nsInput.e("validateIcon")])
                  }, {
                    default: vue.withCtx(() => [
                      (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(_ctx.validateIcon)))
                    ]),
                    _: 1
                  }, 8, ["class"])) : vue.createCommentVNode("v-if", true)
                ], 2)
              ], 2)
            ];
          }),
          content: vue.withCtx(() => [
            vue.createVNode(_component_el_select_menu, {
              ref: "menuRef",
              data: _ctx.filteredOptions,
              width: _ctx.popperSize,
              "hovering-index": _ctx.states.hoveringIndex,
              "scrollbar-always-on": _ctx.scrollbarAlwaysOn
            }, {
              default: vue.withCtx((scope) => [
                vue.renderSlot(_ctx.$slots, "default", vue.normalizeProps(vue.guardReactiveProps(scope)))
              ]),
              empty: vue.withCtx(() => [
                vue.renderSlot(_ctx.$slots, "empty", {}, () => [
                  vue.createElementVNode("p", {
                    class: vue.normalizeClass(_ctx.nsSelectV2.e("empty"))
                  }, vue.toDisplayString(_ctx.emptyText ? _ctx.emptyText : ""), 3)
                ])
              ]),
              _: 3
            }, 8, ["data", "width", "hovering-index", "scrollbar-always-on"])
          ]),
          _: 3
        }, 8, ["visible", "teleported", "popper-class", "popper-options", "effect", "placement", "transition", "persistent", "onBeforeShow"])
      ], 34)), [
        [_directive_click_outside, _ctx.handleClickOutside, _ctx.popperRef]
      ]);
    }
    var Select = /* @__PURE__ */ _export_sfc(_sfc_main$y, [["render", _sfc_render$5], ["__file", "select.vue"]]);
  
    Select.install = (app) => {
      app.component(Select.name, Select);
    };
    const _Select = Select;
    const ElSelectV2 = _Select;
  
    const skeletonProps = buildProps({
      animated: {
        type: Boolean,
        default: false
      },
      count: {
        type: Number,
        default: 1
      },
      rows: {
        type: Number,
        default: 3
      },
      loading: {
        type: Boolean,
        default: true
      },
      throttle: {
        type: Number
      }
    });
  
    const skeletonItemProps = buildProps({
      variant: {
        type: String,
        values: [
          "circle",
          "rect",
          "h1",
          "h3",
          "text",
          "caption",
          "p",
          "image",
          "button"
        ],
        default: "text"
      }
    });
  
    const __default__$q = vue.defineComponent({
      name: "ElSkeletonItem"
    });
    const _sfc_main$x = /* @__PURE__ */ vue.defineComponent({
      ...__default__$q,
      props: skeletonItemProps,
      setup(__props) {
        const ns = useNamespace("skeleton");
        return (_ctx, _cache) => {
          return vue.openBlock(), vue.createElementBlock("div", {
            class: vue.normalizeClass([vue.unref(ns).e("item"), vue.unref(ns).e(_ctx.variant)])
          }, [
            _ctx.variant === "image" ? (vue.openBlock(), vue.createBlock(vue.unref(picture_filled_default), { key: 0 })) : vue.createCommentVNode("v-if", true)
          ], 2);
        };
      }
    });
    var SkeletonItem = /* @__PURE__ */ _export_sfc(_sfc_main$x, [["__file", "skeleton-item.vue"]]);
  
    const __default__$p = vue.defineComponent({
      name: "ElSkeleton"
    });
    const _sfc_main$w = /* @__PURE__ */ vue.defineComponent({
      ...__default__$p,
      props: skeletonProps,
      setup(__props, { expose }) {
        const props = __props;
        const ns = useNamespace("skeleton");
        const uiLoading = useThrottleRender(vue.toRef(props, "loading"), props.throttle);
        expose({
          uiLoading
        });
        return (_ctx, _cache) => {
          return vue.unref(uiLoading) ? (vue.openBlock(), vue.createElementBlock("div", vue.mergeProps({
            key: 0,
            class: [vue.unref(ns).b(), vue.unref(ns).is("animated", _ctx.animated)]
          }, _ctx.$attrs), [
            (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(_ctx.count, (i) => {
              return vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: i }, [
                _ctx.loading ? vue.renderSlot(_ctx.$slots, "template", { key: i }, () => [
                  vue.createVNode(SkeletonItem, {
                    class: vue.normalizeClass(vue.unref(ns).is("first")),
                    variant: "p"
                  }, null, 8, ["class"]),
                  (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(_ctx.rows, (item) => {
                    return vue.openBlock(), vue.createBlock(SkeletonItem, {
                      key: item,
                      class: vue.normalizeClass([
                        vue.unref(ns).e("paragraph"),
                        vue.unref(ns).is("last", item === _ctx.rows && _ctx.rows > 1)
                      ]),
                      variant: "p"
                    }, null, 8, ["class"]);
                  }), 128))
                ]) : vue.createCommentVNode("v-if", true)
              ], 64);
            }), 128))
          ], 16)) : vue.renderSlot(_ctx.$slots, "default", vue.normalizeProps(vue.mergeProps({ key: 1 }, _ctx.$attrs)));
        };
      }
    });
    var Skeleton = /* @__PURE__ */ _export_sfc(_sfc_main$w, [["__file", "skeleton.vue"]]);
  
    const ElSkeleton = withInstall(Skeleton, {
      SkeletonItem
    });
    const ElSkeletonItem = withNoopInstall(SkeletonItem);
  
    const sliderProps = buildProps({
      modelValue: {
        type: definePropType([Number, Array]),
        default: 0
      },
      id: {
        type: String,
        default: void 0
      },
      min: {
        type: Number,
        default: 0
      },
      max: {
        type: Number,
        default: 100
      },
      step: {
        type: Number,
        default: 1
      },
      showInput: Boolean,
      showInputControls: {
        type: Boolean,
        default: true
      },
      size: useSizeProp,
      inputSize: useSizeProp,
      showStops: Boolean,
      showTooltip: {
        type: Boolean,
        default: true
      },
      formatTooltip: {
        type: definePropType(Function),
        default: void 0
      },
      disabled: Boolean,
      range: Boolean,
      vertical: Boolean,
      height: String,
      debounce: {
        type: Number,
        default: 300
      },
      label: {
        type: String,
        default: void 0
      },
      rangeStartLabel: {
        type: String,
        default: void 0
      },
      rangeEndLabel: {
        type: String,
        default: void 0
      },
      formatValueText: {
        type: definePropType(Function),
        default: void 0
      },
      tooltipClass: {
        type: String,
        default: void 0
      },
      placement: {
        type: String,
        values: Ee,
        default: "top"
      },
      marks: {
        type: definePropType(Object)
      },
      validateEvent: {
        type: Boolean,
        default: true
      }
    });
    const isValidValue$1 = (value) => isNumber(value) || isArray(value) && value.every(isNumber);
    const sliderEmits = {
      [UPDATE_MODEL_EVENT]: isValidValue$1,
      [INPUT_EVENT]: isValidValue$1,
      [CHANGE_EVENT]: isValidValue$1
    };
  
    const useLifecycle = (props, initData, resetSize) => {
      const sliderWrapper = vue.ref();
      vue.onMounted(async () => {
        if (props.range) {
          if (Array.isArray(props.modelValue)) {
            initData.firstValue = Math.max(props.min, props.modelValue[0]);
            initData.secondValue = Math.min(props.max, props.modelValue[1]);
          } else {
            initData.firstValue = props.min;
            initData.secondValue = props.max;
          }
          initData.oldValue = [initData.firstValue, initData.secondValue];
        } else {
          if (typeof props.modelValue !== "number" || Number.isNaN(props.modelValue)) {
            initData.firstValue = props.min;
          } else {
            initData.firstValue = Math.min(props.max, Math.max(props.min, props.modelValue));
          }
          initData.oldValue = initData.firstValue;
        }
        useEventListener(window, "resize", resetSize);
        await vue.nextTick();
        resetSize();
      });
      return {
        sliderWrapper
      };
    };
  
    const useMarks = (props) => {
      return vue.computed(() => {
        if (!props.marks) {
          return [];
        }
        const marksKeys = Object.keys(props.marks);
        return marksKeys.map(Number.parseFloat).sort((a, b) => a - b).filter((point) => point <= props.max && point >= props.min).map((point) => ({
          point,
          position: (point - props.min) * 100 / (props.max - props.min),
          mark: props.marks[point]
        }));
      });
    };
  
    const useSlide = (props, initData, emit) => {
      const { form: elForm, formItem: elFormItem } = useFormItem();
      const slider = vue.shallowRef();
      const firstButton = vue.ref();
      const secondButton = vue.ref();
      const buttonRefs = {
        firstButton,
        secondButton
      };
      const sliderDisabled = vue.computed(() => {
        return props.disabled || (elForm == null ? void 0 : elForm.disabled) || false;
      });
      const minValue = vue.computed(() => {
        return Math.min(initData.firstValue, initData.secondValue);
      });
      const maxValue = vue.computed(() => {
        return Math.max(initData.firstValue, initData.secondValue);
      });
      const barSize = vue.computed(() => {
        return props.range ? `${100 * (maxValue.value - minValue.value) / (props.max - props.min)}%` : `${100 * (initData.firstValue - props.min) / (props.max - props.min)}%`;
      });
      const barStart = vue.computed(() => {
        return props.range ? `${100 * (minValue.value - props.min) / (props.max - props.min)}%` : "0%";
      });
      const runwayStyle = vue.computed(() => {
        return props.vertical ? { height: props.height } : {};
      });
      const barStyle = vue.computed(() => {
        return props.vertical ? {
          height: barSize.value,
          bottom: barStart.value
        } : {
          width: barSize.value,
          left: barStart.value
        };
      });
      const resetSize = () => {
        if (slider.value) {
          initData.sliderSize = slider.value[`client${props.vertical ? "Height" : "Width"}`];
        }
      };
      const getButtonRefByPercent = (percent) => {
        const targetValue = props.min + percent * (props.max - props.min) / 100;
        if (!props.range) {
          return firstButton;
        }
        let buttonRefName;
        if (Math.abs(minValue.value - targetValue) < Math.abs(maxValue.value - targetValue)) {
          buttonRefName = initData.firstValue < initData.secondValue ? "firstButton" : "secondButton";
        } else {
          buttonRefName = initData.firstValue > initData.secondValue ? "firstButton" : "secondButton";
        }
        return buttonRefs[buttonRefName];
      };
      const setPosition = (percent) => {
        const buttonRef = getButtonRefByPercent(percent);
        buttonRef.value.setPosition(percent);
        return buttonRef;
      };
      const setFirstValue = (firstValue) => {
        initData.firstValue = firstValue;
        _emit(props.range ? [minValue.value, maxValue.value] : firstValue);
      };
      const setSecondValue = (secondValue) => {
        initData.secondValue = secondValue;
        if (props.range) {
          _emit([minValue.value, maxValue.value]);
        }
      };
      const _emit = (val) => {
        emit(UPDATE_MODEL_EVENT, val);
        emit(INPUT_EVENT, val);
      };
      const emitChange = async () => {
        await vue.nextTick();
        emit(CHANGE_EVENT, props.range ? [minValue.value, maxValue.value] : props.modelValue);
      };
      const handleSliderPointerEvent = (event) => {
        var _a, _b, _c, _d, _e, _f;
        if (sliderDisabled.value || initData.dragging)
          return;
        resetSize();
        let newPercent = 0;
        if (props.vertical) {
          const clientY = (_c = (_b = (_a = event.touches) == null ? void 0 : _a.item(0)) == null ? void 0 : _b.clientY) != null ? _c : event.clientY;
          const sliderOffsetBottom = slider.value.getBoundingClientRect().bottom;
          newPercent = (sliderOffsetBottom - clientY) / initData.sliderSize * 100;
        } else {
          const clientX = (_f = (_e = (_d = event.touches) == null ? void 0 : _d.item(0)) == null ? void 0 : _e.clientX) != null ? _f : event.clientX;
          const sliderOffsetLeft = slider.value.getBoundingClientRect().left;
          newPercent = (clientX - sliderOffsetLeft) / initData.sliderSize * 100;
        }
        if (newPercent < 0 || newPercent > 100)
          return;
        return setPosition(newPercent);
      };
      const onSliderWrapperPrevent = (event) => {
        var _a, _b;
        if (((_a = buttonRefs["firstButton"].value) == null ? void 0 : _a.dragging) || ((_b = buttonRefs["secondButton"].value) == null ? void 0 : _b.dragging)) {
          event.preventDefault();
        }
      };
      const onSliderDown = async (event) => {
        const buttonRef = handleSliderPointerEvent(event);
        if (buttonRef) {
          await vue.nextTick();
          buttonRef.value.onButtonDown(event);
        }
      };
      const onSliderClick = (event) => {
        const buttonRef = handleSliderPointerEvent(event);
        if (buttonRef) {
          emitChange();
        }
      };
      return {
        elFormItem,
        slider,
        firstButton,
        secondButton,
        sliderDisabled,
        minValue,
        maxValue,
        runwayStyle,
        barStyle,
        resetSize,
        setPosition,
        emitChange,
        onSliderWrapperPrevent,
        onSliderClick,
        onSliderDown,
        setFirstValue,
        setSecondValue
      };
    };
  
    const { left, down, right, up, home, end, pageUp, pageDown } = EVENT_CODE;
    const useTooltip = (props, formatTooltip, showTooltip) => {
      const tooltip = vue.ref();
      const tooltipVisible = vue.ref(false);
      const enableFormat = vue.computed(() => {
        return formatTooltip.value instanceof Function;
      });
      const formatValue = vue.computed(() => {
        return enableFormat.value && formatTooltip.value(props.modelValue) || props.modelValue;
      });
      const displayTooltip = debounce(() => {
        showTooltip.value && (tooltipVisible.value = true);
      }, 50);
      const hideTooltip = debounce(() => {
        showTooltip.value && (tooltipVisible.value = false);
      }, 50);
      return {
        tooltip,
        tooltipVisible,
        formatValue,
        displayTooltip,
        hideTooltip
      };
    };
    const useSliderButton = (props, initData, emit) => {
      const {
        disabled,
        min,
        max,
        step,
        showTooltip,
        precision,
        sliderSize,
        formatTooltip,
        emitChange,
        resetSize,
        updateDragging
      } = vue.inject(sliderContextKey);
      const { tooltip, tooltipVisible, formatValue, displayTooltip, hideTooltip } = useTooltip(props, formatTooltip, showTooltip);
      const button = vue.ref();
      const currentPosition = vue.computed(() => {
        return `${(props.modelValue - min.value) / (max.value - min.value) * 100}%`;
      });
      const wrapperStyle = vue.computed(() => {
        return props.vertical ? { bottom: currentPosition.value } : { left: currentPosition.value };
      });
      const handleMouseEnter = () => {
        initData.hovering = true;
        displayTooltip();
      };
      const handleMouseLeave = () => {
        initData.hovering = false;
        if (!initData.dragging) {
          hideTooltip();
        }
      };
      const onButtonDown = (event) => {
        if (disabled.value)
          return;
        event.preventDefault();
        onDragStart(event);
        window.addEventListener("mousemove", onDragging);
        window.addEventListener("touchmove", onDragging);
        window.addEventListener("mouseup", onDragEnd);
        window.addEventListener("touchend", onDragEnd);
        window.addEventListener("contextmenu", onDragEnd);
        button.value.focus();
      };
      const incrementPosition = (amount) => {
        if (disabled.value)
          return;
        initData.newPosition = Number.parseFloat(currentPosition.value) + amount / (max.value - min.value) * 100;
        setPosition(initData.newPosition);
        emitChange();
      };
      const onLeftKeyDown = () => {
        incrementPosition(-step.value);
      };
      const onRightKeyDown = () => {
        incrementPosition(step.value);
      };
      const onPageDownKeyDown = () => {
        incrementPosition(-step.value * 4);
      };
      const onPageUpKeyDown = () => {
        incrementPosition(step.value * 4);
      };
      const onHomeKeyDown = () => {
        if (disabled.value)
          return;
        setPosition(0);
        emitChange();
      };
      const onEndKeyDown = () => {
        if (disabled.value)
          return;
        setPosition(100);
        emitChange();
      };
      const onKeyDown = (event) => {
        let isPreventDefault = true;
        if ([left, down].includes(event.key)) {
          onLeftKeyDown();
        } else if ([right, up].includes(event.key)) {
          onRightKeyDown();
        } else if (event.key === home) {
          onHomeKeyDown();
        } else if (event.key === end) {
          onEndKeyDown();
        } else if (event.key === pageDown) {
          onPageDownKeyDown();
        } else if (event.key === pageUp) {
          onPageUpKeyDown();
        } else {
          isPreventDefault = false;
        }
        isPreventDefault && event.preventDefault();
      };
      const getClientXY = (event) => {
        let clientX;
        let clientY;
        if (event.type.startsWith("touch")) {
          clientY = event.touches[0].clientY;
          clientX = event.touches[0].clientX;
        } else {
          clientY = event.clientY;
          clientX = event.clientX;
        }
        return {
          clientX,
          clientY
        };
      };
      const onDragStart = (event) => {
        initData.dragging = true;
        initData.isClick = true;
        const { clientX, clientY } = getClientXY(event);
        if (props.vertical) {
          initData.startY = clientY;
        } else {
          initData.startX = clientX;
        }
        initData.startPosition = Number.parseFloat(currentPosition.value);
        initData.newPosition = initData.startPosition;
      };
      const onDragging = (event) => {
        if (initData.dragging) {
          initData.isClick = false;
          displayTooltip();
          resetSize();
          let diff;
          const { clientX, clientY } = getClientXY(event);
          if (props.vertical) {
            initData.currentY = clientY;
            diff = (initData.startY - initData.currentY) / sliderSize.value * 100;
          } else {
            initData.currentX = clientX;
            diff = (initData.currentX - initData.startX) / sliderSize.value * 100;
          }
          initData.newPosition = initData.startPosition + diff;
          setPosition(initData.newPosition);
        }
      };
      const onDragEnd = () => {
        if (initData.dragging) {
          setTimeout(() => {
            initData.dragging = false;
            if (!initData.hovering) {
              hideTooltip();
            }
            if (!initData.isClick) {
              setPosition(initData.newPosition);
            }
            emitChange();
          }, 0);
          window.removeEventListener("mousemove", onDragging);
          window.removeEventListener("touchmove", onDragging);
          window.removeEventListener("mouseup", onDragEnd);
          window.removeEventListener("touchend", onDragEnd);
          window.removeEventListener("contextmenu", onDragEnd);
        }
      };
      const setPosition = async (newPosition) => {
        if (newPosition === null || Number.isNaN(+newPosition))
          return;
        if (newPosition < 0) {
          newPosition = 0;
        } else if (newPosition > 100) {
          newPosition = 100;
        }
        const lengthPerStep = 100 / ((max.value - min.value) / step.value);
        const steps = Math.round(newPosition / lengthPerStep);
        let value = steps * lengthPerStep * (max.value - min.value) * 0.01 + min.value;
        value = Number.parseFloat(value.toFixed(precision.value));
        if (value !== props.modelValue) {
          emit(UPDATE_MODEL_EVENT, value);
        }
        if (!initData.dragging && props.modelValue !== initData.oldValue) {
          initData.oldValue = props.modelValue;
        }
        await vue.nextTick();
        initData.dragging && displayTooltip();
        tooltip.value.updatePopper();
      };
      vue.watch(() => initData.dragging, (val) => {
        updateDragging(val);
      });
      return {
        disabled,
        button,
        tooltip,
        tooltipVisible,
        showTooltip,
        wrapperStyle,
        formatValue,
        handleMouseEnter,
        handleMouseLeave,
        onButtonDown,
        onKeyDown,
        setPosition
      };
    };
  
    const useStops = (props, initData, minValue, maxValue) => {
      const stops = vue.computed(() => {
        if (!props.showStops || props.min > props.max)
          return [];
        if (props.step === 0) {
          return [];
        }
        const stopCount = (props.max - props.min) / props.step;
        const stepWidth = 100 * props.step / (props.max - props.min);
        const result = Array.from({ length: stopCount - 1 }).map((_, index) => (index + 1) * stepWidth);
        if (props.range) {
          return result.filter((step) => {
            return step < 100 * (minValue.value - props.min) / (props.max - props.min) || step > 100 * (maxValue.value - props.min) / (props.max - props.min);
          });
        } else {
          return result.filter((step) => step > 100 * (initData.firstValue - props.min) / (props.max - props.min));
        }
      });
      const getStopStyle = (position) => {
        return props.vertical ? { bottom: `${position}%` } : { left: `${position}%` };
      };
      return {
        stops,
        getStopStyle
      };
    };
  
    const useWatch = (props, initData, minValue, maxValue, emit, elFormItem) => {
      const _emit = (val) => {
        emit(UPDATE_MODEL_EVENT, val);
        emit(INPUT_EVENT, val);
      };
      const valueChanged = () => {
        if (props.range) {
          return ![minValue.value, maxValue.value].every((item, index) => item === initData.oldValue[index]);
        } else {
          return props.modelValue !== initData.oldValue;
        }
      };
      const setValues = () => {
        var _a, _b;
        if (props.min > props.max) {
          throwError("Slider", "min should not be greater than max.");
          return;
        }
        const val = props.modelValue;
        if (props.range && Array.isArray(val)) {
          if (val[1] < props.min) {
            _emit([props.min, props.min]);
          } else if (val[0] > props.max) {
            _emit([props.max, props.max]);
          } else if (val[0] < props.min) {
            _emit([props.min, val[1]]);
          } else if (val[1] > props.max) {
            _emit([val[0], props.max]);
          } else {
            initData.firstValue = val[0];
            initData.secondValue = val[1];
            if (valueChanged()) {
              if (props.validateEvent) {
                (_a = elFormItem == null ? void 0 : elFormItem.validate) == null ? void 0 : _a.call(elFormItem, "change").catch((err) => debugWarn());
              }
              initData.oldValue = val.slice();
            }
          }
        } else if (!props.range && typeof val === "number" && !Number.isNaN(val)) {
          if (val < props.min) {
            _emit(props.min);
          } else if (val > props.max) {
            _emit(props.max);
          } else {
            initData.firstValue = val;
            if (valueChanged()) {
              if (props.validateEvent) {
                (_b = elFormItem == null ? void 0 : elFormItem.validate) == null ? void 0 : _b.call(elFormItem, "change").catch((err) => debugWarn());
              }
              initData.oldValue = val;
            }
          }
        }
      };
      setValues();
      vue.watch(() => initData.dragging, (val) => {
        if (!val) {
          setValues();
        }
      });
      vue.watch(() => props.modelValue, (val, oldVal) => {
        if (initData.dragging || Array.isArray(val) && Array.isArray(oldVal) && val.every((item, index) => item === oldVal[index]) && initData.firstValue === val[0] && initData.secondValue === val[1]) {
          return;
        }
        setValues();
      }, {
        deep: true
      });
      vue.watch(() => [props.min, props.max], () => {
        setValues();
      });
    };
  
    const sliderButtonProps = buildProps({
      modelValue: {
        type: Number,
        default: 0
      },
      vertical: Boolean,
      tooltipClass: String,
      placement: {
        type: String,
        values: Ee,
        default: "top"
      }
    });
    const sliderButtonEmits = {
      [UPDATE_MODEL_EVENT]: (value) => isNumber(value)
    };
  
    const _hoisted_1$f = ["tabindex"];
    const __default__$o = vue.defineComponent({
      name: "ElSliderButton"
    });
    const _sfc_main$v = /* @__PURE__ */ vue.defineComponent({
      ...__default__$o,
      props: sliderButtonProps,
      emits: sliderButtonEmits,
      setup(__props, { expose, emit }) {
        const props = __props;
        const ns = useNamespace("slider");
        const initData = vue.reactive({
          hovering: false,
          dragging: false,
          isClick: false,
          startX: 0,
          currentX: 0,
          startY: 0,
          currentY: 0,
          startPosition: 0,
          newPosition: 0,
          oldValue: props.modelValue
        });
        const {
          disabled,
          button,
          tooltip,
          showTooltip,
          tooltipVisible,
          wrapperStyle,
          formatValue,
          handleMouseEnter,
          handleMouseLeave,
          onButtonDown,
          onKeyDown,
          setPosition
        } = useSliderButton(props, initData, emit);
        const { hovering, dragging } = vue.toRefs(initData);
        expose({
          onButtonDown,
          onKeyDown,
          setPosition,
          hovering,
          dragging
        });
        return (_ctx, _cache) => {
          return vue.openBlock(), vue.createElementBlock("div", {
            ref_key: "button",
            ref: button,
            class: vue.normalizeClass([vue.unref(ns).e("button-wrapper"), { hover: vue.unref(hovering), dragging: vue.unref(dragging) }]),
            style: vue.normalizeStyle(vue.unref(wrapperStyle)),
            tabindex: vue.unref(disabled) ? -1 : 0,
            onMouseenter: _cache[0] || (_cache[0] = (...args) => vue.unref(handleMouseEnter) && vue.unref(handleMouseEnter)(...args)),
            onMouseleave: _cache[1] || (_cache[1] = (...args) => vue.unref(handleMouseLeave) && vue.unref(handleMouseLeave)(...args)),
            onMousedown: _cache[2] || (_cache[2] = (...args) => vue.unref(onButtonDown) && vue.unref(onButtonDown)(...args)),
            onTouchstart: _cache[3] || (_cache[3] = (...args) => vue.unref(onButtonDown) && vue.unref(onButtonDown)(...args)),
            onFocus: _cache[4] || (_cache[4] = (...args) => vue.unref(handleMouseEnter) && vue.unref(handleMouseEnter)(...args)),
            onBlur: _cache[5] || (_cache[5] = (...args) => vue.unref(handleMouseLeave) && vue.unref(handleMouseLeave)(...args)),
            onKeydown: _cache[6] || (_cache[6] = (...args) => vue.unref(onKeyDown) && vue.unref(onKeyDown)(...args))
          }, [
            vue.createVNode(vue.unref(ElTooltip), {
              ref_key: "tooltip",
              ref: tooltip,
              visible: vue.unref(tooltipVisible),
              placement: _ctx.placement,
              "fallback-placements": ["top", "bottom", "right", "left"],
              "stop-popper-mouse-event": false,
              "popper-class": _ctx.tooltipClass,
              disabled: !vue.unref(showTooltip),
              persistent: ""
            }, {
              content: vue.withCtx(() => [
                vue.createElementVNode("span", null, vue.toDisplayString(vue.unref(formatValue)), 1)
              ]),
              default: vue.withCtx(() => [
                vue.createElementVNode("div", {
                  class: vue.normalizeClass([vue.unref(ns).e("button"), { hover: vue.unref(hovering), dragging: vue.unref(dragging) }])
                }, null, 2)
              ]),
              _: 1
            }, 8, ["visible", "placement", "popper-class", "disabled"])
          ], 46, _hoisted_1$f);
        };
      }
    });
    var SliderButton = /* @__PURE__ */ _export_sfc(_sfc_main$v, [["__file", "button.vue"]]);
  
    const sliderMarkerProps = buildProps({
      mark: {
        type: definePropType([String, Object]),
        default: void 0
      }
    });
    var SliderMarker = vue.defineComponent({
      name: "ElSliderMarker",
      props: sliderMarkerProps,
      setup(props) {
        const ns = useNamespace("slider");
        const label = vue.computed(() => {
          return isString(props.mark) ? props.mark : props.mark.label;
        });
        const style = vue.computed(() => isString(props.mark) ? void 0 : props.mark.style);
        return () => vue.h("div", {
          class: ns.e("marks-text"),
          style: style.value
        }, label.value);
      }
    });
  
    const _hoisted_1$e = ["id", "role", "aria-label", "aria-labelledby"];
    const _hoisted_2$a = { key: 1 };
    const __default__$n = vue.defineComponent({
      name: "ElSlider"
    });
    const _sfc_main$u = /* @__PURE__ */ vue.defineComponent({
      ...__default__$n,
      props: sliderProps,
      emits: sliderEmits,
      setup(__props, { expose, emit }) {
        const props = __props;
        const ns = useNamespace("slider");
        const { t } = useLocale();
        const initData = vue.reactive({
          firstValue: 0,
          secondValue: 0,
          oldValue: 0,
          dragging: false,
          sliderSize: 1
        });
        const {
          elFormItem,
          slider,
          firstButton,
          secondButton,
          sliderDisabled,
          minValue,
          maxValue,
          runwayStyle,
          barStyle,
          resetSize,
          emitChange,
          onSliderWrapperPrevent,
          onSliderClick,
          onSliderDown,
          setFirstValue,
          setSecondValue
        } = useSlide(props, initData, emit);
        const { stops, getStopStyle } = useStops(props, initData, minValue, maxValue);
        const { inputId, isLabeledByFormItem } = useFormItemInputId(props, {
          formItemContext: elFormItem
        });
        const sliderWrapperSize = useSize();
        const sliderInputSize = vue.computed(() => props.inputSize || sliderWrapperSize.value);
        const groupLabel = vue.computed(() => {
          return props.label || t("el.slider.defaultLabel", {
            min: props.min,
            max: props.max
          });
        });
        const firstButtonLabel = vue.computed(() => {
          if (props.range) {
            return props.rangeStartLabel || t("el.slider.defaultRangeStartLabel");
          } else {
            return groupLabel.value;
          }
        });
        const firstValueText = vue.computed(() => {
          return props.formatValueText ? props.formatValueText(firstValue.value) : `${firstValue.value}`;
        });
        const secondButtonLabel = vue.computed(() => {
          return props.rangeEndLabel || t("el.slider.defaultRangeEndLabel");
        });
        const secondValueText = vue.computed(() => {
          return props.formatValueText ? props.formatValueText(secondValue.value) : `${secondValue.value}`;
        });
        const sliderKls = vue.computed(() => [
          ns.b(),
          ns.m(sliderWrapperSize.value),
          ns.is("vertical", props.vertical),
          { [ns.m("with-input")]: props.showInput }
        ]);
        const markList = useMarks(props);
        useWatch(props, initData, minValue, maxValue, emit, elFormItem);
        const precision = vue.computed(() => {
          const precisions = [props.min, props.max, props.step].map((item) => {
            const decimal = `${item}`.split(".")[1];
            return decimal ? decimal.length : 0;
          });
          return Math.max.apply(null, precisions);
        });
        const { sliderWrapper } = useLifecycle(props, initData, resetSize);
        const { firstValue, secondValue, sliderSize } = vue.toRefs(initData);
        const updateDragging = (val) => {
          initData.dragging = val;
        };
        vue.provide(sliderContextKey, {
          ...vue.toRefs(props),
          sliderSize,
          disabled: sliderDisabled,
          precision,
          emitChange,
          resetSize,
          updateDragging
        });
        expose({
          onSliderClick
        });
        return (_ctx, _cache) => {
          var _a, _b;
          return vue.openBlock(), vue.createElementBlock("div", {
            id: _ctx.range ? vue.unref(inputId) : void 0,
            ref_key: "sliderWrapper",
            ref: sliderWrapper,
            class: vue.normalizeClass(vue.unref(sliderKls)),
            role: _ctx.range ? "group" : void 0,
            "aria-label": _ctx.range && !vue.unref(isLabeledByFormItem) ? vue.unref(groupLabel) : void 0,
            "aria-labelledby": _ctx.range && vue.unref(isLabeledByFormItem) ? (_a = vue.unref(elFormItem)) == null ? void 0 : _a.labelId : void 0,
            onTouchstart: _cache[2] || (_cache[2] = (...args) => vue.unref(onSliderWrapperPrevent) && vue.unref(onSliderWrapperPrevent)(...args)),
            onTouchmove: _cache[3] || (_cache[3] = (...args) => vue.unref(onSliderWrapperPrevent) && vue.unref(onSliderWrapperPrevent)(...args))
          }, [
            vue.createElementVNode("div", {
              ref_key: "slider",
              ref: slider,
              class: vue.normalizeClass([
                vue.unref(ns).e("runway"),
                { "show-input": _ctx.showInput && !_ctx.range },
                vue.unref(ns).is("disabled", vue.unref(sliderDisabled))
              ]),
              style: vue.normalizeStyle(vue.unref(runwayStyle)),
              onMousedown: _cache[0] || (_cache[0] = (...args) => vue.unref(onSliderDown) && vue.unref(onSliderDown)(...args)),
              onTouchstart: _cache[1] || (_cache[1] = (...args) => vue.unref(onSliderDown) && vue.unref(onSliderDown)(...args))
            }, [
              vue.createElementVNode("div", {
                class: vue.normalizeClass(vue.unref(ns).e("bar")),
                style: vue.normalizeStyle(vue.unref(barStyle))
              }, null, 6),
              vue.createVNode(SliderButton, {
                id: !_ctx.range ? vue.unref(inputId) : void 0,
                ref_key: "firstButton",
                ref: firstButton,
                "model-value": vue.unref(firstValue),
                vertical: _ctx.vertical,
                "tooltip-class": _ctx.tooltipClass,
                placement: _ctx.placement,
                role: "slider",
                "aria-label": _ctx.range || !vue.unref(isLabeledByFormItem) ? vue.unref(firstButtonLabel) : void 0,
                "aria-labelledby": !_ctx.range && vue.unref(isLabeledByFormItem) ? (_b = vue.unref(elFormItem)) == null ? void 0 : _b.labelId : void 0,
                "aria-valuemin": _ctx.min,
                "aria-valuemax": _ctx.range ? vue.unref(secondValue) : _ctx.max,
                "aria-valuenow": vue.unref(firstValue),
                "aria-valuetext": vue.unref(firstValueText),
                "aria-orientation": _ctx.vertical ? "vertical" : "horizontal",
                "aria-disabled": vue.unref(sliderDisabled),
                "onUpdate:modelValue": vue.unref(setFirstValue)
              }, null, 8, ["id", "model-value", "vertical", "tooltip-class", "placement", "aria-label", "aria-labelledby", "aria-valuemin", "aria-valuemax", "aria-valuenow", "aria-valuetext", "aria-orientation", "aria-disabled", "onUpdate:modelValue"]),
              _ctx.range ? (vue.openBlock(), vue.createBlock(SliderButton, {
                key: 0,
                ref_key: "secondButton",
                ref: secondButton,
                "model-value": vue.unref(secondValue),
                vertical: _ctx.vertical,
                "tooltip-class": _ctx.tooltipClass,
                placement: _ctx.placement,
                role: "slider",
                "aria-label": vue.unref(secondButtonLabel),
                "aria-valuemin": vue.unref(firstValue),
                "aria-valuemax": _ctx.max,
                "aria-valuenow": vue.unref(secondValue),
                "aria-valuetext": vue.unref(secondValueText),
                "aria-orientation": _ctx.vertical ? "vertical" : "horizontal",
                "aria-disabled": vue.unref(sliderDisabled),
                "onUpdate:modelValue": vue.unref(setSecondValue)
              }, null, 8, ["model-value", "vertical", "tooltip-class", "placement", "aria-label", "aria-valuemin", "aria-valuemax", "aria-valuenow", "aria-valuetext", "aria-orientation", "aria-disabled", "onUpdate:modelValue"])) : vue.createCommentVNode("v-if", true),
              _ctx.showStops ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_2$a, [
                (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(vue.unref(stops), (item, key) => {
                  return vue.openBlock(), vue.createElementBlock("div", {
                    key,
                    class: vue.normalizeClass(vue.unref(ns).e("stop")),
                    style: vue.normalizeStyle(vue.unref(getStopStyle)(item))
                  }, null, 6);
                }), 128))
              ])) : vue.createCommentVNode("v-if", true),
              vue.unref(markList).length > 0 ? (vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: 2 }, [
                vue.createElementVNode("div", null, [
                  (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(vue.unref(markList), (item, key) => {
                    return vue.openBlock(), vue.createElementBlock("div", {
                      key,
                      style: vue.normalizeStyle(vue.unref(getStopStyle)(item.position)),
                      class: vue.normalizeClass([vue.unref(ns).e("stop"), vue.unref(ns).e("marks-stop")])
                    }, null, 6);
                  }), 128))
                ]),
                vue.createElementVNode("div", {
                  class: vue.normalizeClass(vue.unref(ns).e("marks"))
                }, [
                  (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(vue.unref(markList), (item, key) => {
                    return vue.openBlock(), vue.createBlock(vue.unref(SliderMarker), {
                      key,
                      mark: item.mark,
                      style: vue.normalizeStyle(vue.unref(getStopStyle)(item.position))
                    }, null, 8, ["mark", "style"]);
                  }), 128))
                ], 2)
              ], 64)) : vue.createCommentVNode("v-if", true)
            ], 38),
            _ctx.showInput && !_ctx.range ? (vue.openBlock(), vue.createBlock(vue.unref(ElInputNumber), {
              key: 0,
              ref: "input",
              "model-value": vue.unref(firstValue),
              class: vue.normalizeClass(vue.unref(ns).e("input")),
              step: _ctx.step,
              disabled: vue.unref(sliderDisabled),
              controls: _ctx.showInputControls,
              min: _ctx.min,
              max: _ctx.max,
              debounce: _ctx.debounce,
              size: vue.unref(sliderInputSize),
              "onUpdate:modelValue": vue.unref(setFirstValue),
              onChange: vue.unref(emitChange)
            }, null, 8, ["model-value", "class", "step", "disabled", "controls", "min", "max", "debounce", "size", "onUpdate:modelValue", "onChange"])) : vue.createCommentVNode("v-if", true)
          ], 42, _hoisted_1$e);
        };
      }
    });
    var Slider = /* @__PURE__ */ _export_sfc(_sfc_main$u, [["__file", "slider.vue"]]);
  
    const ElSlider = withInstall(Slider);
  
    const spaceItemProps = buildProps({
      prefixCls: {
        type: String
      }
    });
    const SpaceItem = vue.defineComponent({
      name: "ElSpaceItem",
      props: spaceItemProps,
      setup(props, { slots }) {
        const ns = useNamespace("space");
        const classes = vue.computed(() => `${props.prefixCls || ns.b()}__item`);
        return () => vue.h("div", { class: classes.value }, vue.renderSlot(slots, "default"));
      }
    });
    var Item = SpaceItem;
  
    const SIZE_MAP = {
      small: 8,
      default: 12,
      large: 16
    };
    function useSpace(props) {
      const ns = useNamespace("space");
      const classes = vue.computed(() => [ns.b(), ns.m(props.direction), props.class]);
      const horizontalSize = vue.ref(0);
      const verticalSize = vue.ref(0);
      const containerStyle = vue.computed(() => {
        const wrapKls = props.wrap || props.fill ? { flexWrap: "wrap", marginBottom: `-${verticalSize.value}px` } : {};
        const alignment = {
          alignItems: props.alignment
        };
        return [wrapKls, alignment, props.style];
      });
      const itemStyle = vue.computed(() => {
        const itemBaseStyle = {
          paddingBottom: `${verticalSize.value}px`,
          marginRight: `${horizontalSize.value}px`
        };
        const fillStyle = props.fill ? { flexGrow: 1, minWidth: `${props.fillRatio}%` } : {};
        return [itemBaseStyle, fillStyle];
      });
      vue.watchEffect(() => {
        const { size = "small", wrap, direction: dir, fill } = props;
        if (isArray(size)) {
          const [h = 0, v = 0] = size;
          horizontalSize.value = h;
          verticalSize.value = v;
        } else {
          let val;
          if (isNumber(size)) {
            val = size;
          } else {
            val = SIZE_MAP[size || "small"] || SIZE_MAP.small;
          }
          if ((wrap || fill) && dir === "horizontal") {
            horizontalSize.value = verticalSize.value = val;
          } else {
            if (dir === "horizontal") {
              horizontalSize.value = val;
              verticalSize.value = 0;
            } else {
              verticalSize.value = val;
              horizontalSize.value = 0;
            }
          }
        }
      });
      return {
        classes,
        containerStyle,
        itemStyle
      };
    }
  
    const spaceProps = buildProps({
      direction: {
        type: String,
        values: ["horizontal", "vertical"],
        default: "horizontal"
      },
      class: {
        type: definePropType([
          String,
          Object,
          Array
        ]),
        default: ""
      },
      style: {
        type: definePropType([String, Array, Object]),
        default: ""
      },
      alignment: {
        type: definePropType(String),
        default: "center"
      },
      prefixCls: {
        type: String
      },
      spacer: {
        type: definePropType([Object, String, Number, Array]),
        default: null,
        validator: (val) => vue.isVNode(val) || isNumber(val) || isString(val)
      },
      wrap: Boolean,
      fill: Boolean,
      fillRatio: {
        type: Number,
        default: 100
      },
      size: {
        type: [String, Array, Number],
        values: componentSizes,
        validator: (val) => {
          return isNumber(val) || isArray(val) && val.length === 2 && val.every(isNumber);
        }
      }
    });
    var Space = vue.defineComponent({
      name: "ElSpace",
      props: spaceProps,
      setup(props, { slots }) {
        const { classes, containerStyle, itemStyle } = useSpace(props);
        function extractChildren(children, parentKey = "", extractedChildren = []) {
          const { prefixCls } = props;
          children.forEach((child, loopKey) => {
            if (isFragment(child)) {
              if (isArray(child.children)) {
                child.children.forEach((nested, key) => {
                  if (isFragment(nested) && isArray(nested.children)) {
                    extractChildren(nested.children, `${parentKey + key}-`, extractedChildren);
                  } else {
                    extractedChildren.push(vue.createVNode(Item, {
                      style: itemStyle.value,
                      prefixCls,
                      key: `nested-${parentKey + key}`
                    }, {
                      default: () => [nested]
                    }, PatchFlags.PROPS | PatchFlags.STYLE, ["style", "prefixCls"]));
                  }
                });
              }
            } else if (isValidElementNode(child)) {
              extractedChildren.push(vue.createVNode(Item, {
                style: itemStyle.value,
                prefixCls,
                key: `LoopKey${parentKey + loopKey}`
              }, {
                default: () => [child]
              }, PatchFlags.PROPS | PatchFlags.STYLE, ["style", "prefixCls"]));
            }
          });
          return extractedChildren;
        }
        return () => {
          var _a;
          const { spacer, direction } = props;
          const children = vue.renderSlot(slots, "default", { key: 0 }, () => []);
          if (((_a = children.children) != null ? _a : []).length === 0)
            return null;
          if (isArray(children.children)) {
            let extractedChildren = extractChildren(children.children);
            if (spacer) {
              const len = extractedChildren.length - 1;
              extractedChildren = extractedChildren.reduce((acc, child, idx) => {
                const children2 = [...acc, child];
                if (idx !== len) {
                  children2.push(vue.createVNode("span", {
                    style: [
                      itemStyle.value,
                      direction === "vertical" ? "width: 100%" : null
                    ],
                    key: idx
                  }, [
                    vue.isVNode(spacer) ? spacer : vue.createTextVNode(spacer, PatchFlags.TEXT)
                  ], PatchFlags.STYLE));
                }
                return children2;
              }, []);
            }
            return vue.createVNode("div", {
              class: classes.value,
              style: containerStyle.value
            }, extractedChildren, PatchFlags.STYLE | PatchFlags.CLASS);
          }
          return children.children;
        };
      }
    });
  
    const ElSpace = withInstall(Space);
  
    const stepsProps = buildProps({
      space: {
        type: [Number, String],
        default: ""
      },
      active: {
        type: Number,
        default: 0
      },
      direction: {
        type: String,
        default: "horizontal",
        values: ["horizontal", "vertical"]
      },
      alignCenter: {
        type: Boolean
      },
      simple: {
        type: Boolean
      },
      finishStatus: {
        type: String,
        values: ["wait", "process", "finish", "error", "success"],
        default: "finish"
      },
      processStatus: {
        type: String,
        values: ["wait", "process", "finish", "error", "success"],
        default: "process"
      }
    });
    const stepsEmits = {
      [CHANGE_EVENT]: (newVal, oldVal) => [newVal, oldVal].every(isNumber)
    };
  
    const __default__$m = vue.defineComponent({
      name: "ElSteps"
    });
    const _sfc_main$t = /* @__PURE__ */ vue.defineComponent({
      ...__default__$m,
      props: stepsProps,
      emits: stepsEmits,
      setup(__props, { emit }) {
        const props = __props;
        const ns = useNamespace("steps");
        const steps = vue.ref([]);
        vue.watch(steps, () => {
          steps.value.forEach((instance, index) => {
            instance.setIndex(index);
          });
        });
        vue.provide("ElSteps", { props, steps });
        vue.watch(() => props.active, (newVal, oldVal) => {
          emit(CHANGE_EVENT, newVal, oldVal);
        });
        return (_ctx, _cache) => {
          return vue.openBlock(), vue.createElementBlock("div", {
            class: vue.normalizeClass([vue.unref(ns).b(), vue.unref(ns).m(_ctx.simple ? "simple" : _ctx.direction)])
          }, [
            vue.renderSlot(_ctx.$slots, "default")
          ], 2);
        };
      }
    });
    var Steps = /* @__PURE__ */ _export_sfc(_sfc_main$t, [["__file", "steps.vue"]]);
  
    const stepProps = buildProps({
      title: {
        type: String,
        default: ""
      },
      icon: {
        type: iconPropType
      },
      description: {
        type: String,
        default: ""
      },
      status: {
        type: String,
        values: ["", "wait", "process", "finish", "error", "success"],
        default: ""
      }
    });
  
    const __default__$l = vue.defineComponent({
      name: "ElStep"
    });
    const _sfc_main$s = vue.defineComponent({
      ...__default__$l,
      props: stepProps,
      setup(__props) {
        const props = __props;
        const ns = useNamespace("step");
        const index = vue.ref(-1);
        const lineStyle = vue.ref({});
        const internalStatus = vue.ref("");
        const parent = vue.inject("ElSteps");
        const currentInstance = vue.getCurrentInstance();
        vue.onMounted(() => {
          vue.watch([
            () => parent.props.active,
            () => parent.props.processStatus,
            () => parent.props.finishStatus
          ], ([active]) => {
            updateStatus(active);
          }, { immediate: true });
        });
        vue.onBeforeUnmount(() => {
          parent.steps.value = parent.steps.value.filter((instance) => instance.uid !== (currentInstance == null ? void 0 : currentInstance.uid));
        });
        const currentStatus = vue.computed(() => {
          return props.status || internalStatus.value;
        });
        const prevStatus = vue.computed(() => {
          const prevStep = parent.steps.value[index.value - 1];
          return prevStep ? prevStep.currentStatus : "wait";
        });
        const isCenter = vue.computed(() => {
          return parent.props.alignCenter;
        });
        const isVertical = vue.computed(() => {
          return parent.props.direction === "vertical";
        });
        const isSimple = vue.computed(() => {
          return parent.props.simple;
        });
        const stepsCount = vue.computed(() => {
          return parent.steps.value.length;
        });
        const isLast = vue.computed(() => {
          var _a;
          return ((_a = parent.steps.value[stepsCount.value - 1]) == null ? void 0 : _a.uid) === (currentInstance == null ? void 0 : currentInstance.uid);
        });
        const space = vue.computed(() => {
          return isSimple.value ? "" : parent.props.space;
        });
        const style = vue.computed(() => {
          const style2 = {
            flexBasis: typeof space.value === "number" ? `${space.value}px` : space.value ? space.value : `${100 / (stepsCount.value - (isCenter.value ? 0 : 1))}%`
          };
          if (isVertical.value)
            return style2;
          if (isLast.value) {
            style2.maxWidth = `${100 / stepsCount.value}%`;
          }
          return style2;
        });
        const setIndex = (val) => {
          index.value = val;
        };
        const calcProgress = (status) => {
          let step = 100;
          const style2 = {};
          style2.transitionDelay = `${150 * index.value}ms`;
          if (status === parent.props.processStatus) {
            step = 0;
          } else if (status === "wait") {
            step = 0;
            style2.transitionDelay = `${-150 * index.value}ms`;
          }
          style2.borderWidth = step && !isSimple.value ? "1px" : 0;
          style2[parent.props.direction === "vertical" ? "height" : "width"] = `${step}%`;
          lineStyle.value = style2;
        };
        const updateStatus = (activeIndex) => {
          if (activeIndex > index.value) {
            internalStatus.value = parent.props.finishStatus;
          } else if (activeIndex === index.value && prevStatus.value !== "error") {
            internalStatus.value = parent.props.processStatus;
          } else {
            internalStatus.value = "wait";
          }
          const prevChild = parent.steps.value[index.value - 1];
          if (prevChild)
            prevChild.calcProgress(internalStatus.value);
        };
        const stepItemState = vue.reactive({
          uid: vue.computed(() => currentInstance == null ? void 0 : currentInstance.uid),
          currentStatus,
          setIndex,
          calcProgress
        });
        parent.steps.value = [...parent.steps.value, stepItemState];
        return (_ctx, _cache) => {
          return vue.openBlock(), vue.createElementBlock("div", {
            style: vue.normalizeStyle(vue.unref(style)),
            class: vue.normalizeClass([
              vue.unref(ns).b(),
              vue.unref(ns).is(vue.unref(isSimple) ? "simple" : vue.unref(parent).props.direction),
              vue.unref(ns).is("flex", vue.unref(isLast) && !vue.unref(space) && !vue.unref(isCenter)),
              vue.unref(ns).is("center", vue.unref(isCenter) && !vue.unref(isVertical) && !vue.unref(isSimple))
            ])
          }, [
            vue.createCommentVNode(" icon & line "),
            vue.createElementVNode("div", {
              class: vue.normalizeClass([vue.unref(ns).e("head"), vue.unref(ns).is(vue.unref(currentStatus))])
            }, [
              !vue.unref(isSimple) ? (vue.openBlock(), vue.createElementBlock("div", {
                key: 0,
                class: vue.normalizeClass(vue.unref(ns).e("line"))
              }, [
                vue.createElementVNode("i", {
                  class: vue.normalizeClass(vue.unref(ns).e("line-inner")),
                  style: vue.normalizeStyle(lineStyle.value)
                }, null, 6)
              ], 2)) : vue.createCommentVNode("v-if", true),
              vue.createElementVNode("div", {
                class: vue.normalizeClass([vue.unref(ns).e("icon"), vue.unref(ns).is(_ctx.icon || _ctx.$slots.icon ? "icon" : "text")])
              }, [
                vue.renderSlot(_ctx.$slots, "icon", {}, () => [
                  _ctx.icon ? (vue.openBlock(), vue.createBlock(vue.unref(ElIcon), {
                    key: 0,
                    class: vue.normalizeClass(vue.unref(ns).e("icon-inner"))
                  }, {
                    default: vue.withCtx(() => [
                      (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(_ctx.icon)))
                    ]),
                    _: 1
                  }, 8, ["class"])) : vue.unref(currentStatus) === "success" ? (vue.openBlock(), vue.createBlock(vue.unref(ElIcon), {
                    key: 1,
                    class: vue.normalizeClass([vue.unref(ns).e("icon-inner"), vue.unref(ns).is("status")])
                  }, {
                    default: vue.withCtx(() => [
                      vue.createVNode(vue.unref(check_default))
                    ]),
                    _: 1
                  }, 8, ["class"])) : vue.unref(currentStatus) === "error" ? (vue.openBlock(), vue.createBlock(vue.unref(ElIcon), {
                    key: 2,
                    class: vue.normalizeClass([vue.unref(ns).e("icon-inner"), vue.unref(ns).is("status")])
                  }, {
                    default: vue.withCtx(() => [
                      vue.createVNode(vue.unref(close_default))
                    ]),
                    _: 1
                  }, 8, ["class"])) : !vue.unref(isSimple) ? (vue.openBlock(), vue.createElementBlock("div", {
                    key: 3,
                    class: vue.normalizeClass(vue.unref(ns).e("icon-inner"))
                  }, vue.toDisplayString(index.value + 1), 3)) : vue.createCommentVNode("v-if", true)
                ])
              ], 2)
            ], 2),
            vue.createCommentVNode(" title & description "),
            vue.createElementVNode("div", {
              class: vue.normalizeClass(vue.unref(ns).e("main"))
            }, [
              vue.createElementVNode("div", {
                class: vue.normalizeClass([vue.unref(ns).e("title"), vue.unref(ns).is(vue.unref(currentStatus))])
              }, [
                vue.renderSlot(_ctx.$slots, "title", {}, () => [
                  vue.createTextVNode(vue.toDisplayString(_ctx.title), 1)
                ])
              ], 2),
              vue.unref(isSimple) ? (vue.openBlock(), vue.createElementBlock("div", {
                key: 0,
                class: vue.normalizeClass(vue.unref(ns).e("arrow"))
              }, null, 2)) : (vue.openBlock(), vue.createElementBlock("div", {
                key: 1,
                class: vue.normalizeClass([vue.unref(ns).e("description"), vue.unref(ns).is(vue.unref(currentStatus))])
              }, [
                vue.renderSlot(_ctx.$slots, "description", {}, () => [
                  vue.createTextVNode(vue.toDisplayString(_ctx.description), 1)
                ])
              ], 2))
            ], 2)
          ], 6);
        };
      }
    });
    var Step = /* @__PURE__ */ _export_sfc(_sfc_main$s, [["__file", "item.vue"]]);
  
    const ElSteps = withInstall(Steps, {
      Step
    });
    const ElStep = withNoopInstall(Step);
  
    const switchProps = buildProps({
      modelValue: {
        type: [Boolean, String, Number],
        default: false
      },
      value: {
        type: [Boolean, String, Number],
        default: false
      },
      disabled: {
        type: Boolean,
        default: false
      },
      width: {
        type: [String, Number],
        default: ""
      },
      inlinePrompt: {
        type: Boolean,
        default: false
      },
      activeIcon: {
        type: iconPropType
      },
      inactiveIcon: {
        type: iconPropType
      },
      activeText: {
        type: String,
        default: ""
      },
      inactiveText: {
        type: String,
        default: ""
      },
      activeColor: {
        type: String,
        default: ""
      },
      inactiveColor: {
        type: String,
        default: ""
      },
      borderColor: {
        type: String,
        default: ""
      },
      activeValue: {
        type: [Boolean, String, Number],
        default: true
      },
      inactiveValue: {
        type: [Boolean, String, Number],
        default: false
      },
      name: {
        type: String,
        default: ""
      },
      validateEvent: {
        type: Boolean,
        default: true
      },
      id: String,
      loading: {
        type: Boolean,
        default: false
      },
      beforeChange: {
        type: definePropType(Function)
      },
      size: {
        type: String,
        validator: isValidComponentSize
      },
      tabindex: {
        type: [String, Number]
      }
    });
    const switchEmits = {
      [UPDATE_MODEL_EVENT]: (val) => isBoolean(val) || isString(val) || isNumber(val),
      [CHANGE_EVENT]: (val) => isBoolean(val) || isString(val) || isNumber(val),
      [INPUT_EVENT]: (val) => isBoolean(val) || isString(val) || isNumber(val)
    };
  
    const _hoisted_1$d = ["onClick"];
    const _hoisted_2$9 = ["id", "aria-checked", "aria-disabled", "name", "true-value", "false-value", "disabled", "tabindex", "onKeydown"];
    const _hoisted_3$4 = ["aria-hidden"];
    const _hoisted_4$2 = ["aria-hidden"];
    const _hoisted_5$1 = ["aria-hidden"];
    const COMPONENT_NAME$8 = "ElSwitch";
    const __default__$k = vue.defineComponent({
      name: COMPONENT_NAME$8
    });
    const _sfc_main$r = /* @__PURE__ */ vue.defineComponent({
      ...__default__$k,
      props: switchProps,
      emits: switchEmits,
      setup(__props, { expose, emit }) {
        const props = __props;
        const vm = vue.getCurrentInstance();
        const { formItem } = useFormItem();
        const switchSize = useSize();
        const ns = useNamespace("switch");
        useDeprecated({
          from: '"value"',
          replacement: '"model-value" or "v-model"',
          scope: COMPONENT_NAME$8,
          version: "2.3.0",
          ref: "https://element-plus.org/en-US/component/switch.html#attributes",
          type: "Attribute"
        }, vue.computed(() => {
          var _a;
          return !!((_a = vm.vnode.props) == null ? void 0 : _a.value);
        }));
        const { inputId } = useFormItemInputId(props, {
          formItemContext: formItem
        });
        const switchDisabled = useDisabled(vue.computed(() => props.loading));
        const isControlled = vue.ref(props.modelValue !== false);
        const input = vue.ref();
        const core = vue.ref();
        const switchKls = vue.computed(() => [
          ns.b(),
          ns.m(switchSize.value),
          ns.is("disabled", switchDisabled.value),
          ns.is("checked", checked.value)
        ]);
        const coreStyle = vue.computed(() => ({
          width: addUnit(props.width)
        }));
        vue.watch(() => props.modelValue, () => {
          isControlled.value = true;
        });
        vue.watch(() => props.value, () => {
          isControlled.value = false;
        });
        const actualValue = vue.computed(() => {
          return isControlled.value ? props.modelValue : props.value;
        });
        const checked = vue.computed(() => actualValue.value === props.activeValue);
        if (![props.activeValue, props.inactiveValue].includes(actualValue.value)) {
          emit(UPDATE_MODEL_EVENT, props.inactiveValue);
          emit(CHANGE_EVENT, props.inactiveValue);
          emit(INPUT_EVENT, props.inactiveValue);
        }
        vue.watch(checked, (val) => {
          var _a;
          input.value.checked = val;
          if (props.validateEvent) {
            (_a = formItem == null ? void 0 : formItem.validate) == null ? void 0 : _a.call(formItem, "change").catch((err) => debugWarn());
          }
        });
        const handleChange = () => {
          const val = checked.value ? props.inactiveValue : props.activeValue;
          emit(UPDATE_MODEL_EVENT, val);
          emit(CHANGE_EVENT, val);
          emit(INPUT_EVENT, val);
          vue.nextTick(() => {
            input.value.checked = checked.value;
          });
        };
        const switchValue = () => {
          if (switchDisabled.value)
            return;
          const { beforeChange } = props;
          if (!beforeChange) {
            handleChange();
            return;
          }
          const shouldChange = beforeChange();
          const isPromiseOrBool = [
            isPromise(shouldChange),
            isBoolean(shouldChange)
          ].includes(true);
          if (!isPromiseOrBool) {
            throwError(COMPONENT_NAME$8, "beforeChange must return type `Promise<boolean>` or `boolean`");
          }
          if (isPromise(shouldChange)) {
            shouldChange.then((result) => {
              if (result) {
                handleChange();
              }
            }).catch((e) => {
            });
          } else if (shouldChange) {
            handleChange();
          }
        };
        const styles = vue.computed(() => {
          return ns.cssVarBlock({
            ...props.activeColor ? { "on-color": props.activeColor } : null,
            ...props.inactiveColor ? { "off-color": props.inactiveColor } : null,
            ...props.borderColor ? { "border-color": props.borderColor } : null
          });
        });
        const focus = () => {
          var _a, _b;
          (_b = (_a = input.value) == null ? void 0 : _a.focus) == null ? void 0 : _b.call(_a);
        };
        vue.onMounted(() => {
          input.value.checked = checked.value;
        });
        expose({
          focus,
          checked
        });
        return (_ctx, _cache) => {
          return vue.openBlock(), vue.createElementBlock("div", {
            class: vue.normalizeClass(vue.unref(switchKls)),
            style: vue.normalizeStyle(vue.unref(styles)),
            onClick: vue.withModifiers(switchValue, ["prevent"])
          }, [
            vue.createElementVNode("input", {
              id: vue.unref(inputId),
              ref_key: "input",
              ref: input,
              class: vue.normalizeClass(vue.unref(ns).e("input")),
              type: "checkbox",
              role: "switch",
              "aria-checked": vue.unref(checked),
              "aria-disabled": vue.unref(switchDisabled),
              name: _ctx.name,
              "true-value": _ctx.activeValue,
              "false-value": _ctx.inactiveValue,
              disabled: vue.unref(switchDisabled),
              tabindex: _ctx.tabindex,
              onChange: handleChange,
              onKeydown: vue.withKeys(switchValue, ["enter"])
            }, null, 42, _hoisted_2$9),
            !_ctx.inlinePrompt && (_ctx.inactiveIcon || _ctx.inactiveText) ? (vue.openBlock(), vue.createElementBlock("span", {
              key: 0,
              class: vue.normalizeClass([
                vue.unref(ns).e("label"),
                vue.unref(ns).em("label", "left"),
                vue.unref(ns).is("active", !vue.unref(checked))
              ])
            }, [
              _ctx.inactiveIcon ? (vue.openBlock(), vue.createBlock(vue.unref(ElIcon), { key: 0 }, {
                default: vue.withCtx(() => [
                  (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(_ctx.inactiveIcon)))
                ]),
                _: 1
              })) : vue.createCommentVNode("v-if", true),
              !_ctx.inactiveIcon && _ctx.inactiveText ? (vue.openBlock(), vue.createElementBlock("span", {
                key: 1,
                "aria-hidden": vue.unref(checked)
              }, vue.toDisplayString(_ctx.inactiveText), 9, _hoisted_3$4)) : vue.createCommentVNode("v-if", true)
            ], 2)) : vue.createCommentVNode("v-if", true),
            vue.createElementVNode("span", {
              ref_key: "core",
              ref: core,
              class: vue.normalizeClass(vue.unref(ns).e("core")),
              style: vue.normalizeStyle(vue.unref(coreStyle))
            }, [
              _ctx.inlinePrompt ? (vue.openBlock(), vue.createElementBlock("div", {
                key: 0,
                class: vue.normalizeClass(vue.unref(ns).e("inner"))
              }, [
                _ctx.activeIcon || _ctx.inactiveIcon ? (vue.openBlock(), vue.createBlock(vue.unref(ElIcon), {
                  key: 0,
                  class: vue.normalizeClass(vue.unref(ns).is("icon"))
                }, {
                  default: vue.withCtx(() => [
                    (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(vue.unref(checked) ? _ctx.activeIcon : _ctx.inactiveIcon)))
                  ]),
                  _: 1
                }, 8, ["class"])) : _ctx.activeText || _ctx.inactiveText ? (vue.openBlock(), vue.createElementBlock("span", {
                  key: 1,
                  class: vue.normalizeClass(vue.unref(ns).is("text")),
                  "aria-hidden": !vue.unref(checked)
                }, vue.toDisplayString(vue.unref(checked) ? _ctx.activeText : _ctx.inactiveText), 11, _hoisted_4$2)) : vue.createCommentVNode("v-if", true)
              ], 2)) : vue.createCommentVNode("v-if", true),
              vue.createElementVNode("div", {
                class: vue.normalizeClass(vue.unref(ns).e("action"))
              }, [
                _ctx.loading ? (vue.openBlock(), vue.createBlock(vue.unref(ElIcon), {
                  key: 0,
                  class: vue.normalizeClass(vue.unref(ns).is("loading"))
                }, {
                  default: vue.withCtx(() => [
                    vue.createVNode(vue.unref(loading_default))
                  ]),
                  _: 1
                }, 8, ["class"])) : vue.createCommentVNode("v-if", true)
              ], 2)
            ], 6),
            !_ctx.inlinePrompt && (_ctx.activeIcon || _ctx.activeText) ? (vue.openBlock(), vue.createElementBlock("span", {
              key: 1,
              class: vue.normalizeClass([
                vue.unref(ns).e("label"),
                vue.unref(ns).em("label", "right"),
                vue.unref(ns).is("active", vue.unref(checked))
              ])
            }, [
              _ctx.activeIcon ? (vue.openBlock(), vue.createBlock(vue.unref(ElIcon), { key: 0 }, {
                default: vue.withCtx(() => [
                  (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(_ctx.activeIcon)))
                ]),
                _: 1
              })) : vue.createCommentVNode("v-if", true),
              !_ctx.activeIcon && _ctx.activeText ? (vue.openBlock(), vue.createElementBlock("span", {
                key: 1,
                "aria-hidden": !vue.unref(checked)
              }, vue.toDisplayString(_ctx.activeText), 9, _hoisted_5$1)) : vue.createCommentVNode("v-if", true)
            ], 2)) : vue.createCommentVNode("v-if", true)
          ], 14, _hoisted_1$d);
        };
      }
    });
    var Switch = /* @__PURE__ */ _export_sfc(_sfc_main$r, [["__file", "switch.vue"]]);
  
    const ElSwitch = withInstall(Switch);
  
    var matchHtmlRegExp = /["'&<>]/;
    var escapeHtml_1 = escapeHtml;
    function escapeHtml(string) {
      var str = "" + string;
      var match = matchHtmlRegExp.exec(str);
      if (!match) {
        return str;
      }
      var escape;
      var html = "";
      var index = 0;
      var lastIndex = 0;
      for (index = match.index; index < str.length; index++) {
        switch (str.charCodeAt(index)) {
          case 34:
            escape = "&quot;";
            break;
          case 38:
            escape = "&amp;";
            break;
          case 39:
            escape = "&#39;";
            break;
          case 60:
            escape = "&lt;";
            break;
          case 62:
            escape = "&gt;";
            break;
          default:
            continue;
        }
        if (lastIndex !== index) {
          html += str.substring(lastIndex, index);
        }
        lastIndex = index + 1;
        html += escape;
      }
      return lastIndex !== index ? html + str.substring(lastIndex, index) : html;
    }
    /*!
     * escape-html
     * Copyright(c) 2012-2013 TJ Holowaychuk
     * Copyright(c) 2015 Andreas Lubbe
     * Copyright(c) 2015 Tiancheng "Timothy" Gu
     * MIT Licensed
     */
  
    const getCell = function(event) {
      var _a;
      return (_a = event.target) == null ? void 0 : _a.closest("td");
    };
    const isObject = function(obj) {
      return obj !== null && typeof obj === "object";
    };
    const orderBy = function(array, sortKey, reverse, sortMethod, sortBy) {
      if (!sortKey && !sortMethod && (!sortBy || Array.isArray(sortBy) && !sortBy.length)) {
        return array;
      }
      if (typeof reverse === "string") {
        reverse = reverse === "descending" ? -1 : 1;
      } else {
        reverse = reverse && reverse < 0 ? -1 : 1;
      }
      const getKey = sortMethod ? null : function(value, index) {
        if (sortBy) {
          if (!Array.isArray(sortBy)) {
            sortBy = [sortBy];
          }
          return sortBy.map((by) => {
            if (typeof by === "string") {
              return get(value, by);
            } else {
              return by(value, index, array);
            }
          });
        }
        if (sortKey !== "$key") {
          if (isObject(value) && "$value" in value)
            value = value.$value;
        }
        return [isObject(value) ? get(value, sortKey) : value];
      };
      const compare = function(a, b) {
        if (sortMethod) {
          return sortMethod(a.value, b.value);
        }
        for (let i = 0, len = a.key.length; i < len; i++) {
          if (a.key[i] < b.key[i]) {
            return -1;
          }
          if (a.key[i] > b.key[i]) {
            return 1;
          }
        }
        return 0;
      };
      return array.map((value, index) => {
        return {
          value,
          index,
          key: getKey ? getKey(value, index) : null
        };
      }).sort((a, b) => {
        let order = compare(a, b);
        if (!order) {
          order = a.index - b.index;
        }
        return order * +reverse;
      }).map((item) => item.value);
    };
    const getColumnById = function(table, columnId) {
      let column = null;
      table.columns.forEach((item) => {
        if (item.id === columnId) {
          column = item;
        }
      });
      return column;
    };
    const getColumnByKey = function(table, columnKey) {
      let column = null;
      for (let i = 0; i < table.columns.length; i++) {
        const item = table.columns[i];
        if (item.columnKey === columnKey) {
          column = item;
          break;
        }
      }
      if (!column)
        throwError("ElTable", `No column matching with column-key: ${columnKey}`);
      return column;
    };
    const getColumnByCell = function(table, cell, namespace) {
      const matches = (cell.className || "").match(new RegExp(`${namespace}-table_[^\\s]+`, "gm"));
      if (matches) {
        return getColumnById(table, matches[0]);
      }
      return null;
    };
    const getRowIdentity = (row, rowKey) => {
      if (!row)
        throw new Error("Row is required when get row identity");
      if (typeof rowKey === "string") {
        if (!rowKey.includes(".")) {
          return `${row[rowKey]}`;
        }
        const key = rowKey.split(".");
        let current = row;
        for (const element of key) {
          current = current[element];
        }
        return `${current}`;
      } else if (typeof rowKey === "function") {
        return rowKey.call(null, row);
      }
    };
    const getKeysMap = function(array, rowKey) {
      const arrayMap = {};
      (array || []).forEach((row, index) => {
        arrayMap[getRowIdentity(row, rowKey)] = { row, index };
      });
      return arrayMap;
    };
    function mergeOptions(defaults, config) {
      const options = {};
      let key;
      for (key in defaults) {
        options[key] = defaults[key];
      }
      for (key in config) {
        if (hasOwn(config, key)) {
          const value = config[key];
          if (typeof value !== "undefined") {
            options[key] = value;
          }
        }
      }
      return options;
    }
    function parseWidth(width) {
      if (width === "")
        return width;
      if (width !== void 0) {
        width = Number.parseInt(width, 10);
        if (Number.isNaN(width)) {
          width = "";
        }
      }
      return width;
    }
    function parseMinWidth(minWidth) {
      if (minWidth === "")
        return minWidth;
      if (minWidth !== void 0) {
        minWidth = parseWidth(minWidth);
        if (Number.isNaN(minWidth)) {
          minWidth = 80;
        }
      }
      return minWidth;
    }
    function parseHeight(height) {
      if (typeof height === "number") {
        return height;
      }
      if (typeof height === "string") {
        if (/^\d+(?:px)?$/.test(height)) {
          return Number.parseInt(height, 10);
        } else {
          return height;
        }
      }
      return null;
    }
    function compose(...funcs) {
      if (funcs.length === 0) {
        return (arg) => arg;
      }
      if (funcs.length === 1) {
        return funcs[0];
      }
      return funcs.reduce((a, b) => (...args) => a(b(...args)));
    }
    function toggleRowStatus(statusArr, row, newVal) {
      let changed = false;
      const index = statusArr.indexOf(row);
      const included = index !== -1;
      const toggleStatus = (type) => {
        if (type === "add") {
          statusArr.push(row);
        } else {
          statusArr.splice(index, 1);
        }
        changed = true;
        if (isArray(row.children)) {
          row.children.forEach((item) => {
            toggleRowStatus(statusArr, item, newVal != null ? newVal : !included);
          });
        }
      };
      if (isBoolean(newVal)) {
        if (newVal && !included) {
          toggleStatus("add");
        } else if (!newVal && included) {
          toggleStatus("remove");
        }
      } else {
        included ? toggleStatus("remove") : toggleStatus("add");
      }
      return changed;
    }
    function walkTreeNode(root, cb, childrenKey = "children", lazyKey = "hasChildren") {
      const isNil = (array) => !(Array.isArray(array) && array.length);
      function _walker(parent, children, level) {
        cb(parent, children, level);
        children.forEach((item) => {
          if (item[lazyKey]) {
            cb(item, null, level + 1);
            return;
          }
          const children2 = item[childrenKey];
          if (!isNil(children2)) {
            _walker(item, children2, level + 1);
          }
        });
      }
      root.forEach((item) => {
        if (item[lazyKey]) {
          cb(item, null, 0);
          return;
        }
        const children = item[childrenKey];
        if (!isNil(children)) {
          _walker(item, children, 0);
        }
      });
    }
    let removePopper;
    function createTablePopper(parentNode, trigger, popperContent, popperOptions, tooltipEffect) {
      const { nextZIndex } = useZIndex();
      const ns = parentNode == null ? void 0 : parentNode.dataset.prefix;
      const scrollContainer = parentNode == null ? void 0 : parentNode.querySelector(`.${ns}-scrollbar__wrap`);
      function renderContent() {
        const isLight = tooltipEffect === "light";
        const content2 = document.createElement("div");
        content2.className = `${ns}-popper ${isLight ? "is-light" : "is-dark"}`;
        popperContent = escapeHtml_1(popperContent);
        content2.innerHTML = popperContent;
        content2.style.zIndex = String(nextZIndex());
        parentNode == null ? void 0 : parentNode.appendChild(content2);
        return content2;
      }
      function renderArrow() {
        const arrow2 = document.createElement("div");
        arrow2.className = `${ns}-popper__arrow`;
        return arrow2;
      }
      function showPopper() {
        popperInstance && popperInstance.update();
      }
      removePopper == null ? void 0 : removePopper();
      removePopper = () => {
        try {
          popperInstance && popperInstance.destroy();
          content && (parentNode == null ? void 0 : parentNode.removeChild(content));
          trigger.removeEventListener("mouseenter", showPopper);
          trigger.removeEventListener("mouseleave", removePopper);
          scrollContainer == null ? void 0 : scrollContainer.removeEventListener("scroll", removePopper);
          removePopper = void 0;
        } catch (e) {
        }
      };
      let popperInstance = null;
      const content = renderContent();
      const arrow = renderArrow();
      content.appendChild(arrow);
      popperInstance = yn(trigger, content, {
        strategy: "absolute",
        modifiers: [
          {
            name: "offset",
            options: {
              offset: [0, 8]
            }
          },
          {
            name: "arrow",
            options: {
              element: arrow,
              padding: 10
            }
          }
        ],
        ...popperOptions
      });
      trigger.addEventListener("mouseenter", showPopper);
      trigger.addEventListener("mouseleave", removePopper);
      scrollContainer == null ? void 0 : scrollContainer.addEventListener("scroll", removePopper);
      return popperInstance;
    }
    function getCurrentColumns(column) {
      if (column.children) {
        return flatMap(column.children, getCurrentColumns);
      } else {
        return [column];
      }
    }
    function getColSpan(colSpan, column) {
      return colSpan + column.colSpan;
    }
    const isFixedColumn = (index, fixed, store, realColumns) => {
      let start = 0;
      let after = index;
      const columns = store.states.columns.value;
      if (realColumns) {
        const curColumns = getCurrentColumns(realColumns[index]);
        const preColumns = columns.slice(0, columns.indexOf(curColumns[0]));
        start = preColumns.reduce(getColSpan, 0);
        after = start + curColumns.reduce(getColSpan, 0) - 1;
      } else {
        start = index;
      }
      let fixedLayout;
      switch (fixed) {
        case "left":
          if (after < store.states.fixedLeafColumnsLength.value) {
            fixedLayout = "left";
          }
          break;
        case "right":
          if (start >= columns.length - store.states.rightFixedLeafColumnsLength.value) {
            fixedLayout = "right";
          }
          break;
        default:
          if (after < store.states.fixedLeafColumnsLength.value) {
            fixedLayout = "left";
          } else if (start >= columns.length - store.states.rightFixedLeafColumnsLength.value) {
            fixedLayout = "right";
          }
      }
      return fixedLayout ? {
        direction: fixedLayout,
        start,
        after
      } : {};
    };
    const getFixedColumnsClass = (namespace, index, fixed, store, realColumns, offset = 0) => {
      const classes = [];
      const { direction, start, after } = isFixedColumn(index, fixed, store, realColumns);
      if (direction) {
        const isLeft = direction === "left";
        classes.push(`${namespace}-fixed-column--${direction}`);
        if (isLeft && after + offset === store.states.fixedLeafColumnsLength.value - 1) {
          classes.push("is-last-column");
        } else if (!isLeft && start - offset === store.states.columns.value.length - store.states.rightFixedLeafColumnsLength.value) {
          classes.push("is-first-column");
        }
      }
      return classes;
    };
    function getOffset(offset, column) {
      return offset + (column.realWidth === null || Number.isNaN(column.realWidth) ? Number(column.width) : column.realWidth);
    }
    const getFixedColumnOffset = (index, fixed, store, realColumns) => {
      const {
        direction,
        start = 0,
        after = 0
      } = isFixedColumn(index, fixed, store, realColumns);
      if (!direction) {
        return;
      }
      const styles = {};
      const isLeft = direction === "left";
      const columns = store.states.columns.value;
      if (isLeft) {
        styles.left = columns.slice(0, start).reduce(getOffset, 0);
      } else {
        styles.right = columns.slice(after + 1).reverse().reduce(getOffset, 0);
      }
      return styles;
    };
    const ensurePosition = (style, key) => {
      if (!style)
        return;
      if (!Number.isNaN(style[key])) {
        style[key] = `${style[key]}px`;
      }
    };
  
    function useExpand(watcherData) {
      const instance = vue.getCurrentInstance();
      const defaultExpandAll = vue.ref(false);
      const expandRows = vue.ref([]);
      const updateExpandRows = () => {
        const data = watcherData.data.value || [];
        const rowKey = watcherData.rowKey.value;
        if (defaultExpandAll.value) {
          expandRows.value = data.slice();
        } else if (rowKey) {
          const expandRowsMap = getKeysMap(expandRows.value, rowKey);
          expandRows.value = data.reduce((prev, row) => {
            const rowId = getRowIdentity(row, rowKey);
            const rowInfo = expandRowsMap[rowId];
            if (rowInfo) {
              prev.push(row);
            }
            return prev;
          }, []);
        } else {
          expandRows.value = [];
        }
      };
      const toggleRowExpansion = (row, expanded) => {
        const changed = toggleRowStatus(expandRows.value, row, expanded);
        if (changed) {
          instance.emit("expand-change", row, expandRows.value.slice());
        }
      };
      const setExpandRowKeys = (rowKeys) => {
        instance.store.assertRowKey();
        const data = watcherData.data.value || [];
        const rowKey = watcherData.rowKey.value;
        const keysMap = getKeysMap(data, rowKey);
        expandRows.value = rowKeys.reduce((prev, cur) => {
          const info = keysMap[cur];
          if (info) {
            prev.push(info.row);
          }
          return prev;
        }, []);
      };
      const isRowExpanded = (row) => {
        const rowKey = watcherData.rowKey.value;
        if (rowKey) {
          const expandMap = getKeysMap(expandRows.value, rowKey);
          return !!expandMap[getRowIdentity(row, rowKey)];
        }
        return expandRows.value.includes(row);
      };
      return {
        updateExpandRows,
        toggleRowExpansion,
        setExpandRowKeys,
        isRowExpanded,
        states: {
          expandRows,
          defaultExpandAll
        }
      };
    }
  
    function useCurrent(watcherData) {
      const instance = vue.getCurrentInstance();
      const _currentRowKey = vue.ref(null);
      const currentRow = vue.ref(null);
      const setCurrentRowKey = (key) => {
        instance.store.assertRowKey();
        _currentRowKey.value = key;
        setCurrentRowByKey(key);
      };
      const restoreCurrentRowKey = () => {
        _currentRowKey.value = null;
      };
      const setCurrentRowByKey = (key) => {
        const { data, rowKey } = watcherData;
        let _currentRow = null;
        if (rowKey.value) {
          _currentRow = (vue.unref(data) || []).find((item) => getRowIdentity(item, rowKey.value) === key);
        }
        currentRow.value = _currentRow;
        instance.emit("current-change", currentRow.value, null);
      };
      const updateCurrentRow = (_currentRow) => {
        const oldCurrentRow = currentRow.value;
        if (_currentRow && _currentRow !== oldCurrentRow) {
          currentRow.value = _currentRow;
          instance.emit("current-change", currentRow.value, oldCurrentRow);
          return;
        }
        if (!_currentRow && oldCurrentRow) {
          currentRow.value = null;
          instance.emit("current-change", null, oldCurrentRow);
        }
      };
      const updateCurrentRowData = () => {
        const rowKey = watcherData.rowKey.value;
        const data = watcherData.data.value || [];
        const oldCurrentRow = currentRow.value;
        if (!data.includes(oldCurrentRow) && oldCurrentRow) {
          if (rowKey) {
            const currentRowKey = getRowIdentity(oldCurrentRow, rowKey);
            setCurrentRowByKey(currentRowKey);
          } else {
            currentRow.value = null;
          }
          if (currentRow.value === null) {
            instance.emit("current-change", null, oldCurrentRow);
          }
        } else if (_currentRowKey.value) {
          setCurrentRowByKey(_currentRowKey.value);
          restoreCurrentRowKey();
        }
      };
      return {
        setCurrentRowKey,
        restoreCurrentRowKey,
        setCurrentRowByKey,
        updateCurrentRow,
        updateCurrentRowData,
        states: {
          _currentRowKey,
          currentRow
        }
      };
    }
  
    function useTree$2(watcherData) {
      const expandRowKeys = vue.ref([]);
      const treeData = vue.ref({});
      const indent = vue.ref(16);
      const lazy = vue.ref(false);
      const lazyTreeNodeMap = vue.ref({});
      const lazyColumnIdentifier = vue.ref("hasChildren");
      const childrenColumnName = vue.ref("children");
      const instance = vue.getCurrentInstance();
      const normalizedData = vue.computed(() => {
        if (!watcherData.rowKey.value)
          return {};
        const data = watcherData.data.value || [];
        return normalize(data);
      });
      const normalizedLazyNode = vue.computed(() => {
        const rowKey = watcherData.rowKey.value;
        const keys = Object.keys(lazyTreeNodeMap.value);
        const res = {};
        if (!keys.length)
          return res;
        keys.forEach((key) => {
          if (lazyTreeNodeMap.value[key].length) {
            const item = { children: [] };
            lazyTreeNodeMap.value[key].forEach((row) => {
              const currentRowKey = getRowIdentity(row, rowKey);
              item.children.push(currentRowKey);
              if (row[lazyColumnIdentifier.value] && !res[currentRowKey]) {
                res[currentRowKey] = { children: [] };
              }
            });
            res[key] = item;
          }
        });
        return res;
      });
      const normalize = (data) => {
        const rowKey = watcherData.rowKey.value;
        const res = {};
        walkTreeNode(data, (parent, children, level) => {
          const parentId = getRowIdentity(parent, rowKey);
          if (Array.isArray(children)) {
            res[parentId] = {
              children: children.map((row) => getRowIdentity(row, rowKey)),
              level
            };
          } else if (lazy.value) {
            res[parentId] = {
              children: [],
              lazy: true,
              level
            };
          }
        }, childrenColumnName.value, lazyColumnIdentifier.value);
        return res;
      };
      const updateTreeData = (ifChangeExpandRowKeys = false, ifExpandAll = ((_a) => (_a = instance.store) == null ? void 0 : _a.states.defaultExpandAll.value)()) => {
        var _a2;
        const nested = normalizedData.value;
        const normalizedLazyNode_ = normalizedLazyNode.value;
        const keys = Object.keys(nested);
        const newTreeData = {};
        if (keys.length) {
          const oldTreeData = vue.unref(treeData);
          const rootLazyRowKeys = [];
          const getExpanded = (oldValue, key) => {
            if (ifChangeExpandRowKeys) {
              if (expandRowKeys.value) {
                return ifExpandAll || expandRowKeys.value.includes(key);
              } else {
                return !!(ifExpandAll || (oldValue == null ? void 0 : oldValue.expanded));
              }
            } else {
              const included = ifExpandAll || expandRowKeys.value && expandRowKeys.value.includes(key);
              return !!((oldValue == null ? void 0 : oldValue.expanded) || included);
            }
          };
          keys.forEach((key) => {
            const oldValue = oldTreeData[key];
            const newValue = { ...nested[key] };
            newValue.expanded = getExpanded(oldValue, key);
            if (newValue.lazy) {
              const { loaded = false, loading = false } = oldValue || {};
              newValue.loaded = !!loaded;
              newValue.loading = !!loading;
              rootLazyRowKeys.push(key);
            }
            newTreeData[key] = newValue;
          });
          const lazyKeys = Object.keys(normalizedLazyNode_);
          if (lazy.value && lazyKeys.length && rootLazyRowKeys.length) {
            lazyKeys.forEach((key) => {
              const oldValue = oldTreeData[key];
              const lazyNodeChildren = normalizedLazyNode_[key].children;
              if (rootLazyRowKeys.includes(key)) {
                if (newTreeData[key].children.length !== 0) {
                  throw new Error("[ElTable]children must be an empty array.");
                }
                newTreeData[key].children = lazyNodeChildren;
              } else {
                const { loaded = false, loading = false } = oldValue || {};
                newTreeData[key] = {
                  lazy: true,
                  loaded: !!loaded,
                  loading: !!loading,
                  expanded: getExpanded(oldValue, key),
                  children: lazyNodeChildren,
                  level: ""
                };
              }
            });
          }
        }
        treeData.value = newTreeData;
        (_a2 = instance.store) == null ? void 0 : _a2.updateTableScrollY();
      };
      vue.watch(() => expandRowKeys.value, () => {
        updateTreeData(true);
      });
      vue.watch(() => normalizedData.value, () => {
        updateTreeData();
      });
      vue.watch(() => normalizedLazyNode.value, () => {
        updateTreeData();
      });
      const updateTreeExpandKeys = (value) => {
        expandRowKeys.value = value;
        updateTreeData();
      };
      const toggleTreeExpansion = (row, expanded) => {
        instance.store.assertRowKey();
        const rowKey = watcherData.rowKey.value;
        const id = getRowIdentity(row, rowKey);
        const data = id && treeData.value[id];
        if (id && data && "expanded" in data) {
          const oldExpanded = data.expanded;
          expanded = typeof expanded === "undefined" ? !data.expanded : expanded;
          treeData.value[id].expanded = expanded;
          if (oldExpanded !== expanded) {
            instance.emit("expand-change", row, expanded);
          }
          instance.store.updateTableScrollY();
        }
      };
      const loadOrToggle = (row) => {
        instance.store.assertRowKey();
        const rowKey = watcherData.rowKey.value;
        const id = getRowIdentity(row, rowKey);
        const data = treeData.value[id];
        if (lazy.value && data && "loaded" in data && !data.loaded) {
          loadData(row, id, data);
        } else {
          toggleTreeExpansion(row, void 0);
        }
      };
      const loadData = (row, key, treeNode) => {
        const { load } = instance.props;
        if (load && !treeData.value[key].loaded) {
          treeData.value[key].loading = true;
          load(row, treeNode, (data) => {
            if (!Array.isArray(data)) {
              throw new TypeError("[ElTable] data must be an array");
            }
            treeData.value[key].loading = false;
            treeData.value[key].loaded = true;
            treeData.value[key].expanded = true;
            if (data.length) {
              lazyTreeNodeMap.value[key] = data;
            }
            instance.emit("expand-change", row, true);
          });
        }
      };
      return {
        loadData,
        loadOrToggle,
        toggleTreeExpansion,
        updateTreeExpandKeys,
        updateTreeData,
        normalize,
        states: {
          expandRowKeys,
          treeData,
          indent,
          lazy,
          lazyTreeNodeMap,
          lazyColumnIdentifier,
          childrenColumnName
        }
      };
    }
  
    const sortData = (data, states) => {
      const sortingColumn = states.sortingColumn;
      if (!sortingColumn || typeof sortingColumn.sortable === "string") {
        return data;
      }
      return orderBy(data, states.sortProp, states.sortOrder, sortingColumn.sortMethod, sortingColumn.sortBy);
    };
    const doFlattenColumns = (columns) => {
      const result = [];
      columns.forEach((column) => {
        if (column.children) {
          result.push.apply(result, doFlattenColumns(column.children));
        } else {
          result.push(column);
        }
      });
      return result;
    };
    function useWatcher$1() {
      var _a;
      const instance = vue.getCurrentInstance();
      const { size: tableSize } = vue.toRefs((_a = instance.proxy) == null ? void 0 : _a.$props);
      const rowKey = vue.ref(null);
      const data = vue.ref([]);
      const _data = vue.ref([]);
      const isComplex = vue.ref(false);
      const _columns = vue.ref([]);
      const originColumns = vue.ref([]);
      const columns = vue.ref([]);
      const fixedColumns = vue.ref([]);
      const rightFixedColumns = vue.ref([]);
      const leafColumns = vue.ref([]);
      const fixedLeafColumns = vue.ref([]);
      const rightFixedLeafColumns = vue.ref([]);
      const leafColumnsLength = vue.ref(0);
      const fixedLeafColumnsLength = vue.ref(0);
      const rightFixedLeafColumnsLength = vue.ref(0);
      const isAllSelected = vue.ref(false);
      const selection = vue.ref([]);
      const reserveSelection = vue.ref(false);
      const selectOnIndeterminate = vue.ref(false);
      const selectable = vue.ref(null);
      const filters = vue.ref({});
      const filteredData = vue.ref(null);
      const sortingColumn = vue.ref(null);
      const sortProp = vue.ref(null);
      const sortOrder = vue.ref(null);
      const hoverRow = vue.ref(null);
      vue.watch(data, () => instance.state && scheduleLayout(false), {
        deep: true
      });
      const assertRowKey = () => {
        if (!rowKey.value)
          throw new Error("[ElTable] prop row-key is required");
      };
      const updateChildFixed = (column) => {
        var _a2;
        (_a2 = column.children) == null ? void 0 : _a2.forEach((childColumn) => {
          childColumn.fixed = column.fixed;
          updateChildFixed(childColumn);
        });
      };
      const updateColumns = () => {
        _columns.value.forEach((column) => {
          updateChildFixed(column);
        });
        fixedColumns.value = _columns.value.filter((column) => column.fixed === true || column.fixed === "left");
        rightFixedColumns.value = _columns.value.filter((column) => column.fixed === "right");
        if (fixedColumns.value.length > 0 && _columns.value[0] && _columns.value[0].type === "selection" && !_columns.value[0].fixed) {
          _columns.value[0].fixed = true;
          fixedColumns.value.unshift(_columns.value[0]);
        }
        const notFixedColumns = _columns.value.filter((column) => !column.fixed);
        originColumns.value = [].concat(fixedColumns.value).concat(notFixedColumns).concat(rightFixedColumns.value);
        const leafColumns2 = doFlattenColumns(notFixedColumns);
        const fixedLeafColumns2 = doFlattenColumns(fixedColumns.value);
        const rightFixedLeafColumns2 = doFlattenColumns(rightFixedColumns.value);
        leafColumnsLength.value = leafColumns2.length;
        fixedLeafColumnsLength.value = fixedLeafColumns2.length;
        rightFixedLeafColumnsLength.value = rightFixedLeafColumns2.length;
        columns.value = [].concat(fixedLeafColumns2).concat(leafColumns2).concat(rightFixedLeafColumns2);
        isComplex.value = fixedColumns.value.length > 0 || rightFixedColumns.value.length > 0;
      };
      const scheduleLayout = (needUpdateColumns, immediate = false) => {
        if (needUpdateColumns) {
          updateColumns();
        }
        if (immediate) {
          instance.state.doLayout();
        } else {
          instance.state.debouncedUpdateLayout();
        }
      };
      const isSelected = (row) => {
        return selection.value.includes(row);
      };
      const clearSelection = () => {
        isAllSelected.value = false;
        const oldSelection = selection.value;
        if (oldSelection.length) {
          selection.value = [];
          instance.emit("selection-change", []);
        }
      };
      const cleanSelection = () => {
        let deleted;
        if (rowKey.value) {
          deleted = [];
          const selectedMap = getKeysMap(selection.value, rowKey.value);
          const dataMap = getKeysMap(data.value, rowKey.value);
          for (const key in selectedMap) {
            if (hasOwn(selectedMap, key) && !dataMap[key]) {
              deleted.push(selectedMap[key].row);
            }
          }
        } else {
          deleted = selection.value.filter((item) => !data.value.includes(item));
        }
        if (deleted.length) {
          const newSelection = selection.value.filter((item) => !deleted.includes(item));
          selection.value = newSelection;
          instance.emit("selection-change", newSelection.slice());
        }
      };
      const getSelectionRows = () => {
        return (selection.value || []).slice();
      };
      const toggleRowSelection = (row, selected = void 0, emitChange = true) => {
        const changed = toggleRowStatus(selection.value, row, selected);
        if (changed) {
          const newSelection = (selection.value || []).slice();
          if (emitChange) {
            instance.emit("select", newSelection, row);
          }
          instance.emit("selection-change", newSelection);
        }
      };
      const _toggleAllSelection = () => {
        var _a2, _b;
        const value = selectOnIndeterminate.value ? !isAllSelected.value : !(isAllSelected.value || selection.value.length);
        isAllSelected.value = value;
        let selectionChanged = false;
        let childrenCount = 0;
        const rowKey2 = (_b = (_a2 = instance == null ? void 0 : instance.store) == null ? void 0 : _a2.states) == null ? void 0 : _b.rowKey.value;
        data.value.forEach((row, index) => {
          const rowIndex = index + childrenCount;
          if (selectable.value) {
            if (selectable.value.call(null, row, rowIndex) && toggleRowStatus(selection.value, row, value)) {
              selectionChanged = true;
            }
          } else {
            if (toggleRowStatus(selection.value, row, value)) {
              selectionChanged = true;
            }
          }
          childrenCount += getChildrenCount(getRowIdentity(row, rowKey2));
        });
        if (selectionChanged) {
          instance.emit("selection-change", selection.value ? selection.value.slice() : []);
        }
        instance.emit("select-all", selection.value);
      };
      const updateSelectionByRowKey = () => {
        const selectedMap = getKeysMap(selection.value, rowKey.value);
        data.value.forEach((row) => {
          const rowId = getRowIdentity(row, rowKey.value);
          const rowInfo = selectedMap[rowId];
          if (rowInfo) {
            selection.value[rowInfo.index] = row;
          }
        });
      };
      const updateAllSelected = () => {
        var _a2, _b, _c;
        if (((_a2 = data.value) == null ? void 0 : _a2.length) === 0) {
          isAllSelected.value = false;
          return;
        }
        let selectedMap;
        if (rowKey.value) {
          selectedMap = getKeysMap(selection.value, rowKey.value);
        }
        const isSelected2 = function(row) {
          if (selectedMap) {
            return !!selectedMap[getRowIdentity(row, rowKey.value)];
          } else {
            return selection.value.includes(row);
          }
        };
        let isAllSelected_ = true;
        let selectedCount = 0;
        let childrenCount = 0;
        for (let i = 0, j = (data.value || []).length; i < j; i++) {
          const keyProp = (_c = (_b = instance == null ? void 0 : instance.store) == null ? void 0 : _b.states) == null ? void 0 : _c.rowKey.value;
          const rowIndex = i + childrenCount;
          const item = data.value[i];
          const isRowSelectable = selectable.value && selectable.value.call(null, item, rowIndex);
          if (!isSelected2(item)) {
            if (!selectable.value || isRowSelectable) {
              isAllSelected_ = false;
              break;
            }
          } else {
            selectedCount++;
          }
          childrenCount += getChildrenCount(getRowIdentity(item, keyProp));
        }
        if (selectedCount === 0)
          isAllSelected_ = false;
        isAllSelected.value = isAllSelected_;
      };
      const getChildrenCount = (rowKey2) => {
        var _a2;
        if (!instance || !instance.store)
          return 0;
        const { treeData } = instance.store.states;
        let count = 0;
        const children = (_a2 = treeData.value[rowKey2]) == null ? void 0 : _a2.children;
        if (children) {
          count += children.length;
          children.forEach((childKey) => {
            count += getChildrenCount(childKey);
          });
        }
        return count;
      };
      const updateFilters = (columns2, values) => {
        if (!Array.isArray(columns2)) {
          columns2 = [columns2];
        }
        const filters_ = {};
        columns2.forEach((col) => {
          filters.value[col.id] = values;
          filters_[col.columnKey || col.id] = values;
        });
        return filters_;
      };
      const updateSort = (column, prop, order) => {
        if (sortingColumn.value && sortingColumn.value !== column) {
          sortingColumn.value.order = null;
        }
        sortingColumn.value = column;
        sortProp.value = prop;
        sortOrder.value = order;
      };
      const execFilter = () => {
        let sourceData = vue.unref(_data);
        Object.keys(filters.value).forEach((columnId) => {
          const values = filters.value[columnId];
          if (!values || values.length === 0)
            return;
          const column = getColumnById({
            columns: columns.value
          }, columnId);
          if (column && column.filterMethod) {
            sourceData = sourceData.filter((row) => {
              return values.some((value) => column.filterMethod.call(null, value, row, column));
            });
          }
        });
        filteredData.value = sourceData;
      };
      const execSort = () => {
        data.value = sortData(filteredData.value, {
          sortingColumn: sortingColumn.value,
          sortProp: sortProp.value,
          sortOrder: sortOrder.value
        });
      };
      const execQuery = (ignore = void 0) => {
        if (!(ignore && ignore.filter)) {
          execFilter();
        }
        execSort();
      };
      const clearFilter = (columnKeys) => {
        const { tableHeaderRef } = instance.refs;
        if (!tableHeaderRef)
          return;
        const panels = Object.assign({}, tableHeaderRef.filterPanels);
        const keys = Object.keys(panels);
        if (!keys.length)
          return;
        if (typeof columnKeys === "string") {
          columnKeys = [columnKeys];
        }
        if (Array.isArray(columnKeys)) {
          const columns_ = columnKeys.map((key) => getColumnByKey({
            columns: columns.value
          }, key));
          keys.forEach((key) => {
            const column = columns_.find((col) => col.id === key);
            if (column) {
              column.filteredValue = [];
            }
          });
          instance.store.commit("filterChange", {
            column: columns_,
            values: [],
            silent: true,
            multi: true
          });
        } else {
          keys.forEach((key) => {
            const column = columns.value.find((col) => col.id === key);
            if (column) {
              column.filteredValue = [];
            }
          });
          filters.value = {};
          instance.store.commit("filterChange", {
            column: {},
            values: [],
            silent: true
          });
        }
      };
      const clearSort = () => {
        if (!sortingColumn.value)
          return;
        updateSort(null, null, null);
        instance.store.commit("changeSortCondition", {
          silent: true
        });
      };
      const {
        setExpandRowKeys,
        toggleRowExpansion,
        updateExpandRows,
        states: expandStates,
        isRowExpanded
      } = useExpand({
        data,
        rowKey
      });
      const {
        updateTreeExpandKeys,
        toggleTreeExpansion,
        updateTreeData,
        loadOrToggle,
        states: treeStates
      } = useTree$2({
        data,
        rowKey
      });
      const {
        updateCurrentRowData,
        updateCurrentRow,
        setCurrentRowKey,
        states: currentData
      } = useCurrent({
        data,
        rowKey
      });
      const setExpandRowKeysAdapter = (val) => {
        setExpandRowKeys(val);
        updateTreeExpandKeys(val);
      };
      const toggleRowExpansionAdapter = (row, expanded) => {
        const hasExpandColumn = columns.value.some(({ type }) => type === "expand");
        if (hasExpandColumn) {
          toggleRowExpansion(row, expanded);
        } else {
          toggleTreeExpansion(row, expanded);
        }
      };
      return {
        assertRowKey,
        updateColumns,
        scheduleLayout,
        isSelected,
        clearSelection,
        cleanSelection,
        getSelectionRows,
        toggleRowSelection,
        _toggleAllSelection,
        toggleAllSelection: null,
        updateSelectionByRowKey,
        updateAllSelected,
        updateFilters,
        updateCurrentRow,
        updateSort,
        execFilter,
        execSort,
        execQuery,
        clearFilter,
        clearSort,
        toggleRowExpansion,
        setExpandRowKeysAdapter,
        setCurrentRowKey,
        toggleRowExpansionAdapter,
        isRowExpanded,
        updateExpandRows,
        updateCurrentRowData,
        loadOrToggle,
        updateTreeData,
        states: {
          tableSize,
          rowKey,
          data,
          _data,
          isComplex,
          _columns,
          originColumns,
          columns,
          fixedColumns,
          rightFixedColumns,
          leafColumns,
          fixedLeafColumns,
          rightFixedLeafColumns,
          leafColumnsLength,
          fixedLeafColumnsLength,
          rightFixedLeafColumnsLength,
          isAllSelected,
          selection,
          reserveSelection,
          selectOnIndeterminate,
          selectable,
          filters,
          filteredData,
          sortingColumn,
          sortProp,
          sortOrder,
          hoverRow,
          ...expandStates,
          ...treeStates,
          ...currentData
        }
      };
    }
  
    function replaceColumn(array, column) {
      return array.map((item) => {
        var _a;
        if (item.id === column.id) {
          return column;
        } else if ((_a = item.children) == null ? void 0 : _a.length) {
          item.children = replaceColumn(item.children, column);
        }
        return item;
      });
    }
    function sortColumn(array) {
      array.forEach((item) => {
        var _a, _b;
        item.no = (_a = item.getColumnIndex) == null ? void 0 : _a.call(item);
        if ((_b = item.children) == null ? void 0 : _b.length) {
          sortColumn(item.children);
        }
      });
      array.sort((cur, pre) => cur.no - pre.no);
    }
    function useStore() {
      const instance = vue.getCurrentInstance();
      const watcher = useWatcher$1();
      const ns = useNamespace("table");
      const mutations = {
        setData(states, data) {
          const dataInstanceChanged = vue.unref(states._data) !== data;
          states.data.value = data;
          states._data.value = data;
          instance.store.execQuery();
          instance.store.updateCurrentRowData();
          instance.store.updateExpandRows();
          instance.store.updateTreeData(instance.store.states.defaultExpandAll.value);
          if (vue.unref(states.reserveSelection)) {
            instance.store.assertRowKey();
            instance.store.updateSelectionByRowKey();
          } else {
            if (dataInstanceChanged) {
              instance.store.clearSelection();
            } else {
              instance.store.cleanSelection();
            }
          }
          instance.store.updateAllSelected();
          if (instance.$ready) {
            instance.store.scheduleLayout();
          }
        },
        insertColumn(states, column, parent) {
          const array = vue.unref(states._columns);
          let newColumns = [];
          if (!parent) {
            array.push(column);
            newColumns = array;
          } else {
            if (parent && !parent.children) {
              parent.children = [];
            }
            parent.children.push(column);
            newColumns = replaceColumn(array, parent);
          }
          sortColumn(newColumns);
          states._columns.value = newColumns;
          if (column.type === "selection") {
            states.selectable.value = column.selectable;
            states.reserveSelection.value = column.reserveSelection;
          }
          if (instance.$ready) {
            instance.store.updateColumns();
            instance.store.scheduleLayout();
          }
        },
        removeColumn(states, column, parent) {
          const array = vue.unref(states._columns) || [];
          if (parent) {
            parent.children.splice(parent.children.findIndex((item) => item.id === column.id), 1);
            if (parent.children.length === 0) {
              delete parent.children;
            }
            states._columns.value = replaceColumn(array, parent);
          } else {
            const index = array.indexOf(column);
            if (index > -1) {
              array.splice(index, 1);
              states._columns.value = array;
            }
          }
          if (instance.$ready) {
            instance.store.updateColumns();
            instance.store.scheduleLayout();
          }
        },
        sort(states, options) {
          const { prop, order, init } = options;
          if (prop) {
            const column = vue.unref(states.columns).find((column2) => column2.property === prop);
            if (column) {
              column.order = order;
              instance.store.updateSort(column, prop, order);
              instance.store.commit("changeSortCondition", { init });
            }
          }
        },
        changeSortCondition(states, options) {
          const { sortingColumn, sortProp, sortOrder } = states;
          const columnValue = vue.unref(sortingColumn), propValue = vue.unref(sortProp), orderValue = vue.unref(sortOrder);
          if (orderValue === null) {
            states.sortingColumn.value = null;
            states.sortProp.value = null;
          }
          const ignore = { filter: true };
          instance.store.execQuery(ignore);
          if (!options || !(options.silent || options.init)) {
            instance.emit("sort-change", {
              column: columnValue,
              prop: propValue,
              order: orderValue
            });
          }
          instance.store.updateTableScrollY();
        },
        filterChange(_states, options) {
          const { column, values, silent } = options;
          const newFilters = instance.store.updateFilters(column, values);
          instance.store.execQuery();
          if (!silent) {
            instance.emit("filter-change", newFilters);
          }
          instance.store.updateTableScrollY();
        },
        toggleAllSelection() {
          instance.store.toggleAllSelection();
        },
        rowSelectedChanged(_states, row) {
          instance.store.toggleRowSelection(row);
          instance.store.updateAllSelected();
        },
        setHoverRow(states, row) {
          states.hoverRow.value = row;
        },
        setCurrentRow(_states, row) {
          instance.store.updateCurrentRow(row);
        }
      };
      const commit = function(name, ...args) {
        const mutations2 = instance.store.mutations;
        if (mutations2[name]) {
          mutations2[name].apply(instance, [instance.store.states].concat(args));
        } else {
          throw new Error(`Action not found: ${name}`);
        }
      };
      const updateTableScrollY = function() {
        vue.nextTick(() => instance.layout.updateScrollY.apply(instance.layout));
      };
      return {
        ns,
        ...watcher,
        mutations,
        commit,
        updateTableScrollY
      };
    }
  
    const InitialStateMap = {
      rowKey: "rowKey",
      defaultExpandAll: "defaultExpandAll",
      selectOnIndeterminate: "selectOnIndeterminate",
      indent: "indent",
      lazy: "lazy",
      data: "data",
      ["treeProps.hasChildren"]: {
        key: "lazyColumnIdentifier",
        default: "hasChildren"
      },
      ["treeProps.children"]: {
        key: "childrenColumnName",
        default: "children"
      }
    };
    function createStore(table, props) {
      if (!table) {
        throw new Error("Table is required.");
      }
      const store = useStore();
      store.toggleAllSelection = debounce(store._toggleAllSelection, 10);
      Object.keys(InitialStateMap).forEach((key) => {
        handleValue(getArrKeysValue(props, key), key, store);
      });
      proxyTableProps(store, props);
      return store;
    }
    function proxyTableProps(store, props) {
      Object.keys(InitialStateMap).forEach((key) => {
        vue.watch(() => getArrKeysValue(props, key), (value) => {
          handleValue(value, key, store);
        });
      });
    }
    function handleValue(value, propsKey, store) {
      let newVal = value;
      let storeKey = InitialStateMap[propsKey];
      if (typeof InitialStateMap[propsKey] === "object") {
        storeKey = storeKey.key;
        newVal = newVal || InitialStateMap[propsKey].default;
      }
      store.states[storeKey].value = newVal;
    }
    function getArrKeysValue(props, keys) {
      if (keys.includes(".")) {
        const keyList = keys.split(".");
        let value = props;
        keyList.forEach((key) => {
          value = value[key];
        });
        return value;
      } else {
        return props[keys];
      }
    }
  
    class TableLayout {
      constructor(options) {
        this.observers = [];
        this.table = null;
        this.store = null;
        this.columns = [];
        this.fit = true;
        this.showHeader = true;
        this.height = vue.ref(null);
        this.scrollX = vue.ref(false);
        this.scrollY = vue.ref(false);
        this.bodyWidth = vue.ref(null);
        this.fixedWidth = vue.ref(null);
        this.rightFixedWidth = vue.ref(null);
        this.gutterWidth = 0;
        for (const name in options) {
          if (hasOwn(options, name)) {
            if (vue.isRef(this[name])) {
              this[name].value = options[name];
            } else {
              this[name] = options[name];
            }
          }
        }
        if (!this.table) {
          throw new Error("Table is required for Table Layout");
        }
        if (!this.store) {
          throw new Error("Store is required for Table Layout");
        }
      }
      updateScrollY() {
        const height = this.height.value;
        if (height === null)
          return false;
        const scrollBarRef = this.table.refs.scrollBarRef;
        if (this.table.vnode.el && scrollBarRef) {
          let scrollY = true;
          const prevScrollY = this.scrollY.value;
          scrollY = scrollBarRef.wrap$.scrollHeight > scrollBarRef.wrap$.clientHeight;
          this.scrollY.value = scrollY;
          return prevScrollY !== scrollY;
        }
        return false;
      }
      setHeight(value, prop = "height") {
        if (!isClient)
          return;
        const el = this.table.vnode.el;
        value = parseHeight(value);
        this.height.value = Number(value);
        if (!el && (value || value === 0))
          return vue.nextTick(() => this.setHeight(value, prop));
        if (typeof value === "number") {
          el.style[prop] = `${value}px`;
          this.updateElsHeight();
        } else if (typeof value === "string") {
          el.style[prop] = value;
          this.updateElsHeight();
        }
      }
      setMaxHeight(value) {
        this.setHeight(value, "max-height");
      }
      getFlattenColumns() {
        const flattenColumns = [];
        const columns = this.table.store.states.columns.value;
        columns.forEach((column) => {
          if (column.isColumnGroup) {
            flattenColumns.push.apply(flattenColumns, column.columns);
          } else {
            flattenColumns.push(column);
          }
        });
        return flattenColumns;
      }
      updateElsHeight() {
        this.updateScrollY();
        this.notifyObservers("scrollable");
      }
      headerDisplayNone(elm) {
        if (!elm)
          return true;
        let headerChild = elm;
        while (headerChild.tagName !== "DIV") {
          if (getComputedStyle(headerChild).display === "none") {
            return true;
          }
          headerChild = headerChild.parentElement;
        }
        return false;
      }
      updateColumnsWidth() {
        if (!isClient)
          return;
        const fit = this.fit;
        const bodyWidth = this.table.vnode.el.clientWidth;
        let bodyMinWidth = 0;
        const flattenColumns = this.getFlattenColumns();
        const flexColumns = flattenColumns.filter((column) => typeof column.width !== "number");
        flattenColumns.forEach((column) => {
          if (typeof column.width === "number" && column.realWidth)
            column.realWidth = null;
        });
        if (flexColumns.length > 0 && fit) {
          flattenColumns.forEach((column) => {
            bodyMinWidth += Number(column.width || column.minWidth || 80);
          });
          if (bodyMinWidth <= bodyWidth) {
            this.scrollX.value = false;
            const totalFlexWidth = bodyWidth - bodyMinWidth;
            if (flexColumns.length === 1) {
              flexColumns[0].realWidth = Number(flexColumns[0].minWidth || 80) + totalFlexWidth;
            } else {
              const allColumnsWidth = flexColumns.reduce((prev, column) => prev + Number(column.minWidth || 80), 0);
              const flexWidthPerPixel = totalFlexWidth / allColumnsWidth;
              let noneFirstWidth = 0;
              flexColumns.forEach((column, index) => {
                if (index === 0)
                  return;
                const flexWidth = Math.floor(Number(column.minWidth || 80) * flexWidthPerPixel);
                noneFirstWidth += flexWidth;
                column.realWidth = Number(column.minWidth || 80) + flexWidth;
              });
              flexColumns[0].realWidth = Number(flexColumns[0].minWidth || 80) + totalFlexWidth - noneFirstWidth;
            }
          } else {
            this.scrollX.value = true;
            flexColumns.forEach((column) => {
              column.realWidth = Number(column.minWidth);
            });
          }
          this.bodyWidth.value = Math.max(bodyMinWidth, bodyWidth);
          this.table.state.resizeState.value.width = this.bodyWidth.value;
        } else {
          flattenColumns.forEach((column) => {
            if (!column.width && !column.minWidth) {
              column.realWidth = 80;
            } else {
              column.realWidth = Number(column.width || column.minWidth);
            }
            bodyMinWidth += column.realWidth;
          });
          this.scrollX.value = bodyMinWidth > bodyWidth;
          this.bodyWidth.value = bodyMinWidth;
        }
        const fixedColumns = this.store.states.fixedColumns.value;
        if (fixedColumns.length > 0) {
          let fixedWidth = 0;
          fixedColumns.forEach((column) => {
            fixedWidth += Number(column.realWidth || column.width);
          });
          this.fixedWidth.value = fixedWidth;
        }
        const rightFixedColumns = this.store.states.rightFixedColumns.value;
        if (rightFixedColumns.length > 0) {
          let rightFixedWidth = 0;
          rightFixedColumns.forEach((column) => {
            rightFixedWidth += Number(column.realWidth || column.width);
          });
          this.rightFixedWidth.value = rightFixedWidth;
        }
        this.notifyObservers("columns");
      }
      addObserver(observer) {
        this.observers.push(observer);
      }
      removeObserver(observer) {
        const index = this.observers.indexOf(observer);
        if (index !== -1) {
          this.observers.splice(index, 1);
        }
      }
      notifyObservers(event) {
        const observers = this.observers;
        observers.forEach((observer) => {
          var _a, _b;
          switch (event) {
            case "columns":
              (_a = observer.state) == null ? void 0 : _a.onColumnsChange(this);
              break;
            case "scrollable":
              (_b = observer.state) == null ? void 0 : _b.onScrollableChange(this);
              break;
            default:
              throw new Error(`Table Layout don't have event ${event}.`);
          }
        });
      }
    }
    var TableLayout$1 = TableLayout;
  
    const { CheckboxGroup: ElCheckboxGroup } = ElCheckbox;
    const _sfc_main$q = vue.defineComponent({
      name: "ElTableFilterPanel",
      components: {
        ElCheckbox,
        ElCheckboxGroup,
        ElScrollbar,
        ElTooltip,
        ElIcon,
        ArrowDown: arrow_down_default,
        ArrowUp: arrow_up_default
      },
      directives: { ClickOutside },
      props: {
        placement: {
          type: String,
          default: "bottom-start"
        },
        store: {
          type: Object
        },
        column: {
          type: Object
        },
        upDataColumn: {
          type: Function
        }
      },
      setup(props) {
        const instance = vue.getCurrentInstance();
        const { t } = useLocale();
        const ns = useNamespace("table-filter");
        const parent = instance == null ? void 0 : instance.parent;
        if (!parent.filterPanels.value[props.column.id]) {
          parent.filterPanels.value[props.column.id] = instance;
        }
        const tooltipVisible = vue.ref(false);
        const tooltip = vue.ref(null);
        const filters = vue.computed(() => {
          return props.column && props.column.filters;
        });
        const filterValue = vue.computed({
          get: () => {
            var _a;
            return (((_a = props.column) == null ? void 0 : _a.filteredValue) || [])[0];
          },
          set: (value) => {
            if (filteredValue.value) {
              if (typeof value !== "undefined" && value !== null) {
                filteredValue.value.splice(0, 1, value);
              } else {
                filteredValue.value.splice(0, 1);
              }
            }
          }
        });
        const filteredValue = vue.computed({
          get() {
            if (props.column) {
              return props.column.filteredValue || [];
            }
            return [];
          },
          set(value) {
            if (props.column) {
              props.upDataColumn("filteredValue", value);
            }
          }
        });
        const multiple = vue.computed(() => {
          if (props.column) {
            return props.column.filterMultiple;
          }
          return true;
        });
        const isActive = (filter) => {
          return filter.value === filterValue.value;
        };
        const hidden = () => {
          tooltipVisible.value = false;
        };
        const showFilterPanel = (e) => {
          e.stopPropagation();
          tooltipVisible.value = !tooltipVisible.value;
        };
        const hideFilterPanel = () => {
          tooltipVisible.value = false;
        };
        const handleConfirm = () => {
          confirmFilter(filteredValue.value);
          hidden();
        };
        const handleReset = () => {
          filteredValue.value = [];
          confirmFilter(filteredValue.value);
          hidden();
        };
        const handleSelect = (_filterValue) => {
          filterValue.value = _filterValue;
          if (typeof _filterValue !== "undefined" && _filterValue !== null) {
            confirmFilter(filteredValue.value);
          } else {
            confirmFilter([]);
          }
          hidden();
        };
        const confirmFilter = (filteredValue2) => {
          props.store.commit("filterChange", {
            column: props.column,
            values: filteredValue2
          });
          props.store.updateAllSelected();
        };
        vue.watch(tooltipVisible, (value) => {
          if (props.column) {
            props.upDataColumn("filterOpened", value);
          }
        }, {
          immediate: true
        });
        const popperPaneRef = vue.computed(() => {
          var _a, _b;
          return (_b = (_a = tooltip.value) == null ? void 0 : _a.popperRef) == null ? void 0 : _b.contentRef;
        });
        return {
          tooltipVisible,
          multiple,
          filteredValue,
          filterValue,
          filters,
          handleConfirm,
          handleReset,
          handleSelect,
          isActive,
          t,
          ns,
          showFilterPanel,
          hideFilterPanel,
          popperPaneRef,
          tooltip
        };
      }
    });
    const _hoisted_1$c = { key: 0 };
    const _hoisted_2$8 = ["disabled"];
    const _hoisted_3$3 = ["label", "onClick"];
    function _sfc_render$4(_ctx, _cache, $props, $setup, $data, $options) {
      const _component_el_checkbox = vue.resolveComponent("el-checkbox");
      const _component_el_checkbox_group = vue.resolveComponent("el-checkbox-group");
      const _component_el_scrollbar = vue.resolveComponent("el-scrollbar");
      const _component_arrow_up = vue.resolveComponent("arrow-up");
      const _component_arrow_down = vue.resolveComponent("arrow-down");
      const _component_el_icon = vue.resolveComponent("el-icon");
      const _component_el_tooltip = vue.resolveComponent("el-tooltip");
      const _directive_click_outside = vue.resolveDirective("click-outside");
      return vue.openBlock(), vue.createBlock(_component_el_tooltip, {
        ref: "tooltip",
        visible: _ctx.tooltipVisible,
        offset: 0,
        placement: _ctx.placement,
        "show-arrow": false,
        "stop-popper-mouse-event": false,
        teleported: "",
        effect: "light",
        pure: "",
        "popper-class": _ctx.ns.b(),
        persistent: ""
      }, {
        content: vue.withCtx(() => [
          _ctx.multiple ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_1$c, [
            vue.createElementVNode("div", {
              class: vue.normalizeClass(_ctx.ns.e("content"))
            }, [
              vue.createVNode(_component_el_scrollbar, {
                "wrap-class": _ctx.ns.e("wrap")
              }, {
                default: vue.withCtx(() => [
                  vue.createVNode(_component_el_checkbox_group, {
                    modelValue: _ctx.filteredValue,
                    "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => _ctx.filteredValue = $event),
                    class: vue.normalizeClass(_ctx.ns.e("checkbox-group"))
                  }, {
                    default: vue.withCtx(() => [
                      (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(_ctx.filters, (filter) => {
                        return vue.openBlock(), vue.createBlock(_component_el_checkbox, {
                          key: filter.value,
                          label: filter.value
                        }, {
                          default: vue.withCtx(() => [
                            vue.createTextVNode(vue.toDisplayString(filter.text), 1)
                          ]),
                          _: 2
                        }, 1032, ["label"]);
                      }), 128))
                    ]),
                    _: 1
                  }, 8, ["modelValue", "class"])
                ]),
                _: 1
              }, 8, ["wrap-class"])
            ], 2),
            vue.createElementVNode("div", {
              class: vue.normalizeClass(_ctx.ns.e("bottom"))
            }, [
              vue.createElementVNode("button", {
                class: vue.normalizeClass({ [_ctx.ns.is("disabled")]: _ctx.filteredValue.length === 0 }),
                disabled: _ctx.filteredValue.length === 0,
                type: "button",
                onClick: _cache[1] || (_cache[1] = (...args) => _ctx.handleConfirm && _ctx.handleConfirm(...args))
              }, vue.toDisplayString(_ctx.t("el.table.confirmFilter")), 11, _hoisted_2$8),
              vue.createElementVNode("button", {
                type: "button",
                onClick: _cache[2] || (_cache[2] = (...args) => _ctx.handleReset && _ctx.handleReset(...args))
              }, vue.toDisplayString(_ctx.t("el.table.resetFilter")), 1)
            ], 2)
          ])) : (vue.openBlock(), vue.createElementBlock("ul", {
            key: 1,
            class: vue.normalizeClass(_ctx.ns.e("list"))
          }, [
            vue.createElementVNode("li", {
              class: vue.normalizeClass([
                _ctx.ns.e("list-item"),
                {
                  [_ctx.ns.is("active")]: _ctx.filterValue === void 0 || _ctx.filterValue === null
                }
              ]),
              onClick: _cache[3] || (_cache[3] = ($event) => _ctx.handleSelect(null))
            }, vue.toDisplayString(_ctx.t("el.table.clearFilter")), 3),
            (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(_ctx.filters, (filter) => {
              return vue.openBlock(), vue.createElementBlock("li", {
                key: filter.value,
                class: vue.normalizeClass([_ctx.ns.e("list-item"), _ctx.ns.is("active", _ctx.isActive(filter))]),
                label: filter.value,
                onClick: ($event) => _ctx.handleSelect(filter.value)
              }, vue.toDisplayString(filter.text), 11, _hoisted_3$3);
            }), 128))
          ], 2))
        ]),
        default: vue.withCtx(() => [
          vue.withDirectives((vue.openBlock(), vue.createElementBlock("span", {
            class: vue.normalizeClass([
              `${_ctx.ns.namespace.value}-table__column-filter-trigger`,
              `${_ctx.ns.namespace.value}-none-outline`
            ]),
            onClick: _cache[4] || (_cache[4] = (...args) => _ctx.showFilterPanel && _ctx.showFilterPanel(...args))
          }, [
            vue.createVNode(_component_el_icon, null, {
              default: vue.withCtx(() => [
                _ctx.column.filterOpened ? (vue.openBlock(), vue.createBlock(_component_arrow_up, { key: 0 })) : (vue.openBlock(), vue.createBlock(_component_arrow_down, { key: 1 }))
              ]),
              _: 1
            })
          ], 2)), [
            [_directive_click_outside, _ctx.hideFilterPanel, _ctx.popperPaneRef]
          ])
        ]),
        _: 1
      }, 8, ["visible", "placement", "popper-class"]);
    }
    var FilterPanel = /* @__PURE__ */ _export_sfc(_sfc_main$q, [["render", _sfc_render$4], ["__file", "filter-panel.vue"]]);
  
    function useLayoutObserver(root) {
      const instance = vue.getCurrentInstance();
      vue.onBeforeMount(() => {
        tableLayout.value.addObserver(instance);
      });
      vue.onMounted(() => {
        onColumnsChange(tableLayout.value);
        onScrollableChange(tableLayout.value);
      });
      vue.onUpdated(() => {
        onColumnsChange(tableLayout.value);
        onScrollableChange(tableLayout.value);
      });
      vue.onUnmounted(() => {
        tableLayout.value.removeObserver(instance);
      });
      const tableLayout = vue.computed(() => {
        const layout = root.layout;
        if (!layout) {
          throw new Error("Can not find table layout.");
        }
        return layout;
      });
      const onColumnsChange = (layout) => {
        var _a;
        const cols = ((_a = root.vnode.el) == null ? void 0 : _a.querySelectorAll("colgroup > col")) || [];
        if (!cols.length)
          return;
        const flattenColumns = layout.getFlattenColumns();
        const columnsMap = {};
        flattenColumns.forEach((column) => {
          columnsMap[column.id] = column;
        });
        for (let i = 0, j = cols.length; i < j; i++) {
          const col = cols[i];
          const name = col.getAttribute("name");
          const column = columnsMap[name];
          if (column) {
            col.setAttribute("width", column.realWidth || column.width);
          }
        }
      };
      const onScrollableChange = (layout) => {
        var _a, _b;
        const cols = ((_a = root.vnode.el) == null ? void 0 : _a.querySelectorAll("colgroup > col[name=gutter]")) || [];
        for (let i = 0, j = cols.length; i < j; i++) {
          const col = cols[i];
          col.setAttribute("width", layout.scrollY.value ? layout.gutterWidth : "0");
        }
        const ths = ((_b = root.vnode.el) == null ? void 0 : _b.querySelectorAll("th.gutter")) || [];
        for (let i = 0, j = ths.length; i < j; i++) {
          const th = ths[i];
          th.style.width = layout.scrollY.value ? `${layout.gutterWidth}px` : "0";
          th.style.display = layout.scrollY.value ? "" : "none";
        }
      };
      return {
        tableLayout: tableLayout.value,
        onColumnsChange,
        onScrollableChange
      };
    }
  
    const TABLE_INJECTION_KEY = Symbol("ElTable");
  
    function useEvent(props, emit) {
      const instance = vue.getCurrentInstance();
      const parent = vue.inject(TABLE_INJECTION_KEY);
      const handleFilterClick = (event) => {
        event.stopPropagation();
        return;
      };
      const handleHeaderClick = (event, column) => {
        if (!column.filters && column.sortable) {
          handleSortClick(event, column, false);
        } else if (column.filterable && !column.sortable) {
          handleFilterClick(event);
        }
        parent == null ? void 0 : parent.emit("header-click", column, event);
      };
      const handleHeaderContextMenu = (event, column) => {
        parent == null ? void 0 : parent.emit("header-contextmenu", column, event);
      };
      const draggingColumn = vue.ref(null);
      const dragging = vue.ref(false);
      const dragState = vue.ref({});
      const handleMouseDown = (event, column) => {
        if (!isClient)
          return;
        if (column.children && column.children.length > 0)
          return;
        if (draggingColumn.value && props.border) {
          dragging.value = true;
          const table = parent;
          emit("set-drag-visible", true);
          const tableEl = table == null ? void 0 : table.vnode.el;
          const tableLeft = tableEl.getBoundingClientRect().left;
          const columnEl = instance.vnode.el.querySelector(`th.${column.id}`);
          const columnRect = columnEl.getBoundingClientRect();
          const minLeft = columnRect.left - tableLeft + 30;
          addClass(columnEl, "noclick");
          dragState.value = {
            startMouseLeft: event.clientX,
            startLeft: columnRect.right - tableLeft,
            startColumnLeft: columnRect.left - tableLeft,
            tableLeft
          };
          const resizeProxy = table == null ? void 0 : table.refs.resizeProxy;
          resizeProxy.style.left = `${dragState.value.startLeft}px`;
          document.onselectstart = function() {
            return false;
          };
          document.ondragstart = function() {
            return false;
          };
          const handleMouseMove2 = (event2) => {
            const deltaLeft = event2.clientX - dragState.value.startMouseLeft;
            const proxyLeft = dragState.value.startLeft + deltaLeft;
            resizeProxy.style.left = `${Math.max(minLeft, proxyLeft)}px`;
          };
          const handleMouseUp = () => {
            if (dragging.value) {
              const { startColumnLeft, startLeft } = dragState.value;
              const finalLeft = Number.parseInt(resizeProxy.style.left, 10);
              const columnWidth = finalLeft - startColumnLeft;
              column.width = column.realWidth = columnWidth;
              table == null ? void 0 : table.emit("header-dragend", column.width, startLeft - startColumnLeft, column, event);
              requestAnimationFrame(() => {
                props.store.scheduleLayout(false, true);
              });
              document.body.style.cursor = "";
              dragging.value = false;
              draggingColumn.value = null;
              dragState.value = {};
              emit("set-drag-visible", false);
            }
            document.removeEventListener("mousemove", handleMouseMove2);
            document.removeEventListener("mouseup", handleMouseUp);
            document.onselectstart = null;
            document.ondragstart = null;
            setTimeout(() => {
              removeClass(columnEl, "noclick");
            }, 0);
          };
          document.addEventListener("mousemove", handleMouseMove2);
          document.addEventListener("mouseup", handleMouseUp);
        }
      };
      const handleMouseMove = (event, column) => {
        var _a;
        if (column.children && column.children.length > 0)
          return;
        const target = (_a = event.target) == null ? void 0 : _a.closest("th");
        if (!column || !column.resizable)
          return;
        if (!dragging.value && props.border) {
          const rect = target.getBoundingClientRect();
          const bodyStyle = document.body.style;
          if (rect.width > 12 && rect.right - event.pageX < 8) {
            bodyStyle.cursor = "col-resize";
            if (hasClass(target, "is-sortable")) {
              target.style.cursor = "col-resize";
            }
            draggingColumn.value = column;
          } else if (!dragging.value) {
            bodyStyle.cursor = "";
            if (hasClass(target, "is-sortable")) {
              target.style.cursor = "pointer";
            }
            draggingColumn.value = null;
          }
        }
      };
      const handleMouseOut = () => {
        if (!isClient)
          return;
        document.body.style.cursor = "";
      };
      const toggleOrder = ({ order, sortOrders }) => {
        if (order === "")
          return sortOrders[0];
        const index = sortOrders.indexOf(order || null);
        return sortOrders[index > sortOrders.length - 2 ? 0 : index + 1];
      };
      const handleSortClick = (event, column, givenOrder) => {
        var _a;
        event.stopPropagation();
        const order = column.order === givenOrder ? null : givenOrder || toggleOrder(column);
        const target = (_a = event.target) == null ? void 0 : _a.closest("th");
        if (target) {
          if (hasClass(target, "noclick")) {
            removeClass(target, "noclick");
            return;
          }
        }
        if (!column.sortable)
          return;
        const states = props.store.states;
        let sortProp = states.sortProp.value;
        let sortOrder;
        const sortingColumn = states.sortingColumn.value;
        if (sortingColumn !== column || sortingColumn === column && sortingColumn.order === null) {
          if (sortingColumn) {
            sortingColumn.order = null;
          }
          states.sortingColumn.value = column;
          sortProp = column.property;
        }
        if (!order) {
          sortOrder = column.order = null;
        } else {
          sortOrder = column.order = order;
        }
        states.sortProp.value = sortProp;
        states.sortOrder.value = sortOrder;
        parent == null ? void 0 : parent.store.commit("changeSortCondition");
      };
      return {
        handleHeaderClick,
        handleHeaderContextMenu,
        handleMouseDown,
        handleMouseMove,
        handleMouseOut,
        handleSortClick,
        handleFilterClick
      };
    }
  
    function useStyle$2(props) {
      const parent = vue.inject(TABLE_INJECTION_KEY);
      const ns = useNamespace("table");
      const getHeaderRowStyle = (rowIndex) => {
        const headerRowStyle = parent == null ? void 0 : parent.props.headerRowStyle;
        if (typeof headerRowStyle === "function") {
          return headerRowStyle.call(null, { rowIndex });
        }
        return headerRowStyle;
      };
      const getHeaderRowClass = (rowIndex) => {
        const classes = [];
        const headerRowClassName = parent == null ? void 0 : parent.props.headerRowClassName;
        if (typeof headerRowClassName === "string") {
          classes.push(headerRowClassName);
        } else if (typeof headerRowClassName === "function") {
          classes.push(headerRowClassName.call(null, { rowIndex }));
        }
        return classes.join(" ");
      };
      const getHeaderCellStyle = (rowIndex, columnIndex, row, column) => {
        var _a;
        let headerCellStyles = (_a = parent == null ? void 0 : parent.props.headerCellStyle) != null ? _a : {};
        if (typeof headerCellStyles === "function") {
          headerCellStyles = headerCellStyles.call(null, {
            rowIndex,
            columnIndex,
            row,
            column
          });
        }
        const fixedStyle = getFixedColumnOffset(columnIndex, column.fixed, props.store, row);
        ensurePosition(fixedStyle, "left");
        ensurePosition(fixedStyle, "right");
        return Object.assign({}, headerCellStyles, fixedStyle);
      };
      const getHeaderCellClass = (rowIndex, columnIndex, row, column) => {
        const fixedClasses = getFixedColumnsClass(ns.b(), columnIndex, column.fixed, props.store, row);
        const classes = [
          column.id,
          column.order,
          column.headerAlign,
          column.className,
          column.labelClassName,
          ...fixedClasses
        ];
        if (!column.children) {
          classes.push("is-leaf");
        }
        if (column.sortable) {
          classes.push("is-sortable");
        }
        const headerCellClassName = parent == null ? void 0 : parent.props.headerCellClassName;
        if (typeof headerCellClassName === "string") {
          classes.push(headerCellClassName);
        } else if (typeof headerCellClassName === "function") {
          classes.push(headerCellClassName.call(null, {
            rowIndex,
            columnIndex,
            row,
            column
          }));
        }
        classes.push(ns.e("cell"));
        return classes.filter((className) => Boolean(className)).join(" ");
      };
      return {
        getHeaderRowStyle,
        getHeaderRowClass,
        getHeaderCellStyle,
        getHeaderCellClass
      };
    }
  
    const getAllColumns = (columns) => {
      const result = [];
      columns.forEach((column) => {
        if (column.children) {
          result.push(column);
          result.push.apply(result, getAllColumns(column.children));
        } else {
          result.push(column);
        }
      });
      return result;
    };
    const convertToRows = (originColumns) => {
      let maxLevel = 1;
      const traverse = (column, parent) => {
        if (parent) {
          column.level = parent.level + 1;
          if (maxLevel < column.level) {
            maxLevel = column.level;
          }
        }
        if (column.children) {
          let colSpan = 0;
          column.children.forEach((subColumn) => {
            traverse(subColumn, column);
            colSpan += subColumn.colSpan;
          });
          column.colSpan = colSpan;
        } else {
          column.colSpan = 1;
        }
      };
      originColumns.forEach((column) => {
        column.level = 1;
        traverse(column, void 0);
      });
      const rows = [];
      for (let i = 0; i < maxLevel; i++) {
        rows.push([]);
      }
      const allColumns = getAllColumns(originColumns);
      allColumns.forEach((column) => {
        if (!column.children) {
          column.rowSpan = maxLevel - column.level + 1;
        } else {
          column.rowSpan = 1;
          column.children.forEach((col) => col.isSubColumn = true);
        }
        rows[column.level - 1].push(column);
      });
      return rows;
    };
    function useUtils$1(props) {
      const parent = vue.inject(TABLE_INJECTION_KEY);
      const columnRows = vue.computed(() => {
        return convertToRows(props.store.states.originColumns.value);
      });
      const isGroup = vue.computed(() => {
        const result = columnRows.value.length > 1;
        if (result && parent) {
          parent.state.isGroup.value = true;
        }
        return result;
      });
      const toggleAllSelection = (event) => {
        event.stopPropagation();
        parent == null ? void 0 : parent.store.commit("toggleAllSelection");
      };
      return {
        isGroup,
        toggleAllSelection,
        columnRows
      };
    }
  
    var TableHeader = vue.defineComponent({
      name: "ElTableHeader",
      components: {
        ElCheckbox
      },
      props: {
        fixed: {
          type: String,
          default: ""
        },
        store: {
          required: true,
          type: Object
        },
        border: Boolean,
        defaultSort: {
          type: Object,
          default: () => {
            return {
              prop: "",
              order: ""
            };
          }
        }
      },
      setup(props, { emit }) {
        const instance = vue.getCurrentInstance();
        const parent = vue.inject(TABLE_INJECTION_KEY);
        const ns = useNamespace("table");
        const filterPanels = vue.ref({});
        const { onColumnsChange, onScrollableChange } = useLayoutObserver(parent);
        vue.onMounted(async () => {
          await vue.nextTick();
          await vue.nextTick();
          const { prop, order } = props.defaultSort;
          parent == null ? void 0 : parent.store.commit("sort", { prop, order, init: true });
        });
        const {
          handleHeaderClick,
          handleHeaderContextMenu,
          handleMouseDown,
          handleMouseMove,
          handleMouseOut,
          handleSortClick,
          handleFilterClick
        } = useEvent(props, emit);
        const {
          getHeaderRowStyle,
          getHeaderRowClass,
          getHeaderCellStyle,
          getHeaderCellClass
        } = useStyle$2(props);
        const { isGroup, toggleAllSelection, columnRows } = useUtils$1(props);
        instance.state = {
          onColumnsChange,
          onScrollableChange
        };
        instance.filterPanels = filterPanels;
        return {
          ns,
          filterPanels,
          onColumnsChange,
          onScrollableChange,
          columnRows,
          getHeaderRowClass,
          getHeaderRowStyle,
          getHeaderCellClass,
          getHeaderCellStyle,
          handleHeaderClick,
          handleHeaderContextMenu,
          handleMouseDown,
          handleMouseMove,
          handleMouseOut,
          handleSortClick,
          handleFilterClick,
          isGroup,
          toggleAllSelection
        };
      },
      render() {
        const {
          ns,
          isGroup,
          columnRows,
          getHeaderCellStyle,
          getHeaderCellClass,
          getHeaderRowClass,
          getHeaderRowStyle,
          handleHeaderClick,
          handleHeaderContextMenu,
          handleMouseDown,
          handleMouseMove,
          handleSortClick,
          handleMouseOut,
          store,
          $parent
        } = this;
        let rowSpan = 1;
        return vue.h("thead", {
          class: { [ns.is("group")]: isGroup }
        }, columnRows.map((subColumns, rowIndex) => vue.h("tr", {
          class: getHeaderRowClass(rowIndex),
          key: rowIndex,
          style: getHeaderRowStyle(rowIndex)
        }, subColumns.map((column, cellIndex) => {
          if (column.rowSpan > rowSpan) {
            rowSpan = column.rowSpan;
          }
          return vue.h("th", {
            class: getHeaderCellClass(rowIndex, cellIndex, subColumns, column),
            colspan: column.colSpan,
            key: `${column.id}-thead`,
            rowspan: column.rowSpan,
            style: getHeaderCellStyle(rowIndex, cellIndex, subColumns, column),
            onClick: ($event) => handleHeaderClick($event, column),
            onContextmenu: ($event) => handleHeaderContextMenu($event, column),
            onMousedown: ($event) => handleMouseDown($event, column),
            onMousemove: ($event) => handleMouseMove($event, column),
            onMouseout: handleMouseOut
          }, [
            vue.h("div", {
              class: [
                "cell",
                column.filteredValue && column.filteredValue.length > 0 ? "highlight" : ""
              ]
            }, [
              column.renderHeader ? column.renderHeader({
                column,
                $index: cellIndex,
                store,
                _self: $parent
              }) : column.label,
              column.sortable && vue.h("span", {
                onClick: ($event) => handleSortClick($event, column),
                class: "caret-wrapper"
              }, [
                vue.h("i", {
                  onClick: ($event) => handleSortClick($event, column, "ascending"),
                  class: "sort-caret ascending"
                }),
                vue.h("i", {
                  onClick: ($event) => handleSortClick($event, column, "descending"),
                  class: "sort-caret descending"
                })
              ]),
              column.filterable && vue.h(FilterPanel, {
                store,
                placement: column.filterPlacement || "bottom-start",
                column,
                upDataColumn: (key, value) => {
                  column[key] = value;
                }
              })
            ])
          ]);
        }))));
      }
    });
  
    function useEvents(props) {
      const parent = vue.inject(TABLE_INJECTION_KEY);
      const tooltipContent = vue.ref("");
      const tooltipTrigger = vue.ref(vue.h("div"));
      const handleEvent = (event, row, name) => {
        var _a;
        const table = parent;
        const cell = getCell(event);
        let column;
        const namespace = (_a = table == null ? void 0 : table.vnode.el) == null ? void 0 : _a.dataset.prefix;
        if (cell) {
          column = getColumnByCell({
            columns: props.store.states.columns.value
          }, cell, namespace);
          if (column) {
            table == null ? void 0 : table.emit(`cell-${name}`, row, column, cell, event);
          }
        }
        table == null ? void 0 : table.emit(`row-${name}`, row, column, event);
      };
      const handleDoubleClick = (event, row) => {
        handleEvent(event, row, "dblclick");
      };
      const handleClick = (event, row) => {
        props.store.commit("setCurrentRow", row);
        handleEvent(event, row, "click");
      };
      const handleContextMenu = (event, row) => {
        handleEvent(event, row, "contextmenu");
      };
      const handleMouseEnter = debounce((index) => {
        props.store.commit("setHoverRow", index);
      }, 30);
      const handleMouseLeave = debounce(() => {
        props.store.commit("setHoverRow", null);
      }, 30);
      const handleCellMouseEnter = (event, row, tooltipEffect) => {
        var _a;
        const table = parent;
        const cell = getCell(event);
        const namespace = (_a = table == null ? void 0 : table.vnode.el) == null ? void 0 : _a.dataset.prefix;
        if (cell) {
          const column = getColumnByCell({
            columns: props.store.states.columns.value
          }, cell, namespace);
          const hoverState = table.hoverState = { cell, column, row };
          table == null ? void 0 : table.emit("cell-mouse-enter", hoverState.row, hoverState.column, hoverState.cell, event);
        }
        const cellChild = event.target.querySelector(".cell");
        if (!(hasClass(cellChild, `${namespace}-tooltip`) && cellChild.childNodes.length)) {
          return;
        }
        const range = document.createRange();
        range.setStart(cellChild, 0);
        range.setEnd(cellChild, cellChild.childNodes.length);
        const rangeWidth = range.getBoundingClientRect().width;
        const padding = (Number.parseInt(getStyle(cellChild, "paddingLeft"), 10) || 0) + (Number.parseInt(getStyle(cellChild, "paddingRight"), 10) || 0);
        if (rangeWidth + padding > cellChild.offsetWidth || cellChild.scrollWidth > cellChild.offsetWidth) {
          createTablePopper(parent == null ? void 0 : parent.refs.tableWrapper, cell, cell.innerText || cell.textContent, {
            placement: "top",
            strategy: "fixed"
          }, tooltipEffect);
        }
      };
      const handleCellMouseLeave = (event) => {
        const cell = getCell(event);
        if (!cell)
          return;
        const oldHoverState = parent == null ? void 0 : parent.hoverState;
        parent == null ? void 0 : parent.emit("cell-mouse-leave", oldHoverState == null ? void 0 : oldHoverState.row, oldHoverState == null ? void 0 : oldHoverState.column, oldHoverState == null ? void 0 : oldHoverState.cell, event);
      };
      return {
        handleDoubleClick,
        handleClick,
        handleContextMenu,
        handleMouseEnter,
        handleMouseLeave,
        handleCellMouseEnter,
        handleCellMouseLeave,
        tooltipContent,
        tooltipTrigger
      };
    }
  
    function useStyles$1(props) {
      const parent = vue.inject(TABLE_INJECTION_KEY);
      const ns = useNamespace("table");
      const getRowStyle = (row, rowIndex) => {
        const rowStyle = parent == null ? void 0 : parent.props.rowStyle;
        if (typeof rowStyle === "function") {
          return rowStyle.call(null, {
            row,
            rowIndex
          });
        }
        return rowStyle || null;
      };
      const getRowClass = (row, rowIndex) => {
        const classes = [ns.e("row")];
        if ((parent == null ? void 0 : parent.props.highlightCurrentRow) && row === props.store.states.currentRow.value) {
          classes.push("current-row");
        }
        if (props.stripe && rowIndex % 2 === 1) {
          classes.push(ns.em("row", "striped"));
        }
        const rowClassName = parent == null ? void 0 : parent.props.rowClassName;
        if (typeof rowClassName === "string") {
          classes.push(rowClassName);
        } else if (typeof rowClassName === "function") {
          classes.push(rowClassName.call(null, {
            row,
            rowIndex
          }));
        }
        return classes;
      };
      const getCellStyle = (rowIndex, columnIndex, row, column) => {
        const cellStyle = parent == null ? void 0 : parent.props.cellStyle;
        let cellStyles = cellStyle != null ? cellStyle : {};
        if (typeof cellStyle === "function") {
          cellStyles = cellStyle.call(null, {
            rowIndex,
            columnIndex,
            row,
            column
          });
        }
        const fixedStyle = getFixedColumnOffset(columnIndex, props == null ? void 0 : props.fixed, props.store);
        ensurePosition(fixedStyle, "left");
        ensurePosition(fixedStyle, "right");
        return Object.assign({}, cellStyles, fixedStyle);
      };
      const getCellClass = (rowIndex, columnIndex, row, column, offset) => {
        const fixedClasses = getFixedColumnsClass(ns.b(), columnIndex, props == null ? void 0 : props.fixed, props.store, void 0, offset);
        const classes = [column.id, column.align, column.className, ...fixedClasses];
        const cellClassName = parent == null ? void 0 : parent.props.cellClassName;
        if (typeof cellClassName === "string") {
          classes.push(cellClassName);
        } else if (typeof cellClassName === "function") {
          classes.push(cellClassName.call(null, {
            rowIndex,
            columnIndex,
            row,
            column
          }));
        }
        classes.push(ns.e("cell"));
        return classes.filter((className) => Boolean(className)).join(" ");
      };
      const getSpan = (row, column, rowIndex, columnIndex) => {
        let rowspan = 1;
        let colspan = 1;
        const fn = parent == null ? void 0 : parent.props.spanMethod;
        if (typeof fn === "function") {
          const result = fn({
            row,
            column,
            rowIndex,
            columnIndex
          });
          if (Array.isArray(result)) {
            rowspan = result[0];
            colspan = result[1];
          } else if (typeof result === "object") {
            rowspan = result.rowspan;
            colspan = result.colspan;
          }
        }
        return { rowspan, colspan };
      };
      const getColspanRealWidth = (columns, colspan, index) => {
        if (colspan < 1) {
          return columns[index].realWidth;
        }
        const widthArr = columns.map(({ realWidth, width }) => realWidth || width).slice(index, index + colspan);
        return Number(widthArr.reduce((acc, width) => Number(acc) + Number(width), -1));
      };
      return {
        getRowStyle,
        getRowClass,
        getCellStyle,
        getCellClass,
        getSpan,
        getColspanRealWidth
      };
    }
  
    function useRender$1(props) {
      const parent = vue.inject(TABLE_INJECTION_KEY);
      const ns = useNamespace("table");
      const {
        handleDoubleClick,
        handleClick,
        handleContextMenu,
        handleMouseEnter,
        handleMouseLeave,
        handleCellMouseEnter,
        handleCellMouseLeave,
        tooltipContent,
        tooltipTrigger
      } = useEvents(props);
      const {
        getRowStyle,
        getRowClass,
        getCellStyle,
        getCellClass,
        getSpan,
        getColspanRealWidth
      } = useStyles$1(props);
      const firstDefaultColumnIndex = vue.computed(() => {
        return props.store.states.columns.value.findIndex(({ type }) => type === "default");
      });
      const getKeyOfRow = (row, index) => {
        const rowKey = parent.props.rowKey;
        if (rowKey) {
          return getRowIdentity(row, rowKey);
        }
        return index;
      };
      const rowRender = (row, $index, treeRowData, expanded = false) => {
        const { tooltipEffect, store } = props;
        const { indent, columns } = store.states;
        const rowClasses = getRowClass(row, $index);
        let display = true;
        if (treeRowData) {
          rowClasses.push(ns.em("row", `level-${treeRowData.level}`));
          display = treeRowData.display;
        }
        const displayStyle = display ? null : {
          display: "none"
        };
        return vue.h("tr", {
          style: [displayStyle, getRowStyle(row, $index)],
          class: rowClasses,
          key: getKeyOfRow(row, $index),
          onDblclick: ($event) => handleDoubleClick($event, row),
          onClick: ($event) => handleClick($event, row),
          onContextmenu: ($event) => handleContextMenu($event, row),
          onMouseenter: () => handleMouseEnter($index),
          onMouseleave: handleMouseLeave
        }, columns.value.map((column, cellIndex) => {
          const { rowspan, colspan } = getSpan(row, column, $index, cellIndex);
          if (!rowspan || !colspan) {
            return null;
          }
          const columnData = { ...column };
          columnData.realWidth = getColspanRealWidth(columns.value, colspan, cellIndex);
          const data = {
            store: props.store,
            _self: props.context || parent,
            column: columnData,
            row,
            $index,
            cellIndex,
            expanded
          };
          if (cellIndex === firstDefaultColumnIndex.value && treeRowData) {
            data.treeNode = {
              indent: treeRowData.level * indent.value,
              level: treeRowData.level
            };
            if (typeof treeRowData.expanded === "boolean") {
              data.treeNode.expanded = treeRowData.expanded;
              if ("loading" in treeRowData) {
                data.treeNode.loading = treeRowData.loading;
              }
              if ("noLazyChildren" in treeRowData) {
                data.treeNode.noLazyChildren = treeRowData.noLazyChildren;
              }
            }
          }
          const baseKey = `${$index},${cellIndex}`;
          const patchKey = columnData.columnKey || columnData.rawColumnKey || "";
          const tdChildren = cellChildren(cellIndex, column, data);
          return vue.h("td", {
            style: getCellStyle($index, cellIndex, row, column),
            class: getCellClass($index, cellIndex, row, column, colspan - 1),
            key: `${patchKey}${baseKey}`,
            rowspan,
            colspan,
            onMouseenter: ($event) => handleCellMouseEnter($event, row, tooltipEffect),
            onMouseleave: handleCellMouseLeave
          }, [tdChildren]);
        }));
      };
      const cellChildren = (cellIndex, column, data) => {
        return column.renderCell(data);
      };
      const wrappedRowRender = (row, $index) => {
        const store = props.store;
        const { isRowExpanded, assertRowKey } = store;
        const { treeData, lazyTreeNodeMap, childrenColumnName, rowKey } = store.states;
        const columns = store.states.columns.value;
        const hasExpandColumn = columns.some(({ type }) => type === "expand");
        if (hasExpandColumn) {
          const expanded = isRowExpanded(row);
          const tr = rowRender(row, $index, void 0, expanded);
          const renderExpanded = parent.renderExpanded;
          if (expanded) {
            if (!renderExpanded) {
              console.error("[Element Error]renderExpanded is required.");
              return tr;
            }
            return [
              [
                tr,
                vue.h("tr", {
                  key: `expanded-row__${tr.key}`
                }, [
                  vue.h("td", {
                    colspan: columns.length,
                    class: `${ns.e("cell")} ${ns.e("expanded-cell")}`
                  }, [renderExpanded({ row, $index, store, expanded })])
                ])
              ]
            ];
          } else {
            return [[tr]];
          }
        } else if (Object.keys(treeData.value).length) {
          assertRowKey();
          const key = getRowIdentity(row, rowKey.value);
          let cur = treeData.value[key];
          let treeRowData = null;
          if (cur) {
            treeRowData = {
              expanded: cur.expanded,
              level: cur.level,
              display: true
            };
            if (typeof cur.lazy === "boolean") {
              if (typeof cur.loaded === "boolean" && cur.loaded) {
                treeRowData.noLazyChildren = !(cur.children && cur.children.length);
              }
              treeRowData.loading = cur.loading;
            }
          }
          const tmp = [rowRender(row, $index, treeRowData)];
          if (cur) {
            let i = 0;
            const traverse = (children, parent2) => {
              if (!(children && children.length && parent2))
                return;
              children.forEach((node) => {
                const innerTreeRowData = {
                  display: parent2.display && parent2.expanded,
                  level: parent2.level + 1,
                  expanded: false,
                  noLazyChildren: false,
                  loading: false
                };
                const childKey = getRowIdentity(node, rowKey.value);
                if (childKey === void 0 || childKey === null) {
                  throw new Error("For nested data item, row-key is required.");
                }
                cur = { ...treeData.value[childKey] };
                if (cur) {
                  innerTreeRowData.expanded = cur.expanded;
                  cur.level = cur.level || innerTreeRowData.level;
                  cur.display = !!(cur.expanded && innerTreeRowData.display);
                  if (typeof cur.lazy === "boolean") {
                    if (typeof cur.loaded === "boolean" && cur.loaded) {
                      innerTreeRowData.noLazyChildren = !(cur.children && cur.children.length);
                    }
                    innerTreeRowData.loading = cur.loading;
                  }
                }
                i++;
                tmp.push(rowRender(node, $index + i, innerTreeRowData));
                if (cur) {
                  const nodes2 = lazyTreeNodeMap.value[childKey] || node[childrenColumnName.value];
                  traverse(nodes2, cur);
                }
              });
            };
            cur.display = true;
            const nodes = lazyTreeNodeMap.value[key] || row[childrenColumnName.value];
            traverse(nodes, cur);
          }
          return tmp;
        } else {
          return rowRender(row, $index, void 0);
        }
      };
      return {
        wrappedRowRender,
        tooltipContent,
        tooltipTrigger
      };
    }
  
    const defaultProps$2 = {
      store: {
        required: true,
        type: Object
      },
      stripe: Boolean,
      tooltipEffect: String,
      context: {
        default: () => ({}),
        type: Object
      },
      rowClassName: [String, Function],
      rowStyle: [Object, Function],
      fixed: {
        type: String,
        default: ""
      },
      highlight: Boolean
    };
    var defaultProps$3 = defaultProps$2;
  
    var TableBody = vue.defineComponent({
      name: "ElTableBody",
      props: defaultProps$3,
      setup(props) {
        const instance = vue.getCurrentInstance();
        const parent = vue.inject(TABLE_INJECTION_KEY);
        const ns = useNamespace("table");
        const { wrappedRowRender, tooltipContent, tooltipTrigger } = useRender$1(props);
        const { onColumnsChange, onScrollableChange } = useLayoutObserver(parent);
        vue.watch(props.store.states.hoverRow, (newVal, oldVal) => {
          if (!props.store.states.isComplex.value || !isClient)
            return;
          let raf = window.requestAnimationFrame;
          if (!raf) {
            raf = (fn) => window.setTimeout(fn, 16);
          }
          raf(() => {
            const el = instance == null ? void 0 : instance.vnode.el;
            const rows = Array.from((el == null ? void 0 : el.children) || []).filter((e) => e == null ? void 0 : e.classList.contains(`${ns.e("row")}`));
            const oldRow = rows[oldVal];
            const newRow = rows[newVal];
            if (oldRow) {
              removeClass(oldRow, "hover-row");
            }
            if (newRow) {
              addClass(newRow, "hover-row");
            }
          });
        });
        vue.onUnmounted(() => {
          var _a;
          (_a = removePopper) == null ? void 0 : _a();
        });
        return {
          ns,
          onColumnsChange,
          onScrollableChange,
          wrappedRowRender,
          tooltipContent,
          tooltipTrigger
        };
      },
      render() {
        const { wrappedRowRender, store } = this;
        const data = store.states.data.value || [];
        return vue.h("tbody", {}, [
          data.reduce((acc, row) => {
            return acc.concat(wrappedRowRender(row, acc.length));
          }, [])
        ]);
      }
    });
  
    function hColgroup(props) {
      const isAuto = props.tableLayout === "auto";
      let columns = props.columns || [];
      if (isAuto) {
        if (columns.every((column) => column.width === void 0)) {
          columns = [];
        }
      }
      const getPropsData = (column) => {
        const propsData = {
          key: `${props.tableLayout}_${column.id}`,
          style: {},
          name: void 0
        };
        if (isAuto) {
          propsData.style = {
            width: `${column.width}px`
          };
        } else {
          propsData.name = column.id;
        }
        return propsData;
      };
      return vue.h("colgroup", {}, columns.map((column) => vue.h("col", getPropsData(column))));
    }
    hColgroup.props = ["columns", "tableLayout"];
  
    function useMapState() {
      const table = vue.inject(TABLE_INJECTION_KEY);
      const store = table == null ? void 0 : table.store;
      const leftFixedLeafCount = vue.computed(() => {
        return store.states.fixedLeafColumnsLength.value;
      });
      const rightFixedLeafCount = vue.computed(() => {
        return store.states.rightFixedColumns.value.length;
      });
      const columnsCount = vue.computed(() => {
        return store.states.columns.value.length;
      });
      const leftFixedCount = vue.computed(() => {
        return store.states.fixedColumns.value.length;
      });
      const rightFixedCount = vue.computed(() => {
        return store.states.rightFixedColumns.value.length;
      });
      return {
        leftFixedLeafCount,
        rightFixedLeafCount,
        columnsCount,
        leftFixedCount,
        rightFixedCount,
        columns: store.states.columns
      };
    }
  
    function useStyle$1(props) {
      const { columns } = useMapState();
      const ns = useNamespace("table");
      const getCellClasses = (columns2, cellIndex) => {
        const column = columns2[cellIndex];
        const classes = [
          ns.e("cell"),
          column.id,
          column.align,
          column.labelClassName,
          ...getFixedColumnsClass(ns.b(), cellIndex, column.fixed, props.store)
        ];
        if (column.className) {
          classes.push(column.className);
        }
        if (!column.children) {
          classes.push(ns.is("leaf"));
        }
        return classes;
      };
      const getCellStyles = (column, cellIndex) => {
        const fixedStyle = getFixedColumnOffset(cellIndex, column.fixed, props.store);
        ensurePosition(fixedStyle, "left");
        ensurePosition(fixedStyle, "right");
        return fixedStyle;
      };
      return {
        getCellClasses,
        getCellStyles,
        columns
      };
    }
  
    var TableFooter = vue.defineComponent({
      name: "ElTableFooter",
      props: {
        fixed: {
          type: String,
          default: ""
        },
        store: {
          required: true,
          type: Object
        },
        summaryMethod: Function,
        sumText: String,
        border: Boolean,
        defaultSort: {
          type: Object,
          default: () => {
            return {
              prop: "",
              order: ""
            };
          }
        }
      },
      setup(props) {
        const { getCellClasses, getCellStyles, columns } = useStyle$1(props);
        const ns = useNamespace("table");
        return {
          ns,
          getCellClasses,
          getCellStyles,
          columns
        };
      },
      render() {
        const {
          columns,
          getCellStyles,
          getCellClasses,
          summaryMethod,
          sumText,
          ns
        } = this;
        const data = this.store.states.data.value;
        let sums = [];
        if (summaryMethod) {
          sums = summaryMethod({
            columns,
            data
          });
        } else {
          columns.forEach((column, index) => {
            if (index === 0) {
              sums[index] = sumText;
              return;
            }
            const values = data.map((item) => Number(item[column.property]));
            const precisions = [];
            let notNumber = true;
            values.forEach((value) => {
              if (!Number.isNaN(+value)) {
                notNumber = false;
                const decimal = `${value}`.split(".")[1];
                precisions.push(decimal ? decimal.length : 0);
              }
            });
            const precision = Math.max.apply(null, precisions);
            if (!notNumber) {
              sums[index] = values.reduce((prev, curr) => {
                const value = Number(curr);
                if (!Number.isNaN(+value)) {
                  return Number.parseFloat((prev + curr).toFixed(Math.min(precision, 20)));
                } else {
                  return prev;
                }
              }, 0);
            } else {
              sums[index] = "";
            }
          });
        }
        return vue.h("table", {
          class: ns.e("footer"),
          cellspacing: "0",
          cellpadding: "0",
          border: "0"
        }, [
          hColgroup({
            columns
          }),
          vue.h("tbody", [
            vue.h("tr", {}, [
              ...columns.map((column, cellIndex) => vue.h("td", {
                key: cellIndex,
                colspan: column.colSpan,
                rowspan: column.rowSpan,
                class: getCellClasses(columns, cellIndex),
                style: getCellStyles(column, cellIndex)
              }, [
                vue.h("div", {
                  class: ["cell", column.labelClassName]
                }, [sums[cellIndex]])
              ]))
            ])
          ])
        ]);
      }
    });
  
    function useUtils(store) {
      const setCurrentRow = (row) => {
        store.commit("setCurrentRow", row);
      };
      const getSelectionRows = () => {
        return store.getSelectionRows();
      };
      const toggleRowSelection = (row, selected) => {
        store.toggleRowSelection(row, selected, false);
        store.updateAllSelected();
      };
      const clearSelection = () => {
        store.clearSelection();
      };
      const clearFilter = (columnKeys) => {
        store.clearFilter(columnKeys);
      };
      const toggleAllSelection = () => {
        store.commit("toggleAllSelection");
      };
      const toggleRowExpansion = (row, expanded) => {
        store.toggleRowExpansionAdapter(row, expanded);
      };
      const clearSort = () => {
        store.clearSort();
      };
      const sort = (prop, order) => {
        store.commit("sort", { prop, order });
      };
      return {
        setCurrentRow,
        getSelectionRows,
        toggleRowSelection,
        clearSelection,
        clearFilter,
        toggleAllSelection,
        toggleRowExpansion,
        clearSort,
        sort
      };
    }
  
    function useStyle(props, layout, store, table) {
      const isHidden = vue.ref(false);
      const renderExpanded = vue.ref(null);
      const resizeProxyVisible = vue.ref(false);
      const setDragVisible = (visible) => {
        resizeProxyVisible.value = visible;
      };
      const resizeState = vue.ref({
        width: null,
        height: null,
        headerHeight: null
      });
      const isGroup = vue.ref(false);
      const scrollbarViewStyle = {
        display: "inline-block",
        verticalAlign: "middle"
      };
      const tableWidth = vue.ref();
      const tableScrollHeight = vue.ref(0);
      const bodyScrollHeight = vue.ref(0);
      const headerScrollHeight = vue.ref(0);
      const footerScrollHeight = vue.ref(0);
      vue.watchEffect(() => {
        layout.setHeight(props.height);
      });
      vue.watchEffect(() => {
        layout.setMaxHeight(props.maxHeight);
      });
      vue.watch(() => [props.currentRowKey, store.states.rowKey], ([currentRowKey, rowKey]) => {
        if (!vue.unref(rowKey) || !vue.unref(currentRowKey))
          return;
        store.setCurrentRowKey(`${currentRowKey}`);
      }, {
        immediate: true
      });
      vue.watch(() => props.data, (data) => {
        table.store.commit("setData", data);
      }, {
        immediate: true,
        deep: true
      });
      vue.watchEffect(() => {
        if (props.expandRowKeys) {
          store.setExpandRowKeysAdapter(props.expandRowKeys);
        }
      });
      const handleMouseLeave = () => {
        table.store.commit("setHoverRow", null);
        if (table.hoverState)
          table.hoverState = null;
      };
      const handleHeaderFooterMousewheel = (event, data) => {
        const { pixelX, pixelY } = data;
        if (Math.abs(pixelX) >= Math.abs(pixelY)) {
          table.refs.bodyWrapper.scrollLeft += data.pixelX / 5;
        }
      };
      const shouldUpdateHeight = vue.computed(() => {
        return props.height || props.maxHeight || store.states.fixedColumns.value.length > 0 || store.states.rightFixedColumns.value.length > 0;
      });
      const tableBodyStyles = vue.computed(() => {
        return {
          width: layout.bodyWidth.value ? `${layout.bodyWidth.value}px` : ""
        };
      });
      const doLayout = () => {
        if (shouldUpdateHeight.value) {
          layout.updateElsHeight();
        }
        layout.updateColumnsWidth();
        requestAnimationFrame(syncPosition);
      };
      vue.onMounted(async () => {
        await vue.nextTick();
        store.updateColumns();
        bindEvents();
        requestAnimationFrame(doLayout);
        const el = table.vnode.el;
        const tableHeader = table.refs.headerWrapper;
        if (props.flexible && el && el.parentElement) {
          el.parentElement.style.minWidth = "0";
        }
        resizeState.value = {
          width: tableWidth.value = el.offsetWidth,
          height: el.offsetHeight,
          headerHeight: props.showHeader && tableHeader ? tableHeader.offsetHeight : null
        };
        store.states.columns.value.forEach((column) => {
          if (column.filteredValue && column.filteredValue.length) {
            table.store.commit("filterChange", {
              column,
              values: column.filteredValue,
              silent: true
            });
          }
        });
        table.$ready = true;
      });
      const setScrollClassByEl = (el, className) => {
        if (!el)
          return;
        const classList = Array.from(el.classList).filter((item) => !item.startsWith("is-scrolling-"));
        classList.push(layout.scrollX.value ? className : "is-scrolling-none");
        el.className = classList.join(" ");
      };
      const setScrollClass = (className) => {
        const { tableWrapper } = table.refs;
        setScrollClassByEl(tableWrapper, className);
      };
      const hasScrollClass = (className) => {
        const { tableWrapper } = table.refs;
        return !!(tableWrapper && tableWrapper.classList.contains(className));
      };
      const syncPosition = function() {
        if (!table.refs.scrollBarRef)
          return;
        if (!layout.scrollX.value) {
          const scrollingNoneClass = "is-scrolling-none";
          if (!hasScrollClass(scrollingNoneClass)) {
            setScrollClass(scrollingNoneClass);
          }
          return;
        }
        const scrollContainer = table.refs.scrollBarRef.wrap$;
        if (!scrollContainer)
          return;
        const { scrollLeft, offsetWidth, scrollWidth } = scrollContainer;
        const { headerWrapper, footerWrapper } = table.refs;
        if (headerWrapper)
          headerWrapper.scrollLeft = scrollLeft;
        if (footerWrapper)
          footerWrapper.scrollLeft = scrollLeft;
        const maxScrollLeftPosition = scrollWidth - offsetWidth - 1;
        if (scrollLeft >= maxScrollLeftPosition) {
          setScrollClass("is-scrolling-right");
        } else if (scrollLeft === 0) {
          setScrollClass("is-scrolling-left");
        } else {
          setScrollClass("is-scrolling-middle");
        }
      };
      const bindEvents = () => {
        if (!table.refs.scrollBarRef)
          return;
        if (table.refs.scrollBarRef.wrap$) {
          useEventListener(table.refs.scrollBarRef.wrap$, "scroll", syncPosition, {
            passive: true
          });
        }
        if (props.fit) {
          useResizeObserver(table.vnode.el, resizeListener);
        } else {
          useEventListener(window, "resize", resizeListener);
        }
        useResizeObserver(table.refs.bodyWrapper, () => {
          var _a, _b;
          resizeListener();
          (_b = (_a = table.refs) == null ? void 0 : _a.scrollBarRef) == null ? void 0 : _b.update();
        });
      };
      const resizeListener = () => {
        var _a, _b, _c;
        const el = table.vnode.el;
        if (!table.$ready || !el)
          return;
        let shouldUpdateLayout = false;
        const {
          width: oldWidth,
          height: oldHeight,
          headerHeight: oldHeaderHeight
        } = resizeState.value;
        const width = tableWidth.value = el.offsetWidth;
        if (oldWidth !== width) {
          shouldUpdateLayout = true;
        }
        const height = el.offsetHeight;
        if ((props.height || shouldUpdateHeight.value) && oldHeight !== height) {
          shouldUpdateLayout = true;
        }
        const tableHeader = props.tableLayout === "fixed" ? table.refs.headerWrapper : (_a = table.refs.tableHeaderRef) == null ? void 0 : _a.$el;
        if (props.showHeader && (tableHeader == null ? void 0 : tableHeader.offsetHeight) !== oldHeaderHeight) {
          shouldUpdateLayout = true;
        }
        tableScrollHeight.value = ((_b = table.refs.tableWrapper) == null ? void 0 : _b.scrollHeight) || 0;
        headerScrollHeight.value = (tableHeader == null ? void 0 : tableHeader.scrollHeight) || 0;
        footerScrollHeight.value = ((_c = table.refs.footerWrapper) == null ? void 0 : _c.offsetHeight) || 0;
        bodyScrollHeight.value = tableScrollHeight.value - headerScrollHeight.value - footerScrollHeight.value;
        if (shouldUpdateLayout) {
          resizeState.value = {
            width,
            height,
            headerHeight: props.showHeader && (tableHeader == null ? void 0 : tableHeader.offsetHeight) || 0
          };
          doLayout();
        }
      };
      const tableSize = useSize();
      const bodyWidth = vue.computed(() => {
        const { bodyWidth: bodyWidth_, scrollY, gutterWidth } = layout;
        return bodyWidth_.value ? `${bodyWidth_.value - (scrollY.value ? gutterWidth : 0)}px` : "";
      });
      const tableLayout = vue.computed(() => {
        if (props.maxHeight)
          return "fixed";
        return props.tableLayout;
      });
      const emptyBlockStyle = vue.computed(() => {
        if (props.data && props.data.length)
          return null;
        let height = "100%";
        if (props.height && bodyScrollHeight.value) {
          height = `${bodyScrollHeight.value}px`;
        }
        const width = tableWidth.value;
        return {
          width: width ? `${width}px` : "",
          height
        };
      });
      const tableInnerStyle = vue.computed(() => {
        if (props.height) {
          return {
            height: !Number.isNaN(Number(props.height)) ? `${props.height}px` : props.height
          };
        }
        if (props.maxHeight) {
          return {
            maxHeight: !Number.isNaN(Number(props.maxHeight)) ? `${props.maxHeight}px` : props.maxHeight
          };
        }
        return {};
      });
      const scrollbarStyle = vue.computed(() => {
        if (props.height) {
          return {
            height: "100%"
          };
        }
        if (props.maxHeight) {
          if (!Number.isNaN(Number(props.maxHeight))) {
            const maxHeight = props.maxHeight;
            const reachMaxHeight = tableScrollHeight.value >= Number(maxHeight);
            if (reachMaxHeight) {
              return {
                maxHeight: `${tableScrollHeight.value - headerScrollHeight.value - footerScrollHeight.value}px`
              };
            }
          } else {
            return {
              maxHeight: `calc(${props.maxHeight} - ${headerScrollHeight.value + footerScrollHeight.value}px)`
            };
          }
        }
        return {};
      });
      const handleFixedMousewheel = (event, data) => {
        const bodyWrapper = table.refs.bodyWrapper;
        if (Math.abs(data.spinY) > 0) {
          const currentScrollTop = bodyWrapper.scrollTop;
          if (data.pixelY < 0 && currentScrollTop !== 0) {
            event.preventDefault();
          }
          if (data.pixelY > 0 && bodyWrapper.scrollHeight - bodyWrapper.clientHeight > currentScrollTop) {
            event.preventDefault();
          }
          bodyWrapper.scrollTop += Math.ceil(data.pixelY / 5);
        } else {
          bodyWrapper.scrollLeft += Math.ceil(data.pixelX / 5);
        }
      };
      return {
        isHidden,
        renderExpanded,
        setDragVisible,
        isGroup,
        handleMouseLeave,
        handleHeaderFooterMousewheel,
        tableSize,
        emptyBlockStyle,
        handleFixedMousewheel,
        resizeProxyVisible,
        bodyWidth,
        resizeState,
        doLayout,
        tableBodyStyles,
        tableLayout,
        scrollbarViewStyle,
        tableInnerStyle,
        scrollbarStyle
      };
    }
  
    var defaultProps$1 = {
      data: {
        type: Array,
        default: () => []
      },
      size: String,
      width: [String, Number],
      height: [String, Number],
      maxHeight: [String, Number],
      fit: {
        type: Boolean,
        default: true
      },
      stripe: Boolean,
      border: Boolean,
      rowKey: [String, Function],
      showHeader: {
        type: Boolean,
        default: true
      },
      showSummary: Boolean,
      sumText: String,
      summaryMethod: Function,
      rowClassName: [String, Function],
      rowStyle: [Object, Function],
      cellClassName: [String, Function],
      cellStyle: [Object, Function],
      headerRowClassName: [String, Function],
      headerRowStyle: [Object, Function],
      headerCellClassName: [String, Function],
      headerCellStyle: [Object, Function],
      highlightCurrentRow: Boolean,
      currentRowKey: [String, Number],
      emptyText: String,
      expandRowKeys: Array,
      defaultExpandAll: Boolean,
      defaultSort: Object,
      tooltipEffect: String,
      spanMethod: Function,
      selectOnIndeterminate: {
        type: Boolean,
        default: true
      },
      indent: {
        type: Number,
        default: 16
      },
      treeProps: {
        type: Object,
        default: () => {
          return {
            hasChildren: "hasChildren",
            children: "children"
          };
        }
      },
      lazy: Boolean,
      load: Function,
      style: {
        type: Object,
        default: () => ({})
      },
      className: {
        type: String,
        default: ""
      },
      tableLayout: {
        type: String,
        default: "fixed"
      },
      scrollbarAlwaysOn: {
        type: Boolean,
        default: false
      },
      flexible: Boolean
    };
  
    const useScrollbar$1 = () => {
      const scrollBarRef = vue.ref();
      const scrollTo = (options, yCoord) => {
        const scrollbar = scrollBarRef.value;
        if (scrollbar) {
          scrollbar.scrollTo(options, yCoord);
        }
      };
      const setScrollPosition = (position, offset) => {
        const scrollbar = scrollBarRef.value;
        if (scrollbar && isNumber(offset) && ["Top", "Left"].includes(position)) {
          scrollbar[`setScroll${position}`](offset);
        }
      };
      const setScrollTop = (top) => setScrollPosition("Top", top);
      const setScrollLeft = (left) => setScrollPosition("Left", left);
      return {
        scrollBarRef,
        scrollTo,
        setScrollTop,
        setScrollLeft
      };
    };
  
    let tableIdSeed = 1;
    const _sfc_main$p = vue.defineComponent({
      name: "ElTable",
      directives: {
        Mousewheel
      },
      components: {
        TableHeader,
        TableBody,
        TableFooter,
        ElScrollbar,
        hColgroup
      },
      props: defaultProps$1,
      emits: [
        "select",
        "select-all",
        "selection-change",
        "cell-mouse-enter",
        "cell-mouse-leave",
        "cell-contextmenu",
        "cell-click",
        "cell-dblclick",
        "row-click",
        "row-contextmenu",
        "row-dblclick",
        "header-click",
        "header-contextmenu",
        "sort-change",
        "filter-change",
        "current-change",
        "header-dragend",
        "expand-change"
      ],
      setup(props) {
        const { t } = useLocale();
        const ns = useNamespace("table");
        const table = vue.getCurrentInstance();
        vue.provide(TABLE_INJECTION_KEY, table);
        const store = createStore(table, props);
        table.store = store;
        const layout = new TableLayout$1({
          store: table.store,
          table,
          fit: props.fit,
          showHeader: props.showHeader
        });
        table.layout = layout;
        const isEmpty = vue.computed(() => (store.states.data.value || []).length === 0);
        const {
          setCurrentRow,
          getSelectionRows,
          toggleRowSelection,
          clearSelection,
          clearFilter,
          toggleAllSelection,
          toggleRowExpansion,
          clearSort,
          sort
        } = useUtils(store);
        const {
          isHidden,
          renderExpanded,
          setDragVisible,
          isGroup,
          handleMouseLeave,
          handleHeaderFooterMousewheel,
          tableSize,
          emptyBlockStyle,
          handleFixedMousewheel,
          resizeProxyVisible,
          bodyWidth,
          resizeState,
          doLayout,
          tableBodyStyles,
          tableLayout,
          scrollbarViewStyle,
          tableInnerStyle,
          scrollbarStyle
        } = useStyle(props, layout, store, table);
        const { scrollBarRef, scrollTo, setScrollLeft, setScrollTop } = useScrollbar$1();
        const debouncedUpdateLayout = debounce(doLayout, 50);
        const tableId = `${ns.namespace.value}-table_${tableIdSeed++}`;
        table.tableId = tableId;
        table.state = {
          isGroup,
          resizeState,
          doLayout,
          debouncedUpdateLayout
        };
        const computedSumText = vue.computed(() => props.sumText || t("el.table.sumText"));
        const computedEmptyText = vue.computed(() => {
          return props.emptyText || t("el.table.emptyText");
        });
        return {
          ns,
          layout,
          store,
          handleHeaderFooterMousewheel,
          handleMouseLeave,
          tableId,
          tableSize,
          isHidden,
          isEmpty,
          renderExpanded,
          resizeProxyVisible,
          resizeState,
          isGroup,
          bodyWidth,
          tableBodyStyles,
          emptyBlockStyle,
          debouncedUpdateLayout,
          handleFixedMousewheel,
          setCurrentRow,
          getSelectionRows,
          toggleRowSelection,
          clearSelection,
          clearFilter,
          toggleAllSelection,
          toggleRowExpansion,
          clearSort,
          doLayout,
          sort,
          t,
          setDragVisible,
          context: table,
          computedSumText,
          computedEmptyText,
          tableLayout,
          scrollbarViewStyle,
          tableInnerStyle,
          scrollbarStyle,
          scrollBarRef,
          scrollTo,
          setScrollLeft,
          setScrollTop
        };
      }
    });
    const _hoisted_1$b = ["data-prefix"];
    const _hoisted_2$7 = {
      ref: "hiddenColumns",
      class: "hidden-columns"
    };
    function _sfc_render$3(_ctx, _cache, $props, $setup, $data, $options) {
      const _component_hColgroup = vue.resolveComponent("hColgroup");
      const _component_table_header = vue.resolveComponent("table-header");
      const _component_table_body = vue.resolveComponent("table-body");
      const _component_el_scrollbar = vue.resolveComponent("el-scrollbar");
      const _component_table_footer = vue.resolveComponent("table-footer");
      const _directive_mousewheel = vue.resolveDirective("mousewheel");
      return vue.openBlock(), vue.createElementBlock("div", {
        ref: "tableWrapper",
        class: vue.normalizeClass([
          {
            [_ctx.ns.m("fit")]: _ctx.fit,
            [_ctx.ns.m("striped")]: _ctx.stripe,
            [_ctx.ns.m("border")]: _ctx.border || _ctx.isGroup,
            [_ctx.ns.m("hidden")]: _ctx.isHidden,
            [_ctx.ns.m("group")]: _ctx.isGroup,
            [_ctx.ns.m("fluid-height")]: _ctx.maxHeight,
            [_ctx.ns.m("scrollable-x")]: _ctx.layout.scrollX.value,
            [_ctx.ns.m("scrollable-y")]: _ctx.layout.scrollY.value,
            [_ctx.ns.m("enable-row-hover")]: !_ctx.store.states.isComplex.value,
            [_ctx.ns.m("enable-row-transition")]: (_ctx.store.states.data.value || []).length !== 0 && (_ctx.store.states.data.value || []).length < 100,
            "has-footer": _ctx.showSummary
          },
          _ctx.ns.m(_ctx.tableSize),
          _ctx.className,
          _ctx.ns.b(),
          _ctx.ns.m(`layout-${_ctx.tableLayout}`)
        ]),
        style: vue.normalizeStyle(_ctx.style),
        "data-prefix": _ctx.ns.namespace.value,
        onMouseleave: _cache[0] || (_cache[0] = ($event) => _ctx.handleMouseLeave())
      }, [
        vue.createElementVNode("div", {
          class: vue.normalizeClass(_ctx.ns.e("inner-wrapper")),
          style: vue.normalizeStyle(_ctx.tableInnerStyle)
        }, [
          vue.createElementVNode("div", _hoisted_2$7, [
            vue.renderSlot(_ctx.$slots, "default")
          ], 512),
          _ctx.showHeader && _ctx.tableLayout === "fixed" ? vue.withDirectives((vue.openBlock(), vue.createElementBlock("div", {
            key: 0,
            ref: "headerWrapper",
            class: vue.normalizeClass(_ctx.ns.e("header-wrapper"))
          }, [
            vue.createElementVNode("table", {
              ref: "tableHeader",
              class: vue.normalizeClass(_ctx.ns.e("header")),
              style: vue.normalizeStyle(_ctx.tableBodyStyles),
              border: "0",
              cellpadding: "0",
              cellspacing: "0"
            }, [
              vue.createVNode(_component_hColgroup, {
                columns: _ctx.store.states.columns.value,
                "table-layout": _ctx.tableLayout
              }, null, 8, ["columns", "table-layout"]),
              vue.createVNode(_component_table_header, {
                ref: "tableHeaderRef",
                border: _ctx.border,
                "default-sort": _ctx.defaultSort,
                store: _ctx.store,
                onSetDragVisible: _ctx.setDragVisible
              }, null, 8, ["border", "default-sort", "store", "onSetDragVisible"])
            ], 6)
          ], 2)), [
            [_directive_mousewheel, _ctx.handleHeaderFooterMousewheel]
          ]) : vue.createCommentVNode("v-if", true),
          vue.createElementVNode("div", {
            ref: "bodyWrapper",
            class: vue.normalizeClass(_ctx.ns.e("body-wrapper"))
          }, [
            vue.createVNode(_component_el_scrollbar, {
              ref: "scrollBarRef",
              "view-style": _ctx.scrollbarViewStyle,
              "wrap-style": _ctx.scrollbarStyle,
              always: _ctx.scrollbarAlwaysOn
            }, {
              default: vue.withCtx(() => [
                vue.createElementVNode("table", {
                  ref: "tableBody",
                  class: vue.normalizeClass(_ctx.ns.e("body")),
                  cellspacing: "0",
                  cellpadding: "0",
                  border: "0",
                  style: vue.normalizeStyle({
                    width: _ctx.bodyWidth,
                    tableLayout: _ctx.tableLayout
                  })
                }, [
                  vue.createVNode(_component_hColgroup, {
                    columns: _ctx.store.states.columns.value,
                    "table-layout": _ctx.tableLayout
                  }, null, 8, ["columns", "table-layout"]),
                  _ctx.showHeader && _ctx.tableLayout === "auto" ? (vue.openBlock(), vue.createBlock(_component_table_header, {
                    key: 0,
                    ref: "tableHeaderRef",
                    border: _ctx.border,
                    "default-sort": _ctx.defaultSort,
                    store: _ctx.store,
                    onSetDragVisible: _ctx.setDragVisible
                  }, null, 8, ["border", "default-sort", "store", "onSetDragVisible"])) : vue.createCommentVNode("v-if", true),
                  vue.createVNode(_component_table_body, {
                    context: _ctx.context,
                    highlight: _ctx.highlightCurrentRow,
                    "row-class-name": _ctx.rowClassName,
                    "tooltip-effect": _ctx.tooltipEffect,
                    "row-style": _ctx.rowStyle,
                    store: _ctx.store,
                    stripe: _ctx.stripe
                  }, null, 8, ["context", "highlight", "row-class-name", "tooltip-effect", "row-style", "store", "stripe"])
                ], 6),
                _ctx.isEmpty ? (vue.openBlock(), vue.createElementBlock("div", {
                  key: 0,
                  ref: "emptyBlock",
                  style: vue.normalizeStyle(_ctx.emptyBlockStyle),
                  class: vue.normalizeClass(_ctx.ns.e("empty-block"))
                }, [
                  vue.createElementVNode("span", {
                    class: vue.normalizeClass(_ctx.ns.e("empty-text"))
                  }, [
                    vue.renderSlot(_ctx.$slots, "empty", {}, () => [
                      vue.createTextVNode(vue.toDisplayString(_ctx.computedEmptyText), 1)
                    ])
                  ], 2)
                ], 6)) : vue.createCommentVNode("v-if", true),
                _ctx.$slots.append ? (vue.openBlock(), vue.createElementBlock("div", {
                  key: 1,
                  ref: "appendWrapper",
                  class: vue.normalizeClass(_ctx.ns.e("append-wrapper"))
                }, [
                  vue.renderSlot(_ctx.$slots, "append")
                ], 2)) : vue.createCommentVNode("v-if", true)
              ]),
              _: 3
            }, 8, ["view-style", "wrap-style", "always"])
          ], 2),
          _ctx.showSummary ? vue.withDirectives((vue.openBlock(), vue.createElementBlock("div", {
            key: 1,
            ref: "footerWrapper",
            class: vue.normalizeClass(_ctx.ns.e("footer-wrapper"))
          }, [
            vue.createVNode(_component_table_footer, {
              border: _ctx.border,
              "default-sort": _ctx.defaultSort,
              store: _ctx.store,
              style: vue.normalizeStyle(_ctx.tableBodyStyles),
              "sum-text": _ctx.computedSumText,
              "summary-method": _ctx.summaryMethod
            }, null, 8, ["border", "default-sort", "store", "style", "sum-text", "summary-method"])
          ], 2)), [
            [vue.vShow, !_ctx.isEmpty],
            [_directive_mousewheel, _ctx.handleHeaderFooterMousewheel]
          ]) : vue.createCommentVNode("v-if", true),
          _ctx.border || _ctx.isGroup ? (vue.openBlock(), vue.createElementBlock("div", {
            key: 2,
            class: vue.normalizeClass(_ctx.ns.e("border-left-patch"))
          }, null, 2)) : vue.createCommentVNode("v-if", true)
        ], 6),
        vue.withDirectives(vue.createElementVNode("div", {
          ref: "resizeProxy",
          class: vue.normalizeClass(_ctx.ns.e("column-resize-proxy"))
        }, null, 2), [
          [vue.vShow, _ctx.resizeProxyVisible]
        ])
      ], 46, _hoisted_1$b);
    }
    var Table = /* @__PURE__ */ _export_sfc(_sfc_main$p, [["render", _sfc_render$3], ["__file", "table.vue"]]);
  
    const defaultClassNames = {
      selection: "table-column--selection",
      expand: "table__expand-column"
    };
    const cellStarts = {
      default: {
        order: ""
      },
      selection: {
        width: 48,
        minWidth: 48,
        realWidth: 48,
        order: ""
      },
      expand: {
        width: 48,
        minWidth: 48,
        realWidth: 48,
        order: ""
      },
      index: {
        width: 48,
        minWidth: 48,
        realWidth: 48,
        order: ""
      }
    };
    const getDefaultClassName = (type) => {
      return defaultClassNames[type] || "";
    };
    const cellForced = {
      selection: {
        renderHeader({ store }) {
          function isDisabled() {
            return store.states.data.value && store.states.data.value.length === 0;
          }
          return vue.h(ElCheckbox, {
            disabled: isDisabled(),
            size: store.states.tableSize.value,
            indeterminate: store.states.selection.value.length > 0 && !store.states.isAllSelected.value,
            "onUpdate:modelValue": store.toggleAllSelection,
            modelValue: store.states.isAllSelected.value
          });
        },
        renderCell({
          row,
          column,
          store,
          $index
        }) {
          return vue.h(ElCheckbox, {
            disabled: column.selectable ? !column.selectable.call(null, row, $index) : false,
            size: store.states.tableSize.value,
            onChange: () => {
              store.commit("rowSelectedChanged", row);
            },
            onClick: (event) => event.stopPropagation(),
            modelValue: store.isSelected(row)
          });
        },
        sortable: false,
        resizable: false
      },
      index: {
        renderHeader({ column }) {
          return column.label || "#";
        },
        renderCell({
          column,
          $index
        }) {
          let i = $index + 1;
          const index = column.index;
          if (typeof index === "number") {
            i = $index + index;
          } else if (typeof index === "function") {
            i = index($index);
          }
          return vue.h("div", {}, [i]);
        },
        sortable: false
      },
      expand: {
        renderHeader({ column }) {
          return column.label || "";
        },
        renderCell({
          row,
          store,
          expanded
        }) {
          const { ns } = store;
          const classes = [ns.e("expand-icon")];
          if (expanded) {
            classes.push(ns.em("expand-icon", "expanded"));
          }
          const callback = function(e) {
            e.stopPropagation();
            store.toggleRowExpansion(row);
          };
          return vue.h("div", {
            class: classes,
            onClick: callback
          }, {
            default: () => {
              return [
                vue.h(ElIcon, null, {
                  default: () => {
                    return [vue.h(arrow_right_default)];
                  }
                })
              ];
            }
          });
        },
        sortable: false,
        resizable: false
      }
    };
    function defaultRenderCell({
      row,
      column,
      $index
    }) {
      var _a;
      const property = column.property;
      const value = property && getProp(row, property).value;
      if (column && column.formatter) {
        return column.formatter(row, column, value, $index);
      }
      return ((_a = value == null ? void 0 : value.toString) == null ? void 0 : _a.call(value)) || "";
    }
    function treeCellPrefix({
      row,
      treeNode,
      store
    }, createPlacehoder = false) {
      const { ns } = store;
      if (!treeNode) {
        if (createPlacehoder) {
          return [
            vue.h("span", {
              class: ns.e("placeholder")
            })
          ];
        }
        return null;
      }
      const ele = [];
      const callback = function(e) {
        e.stopPropagation();
        if (treeNode.loading) {
          return;
        }
        store.loadOrToggle(row);
      };
      if (treeNode.indent) {
        ele.push(vue.h("span", {
          class: ns.e("indent"),
          style: { "padding-left": `${treeNode.indent}px` }
        }));
      }
      if (typeof treeNode.expanded === "boolean" && !treeNode.noLazyChildren) {
        const expandClasses = [
          ns.e("expand-icon"),
          treeNode.expanded ? ns.em("expand-icon", "expanded") : ""
        ];
        let icon = arrow_right_default;
        if (treeNode.loading) {
          icon = loading_default;
        }
        ele.push(vue.h("div", {
          class: expandClasses,
          onClick: callback
        }, {
          default: () => {
            return [
              vue.h(ElIcon, { class: { [ns.is("loading")]: treeNode.loading } }, {
                default: () => [vue.h(icon)]
              })
            ];
          }
        }));
      } else {
        ele.push(vue.h("span", {
          class: ns.e("placeholder")
        }));
      }
      return ele;
    }
  
    function getAllAliases(props, aliases) {
      return props.reduce((prev, cur) => {
        prev[cur] = cur;
        return prev;
      }, aliases);
    }
    function useWatcher(owner, props_) {
      const instance = vue.getCurrentInstance();
      const registerComplexWatchers = () => {
        const props = ["fixed"];
        const aliases = {
          realWidth: "width",
          realMinWidth: "minWidth"
        };
        const allAliases = getAllAliases(props, aliases);
        Object.keys(allAliases).forEach((key) => {
          const columnKey = aliases[key];
          if (hasOwn(props_, columnKey)) {
            vue.watch(() => props_[columnKey], (newVal) => {
              let value = newVal;
              if (columnKey === "width" && key === "realWidth") {
                value = parseWidth(newVal);
              }
              if (columnKey === "minWidth" && key === "realMinWidth") {
                value = parseMinWidth(newVal);
              }
              instance.columnConfig.value[columnKey] = value;
              instance.columnConfig.value[key] = value;
              const updateColumns = columnKey === "fixed";
              owner.value.store.scheduleLayout(updateColumns);
            });
          }
        });
      };
      const registerNormalWatchers = () => {
        const props = [
          "label",
          "filters",
          "filterMultiple",
          "sortable",
          "index",
          "formatter",
          "className",
          "labelClassName",
          "showOverflowTooltip"
        ];
        const aliases = {
          property: "prop",
          align: "realAlign",
          headerAlign: "realHeaderAlign"
        };
        const allAliases = getAllAliases(props, aliases);
        Object.keys(allAliases).forEach((key) => {
          const columnKey = aliases[key];
          if (hasOwn(props_, columnKey)) {
            vue.watch(() => props_[columnKey], (newVal) => {
              instance.columnConfig.value[key] = newVal;
            });
          }
        });
      };
      return {
        registerComplexWatchers,
        registerNormalWatchers
      };
    }
  
    function useRender(props, slots, owner) {
      const instance = vue.getCurrentInstance();
      const columnId = vue.ref("");
      const isSubColumn = vue.ref(false);
      const realAlign = vue.ref();
      const realHeaderAlign = vue.ref();
      const ns = useNamespace("table");
      vue.watchEffect(() => {
        realAlign.value = props.align ? `is-${props.align}` : null;
        realAlign.value;
      });
      vue.watchEffect(() => {
        realHeaderAlign.value = props.headerAlign ? `is-${props.headerAlign}` : realAlign.value;
        realHeaderAlign.value;
      });
      const columnOrTableParent = vue.computed(() => {
        let parent = instance.vnode.vParent || instance.parent;
        while (parent && !parent.tableId && !parent.columnId) {
          parent = parent.vnode.vParent || parent.parent;
        }
        return parent;
      });
      const hasTreeColumn = vue.computed(() => {
        const { store } = instance.parent;
        if (!store)
          return false;
        const { treeData } = store.states;
        const treeDataValue = treeData.value;
        return treeDataValue && Object.keys(treeDataValue).length > 0;
      });
      const realWidth = vue.ref(parseWidth(props.width));
      const realMinWidth = vue.ref(parseMinWidth(props.minWidth));
      const setColumnWidth = (column) => {
        if (realWidth.value)
          column.width = realWidth.value;
        if (realMinWidth.value) {
          column.minWidth = realMinWidth.value;
        }
        if (!realWidth.value && realMinWidth.value) {
          column.width = void 0;
        }
        if (!column.minWidth) {
          column.minWidth = 80;
        }
        column.realWidth = Number(column.width === void 0 ? column.minWidth : column.width);
        return column;
      };
      const setColumnForcedProps = (column) => {
        const type = column.type;
        const source = cellForced[type] || {};
        Object.keys(source).forEach((prop) => {
          const value = source[prop];
          if (prop !== "className" && value !== void 0) {
            column[prop] = value;
          }
        });
        const className = getDefaultClassName(type);
        if (className) {
          const forceClass = `${vue.unref(ns.namespace)}-${className}`;
          column.className = column.className ? `${column.className} ${forceClass}` : forceClass;
        }
        return column;
      };
      const checkSubColumn = (children) => {
        if (Array.isArray(children)) {
          children.forEach((child) => check(child));
        } else {
          check(children);
        }
        function check(item) {
          var _a;
          if (((_a = item == null ? void 0 : item.type) == null ? void 0 : _a.name) === "ElTableColumn") {
            item.vParent = instance;
          }
        }
      };
      const setColumnRenders = (column) => {
        if (props.renderHeader) ; else if (column.type !== "selection") {
          column.renderHeader = (scope) => {
            instance.columnConfig.value["label"];
            const renderHeader = slots.header;
            return renderHeader ? renderHeader(scope) : column.label;
          };
        }
        let originRenderCell = column.renderCell;
        if (column.type === "expand") {
          column.renderCell = (data) => vue.h("div", {
            class: "cell"
          }, [originRenderCell(data)]);
          owner.value.renderExpanded = (data) => {
            return slots.default ? slots.default(data) : slots.default;
          };
        } else {
          originRenderCell = originRenderCell || defaultRenderCell;
          column.renderCell = (data) => {
            let children = null;
            if (slots.default) {
              const vnodes = slots.default(data);
              children = vnodes.some((v) => v.type !== vue.Comment) ? vnodes : originRenderCell(data);
            } else {
              children = originRenderCell(data);
            }
            const shouldCreatePlaceholder = hasTreeColumn.value && data.cellIndex === 0 && data.column.type !== "selection";
            const prefix = treeCellPrefix(data, shouldCreatePlaceholder);
            const props2 = {
              class: "cell",
              style: {}
            };
            if (column.showOverflowTooltip) {
              props2.class = `${props2.class} ${vue.unref(ns.namespace)}-tooltip`;
              props2.style = {
                width: `${(data.column.realWidth || Number(data.column.width)) - 1}px`
              };
            }
            checkSubColumn(children);
            return vue.h("div", props2, [prefix, children]);
          };
        }
        return column;
      };
      const getPropsData = (...propsKey) => {
        return propsKey.reduce((prev, cur) => {
          if (Array.isArray(cur)) {
            cur.forEach((key) => {
              prev[key] = props[key];
            });
          }
          return prev;
        }, {});
      };
      const getColumnElIndex = (children, child) => {
        return Array.prototype.indexOf.call(children, child);
      };
      return {
        columnId,
        realAlign,
        isSubColumn,
        realHeaderAlign,
        columnOrTableParent,
        setColumnWidth,
        setColumnForcedProps,
        setColumnRenders,
        getPropsData,
        getColumnElIndex
      };
    }
  
    var defaultProps = {
      type: {
        type: String,
        default: "default"
      },
      label: String,
      className: String,
      labelClassName: String,
      property: String,
      prop: String,
      width: {
        type: [String, Number],
        default: ""
      },
      minWidth: {
        type: [String, Number],
        default: ""
      },
      renderHeader: Function,
      sortable: {
        type: [Boolean, String],
        default: false
      },
      sortMethod: Function,
      sortBy: [String, Function, Array],
      resizable: {
        type: Boolean,
        default: true
      },
      columnKey: String,
      align: String,
      headerAlign: String,
      showTooltipWhenOverflow: Boolean,
      showOverflowTooltip: Boolean,
      fixed: [Boolean, String],
      formatter: Function,
      selectable: Function,
      reserveSelection: Boolean,
      filterMethod: Function,
      filteredValue: Array,
      filters: Array,
      filterPlacement: String,
      filterMultiple: {
        type: Boolean,
        default: true
      },
      index: [Number, Function],
      sortOrders: {
        type: Array,
        default: () => {
          return ["ascending", "descending", null];
        },
        validator: (val) => {
          return val.every((order) => ["ascending", "descending", null].includes(order));
        }
      }
    };
  
    let columnIdSeed = 1;
    var ElTableColumn$1 = vue.defineComponent({
      name: "ElTableColumn",
      components: {
        ElCheckbox
      },
      props: defaultProps,
      setup(props, { slots }) {
        const instance = vue.getCurrentInstance();
        const columnConfig = vue.ref({});
        const owner = vue.computed(() => {
          let parent2 = instance.parent;
          while (parent2 && !parent2.tableId) {
            parent2 = parent2.parent;
          }
          return parent2;
        });
        const { registerNormalWatchers, registerComplexWatchers } = useWatcher(owner, props);
        const {
          columnId,
          isSubColumn,
          realHeaderAlign,
          columnOrTableParent,
          setColumnWidth,
          setColumnForcedProps,
          setColumnRenders,
          getPropsData,
          getColumnElIndex,
          realAlign
        } = useRender(props, slots, owner);
        const parent = columnOrTableParent.value;
        columnId.value = `${parent.tableId || parent.columnId}_column_${columnIdSeed++}`;
        vue.onBeforeMount(() => {
          isSubColumn.value = owner.value !== parent;
          const type = props.type || "default";
          const sortable = props.sortable === "" ? true : props.sortable;
          const defaults = {
            ...cellStarts[type],
            id: columnId.value,
            type,
            property: props.prop || props.property,
            align: realAlign,
            headerAlign: realHeaderAlign,
            showOverflowTooltip: props.showOverflowTooltip || props.showTooltipWhenOverflow,
            filterable: props.filters || props.filterMethod,
            filteredValue: [],
            filterPlacement: "",
            isColumnGroup: false,
            isSubColumn: false,
            filterOpened: false,
            sortable,
            index: props.index,
            rawColumnKey: instance.vnode.key
          };
          const basicProps = [
            "columnKey",
            "label",
            "className",
            "labelClassName",
            "type",
            "renderHeader",
            "formatter",
            "fixed",
            "resizable"
          ];
          const sortProps = ["sortMethod", "sortBy", "sortOrders"];
          const selectProps = ["selectable", "reserveSelection"];
          const filterProps = [
            "filterMethod",
            "filters",
            "filterMultiple",
            "filterOpened",
            "filteredValue",
            "filterPlacement"
          ];
          let column = getPropsData(basicProps, sortProps, selectProps, filterProps);
          column = mergeOptions(defaults, column);
          const chains = compose(setColumnRenders, setColumnWidth, setColumnForcedProps);
          column = chains(column);
          columnConfig.value = column;
          registerNormalWatchers();
          registerComplexWatchers();
        });
        vue.onMounted(() => {
          var _a;
          const parent2 = columnOrTableParent.value;
          const children = isSubColumn.value ? parent2.vnode.el.children : (_a = parent2.refs.hiddenColumns) == null ? void 0 : _a.children;
          const getColumnIndex = () => getColumnElIndex(children || [], instance.vnode.el);
          columnConfig.value.getColumnIndex = getColumnIndex;
          const columnIndex = getColumnIndex();
          columnIndex > -1 && owner.value.store.commit("insertColumn", columnConfig.value, isSubColumn.value ? parent2.columnConfig.value : null);
        });
        vue.onBeforeUnmount(() => {
          owner.value.store.commit("removeColumn", columnConfig.value, isSubColumn.value ? parent.columnConfig.value : null);
        });
        instance.columnId = columnId.value;
        instance.columnConfig = columnConfig;
        return;
      },
      render() {
        var _a, _b, _c;
        try {
          const renderDefault = (_b = (_a = this.$slots).default) == null ? void 0 : _b.call(_a, {
            row: {},
            column: {},
            $index: -1
          });
          const children = [];
          if (Array.isArray(renderDefault)) {
            for (const childNode of renderDefault) {
              if (((_c = childNode.type) == null ? void 0 : _c.name) === "ElTableColumn" || childNode.shapeFlag & 2) {
                children.push(childNode);
              } else if (childNode.type === vue.Fragment && Array.isArray(childNode.children)) {
                childNode.children.forEach((vnode2) => {
                  if ((vnode2 == null ? void 0 : vnode2.patchFlag) !== 1024 && !isString(vnode2 == null ? void 0 : vnode2.children)) {
                    children.push(vnode2);
                  }
                });
              }
            }
          }
          const vnode = vue.h("div", children);
          return vnode;
        } catch (e) {
          return vue.h("div", []);
        }
      }
    });
  
    const ElTable = withInstall(Table, {
      TableColumn: ElTableColumn$1
    });
    const ElTableColumn = withNoopInstall(ElTableColumn$1);
  
    var SortOrder = /* @__PURE__ */ ((SortOrder2) => {
      SortOrder2["ASC"] = "asc";
      SortOrder2["DESC"] = "desc";
      return SortOrder2;
    })(SortOrder || {});
    var Alignment = /* @__PURE__ */ ((Alignment2) => {
      Alignment2["CENTER"] = "center";
      Alignment2["RIGHT"] = "right";
      return Alignment2;
    })(Alignment || {});
    var FixedDir = /* @__PURE__ */ ((FixedDir2) => {
      FixedDir2["LEFT"] = "left";
      FixedDir2["RIGHT"] = "right";
      return FixedDir2;
    })(FixedDir || {});
    const oppositeOrderMap = {
      ["asc" /* ASC */]: "desc" /* DESC */,
      ["desc" /* DESC */]: "asc" /* ASC */
    };
  
    const placeholderSign = Symbol("placeholder");
  
    const calcColumnStyle = (column, fixedColumn, fixed) => {
      var _a;
      const flex = {
        flexGrow: 0,
        flexShrink: 0,
        ...fixed ? {} : {
          flexGrow: column.flexGrow || 0,
          flexShrink: column.flexShrink || 1
        }
      };
      if (!fixed) {
        flex.flexShrink = 1;
      }
      const style = {
        ...(_a = column.style) != null ? _a : {},
        ...flex,
        flexBasis: "auto",
        width: column.width
      };
      if (!fixedColumn) {
        if (column.maxWidth)
          style.maxWidth = column.maxWidth;
        if (column.minWidth)
          style.minWidth = column.minWidth;
      }
      return style;
    };
  
    function useColumns(props, columns, fixed) {
      const visibleColumns = vue.computed(() => {
        return vue.unref(columns).filter((column) => !column.hidden);
      });
      const fixedColumnsOnLeft = vue.computed(() => vue.unref(visibleColumns).filter((column) => column.fixed === "left" || column.fixed === true));
      const fixedColumnsOnRight = vue.computed(() => vue.unref(visibleColumns).filter((column) => column.fixed === "right"));
      const normalColumns = vue.computed(() => vue.unref(visibleColumns).filter((column) => !column.fixed));
      const mainColumns = vue.computed(() => {
        const ret = [];
        vue.unref(fixedColumnsOnLeft).forEach((column) => {
          ret.push({
            ...column,
            placeholderSign
          });
        });
        vue.unref(normalColumns).forEach((column) => {
          ret.push(column);
        });
        vue.unref(fixedColumnsOnRight).forEach((column) => {
          ret.push({
            ...column,
            placeholderSign
          });
        });
        return ret;
      });
      const hasFixedColumns = vue.computed(() => {
        return vue.unref(fixedColumnsOnLeft).length || vue.unref(fixedColumnsOnRight).length;
      });
      const columnsStyles = vue.computed(() => {
        const _columns = vue.unref(columns);
        return _columns.reduce((style, column) => {
          style[column.key] = calcColumnStyle(column, vue.unref(fixed), props.fixed);
          return style;
        }, {});
      });
      const columnsTotalWidth = vue.computed(() => {
        return vue.unref(visibleColumns).reduce((width, column) => width + column.width, 0);
      });
      const getColumn = (key) => {
        return vue.unref(columns).find((column) => column.key === key);
      };
      const getColumnStyle = (key) => {
        return vue.unref(columnsStyles)[key];
      };
      const updateColumnWidth = (column, width) => {
        column.width = width;
      };
      function onColumnSorted(e) {
        var _a;
        const { key } = e.currentTarget.dataset;
        if (!key)
          return;
        const { sortState, sortBy } = props;
        let order = SortOrder.ASC;
        if (isObject$1(sortState)) {
          order = oppositeOrderMap[sortState[key]];
        } else {
          order = oppositeOrderMap[sortBy.order];
        }
        (_a = props.onColumnSort) == null ? void 0 : _a.call(props, { column: getColumn(key), key, order });
      }
      return {
        columns,
        columnsStyles,
        columnsTotalWidth,
        fixedColumnsOnLeft,
        fixedColumnsOnRight,
        hasFixedColumns,
        mainColumns,
        normalColumns,
        visibleColumns,
        getColumn,
        getColumnStyle,
        updateColumnWidth,
        onColumnSorted
      };
    }
  
    const useScrollbar = (props, {
      mainTableRef,
      leftTableRef,
      rightTableRef,
      onMaybeEndReached
    }) => {
      const scrollPos = vue.ref({ scrollLeft: 0, scrollTop: 0 });
      function doScroll(params) {
        var _a, _b, _c;
        const { scrollTop } = params;
        (_a = mainTableRef.value) == null ? void 0 : _a.scrollTo(params);
        (_b = leftTableRef.value) == null ? void 0 : _b.scrollToTop(scrollTop);
        (_c = rightTableRef.value) == null ? void 0 : _c.scrollToTop(scrollTop);
      }
      function scrollTo(params) {
        scrollPos.value = params;
        doScroll(params);
      }
      function scrollToTop(scrollTop) {
        scrollPos.value.scrollTop = scrollTop;
        doScroll(vue.unref(scrollPos));
      }
      function scrollToLeft(scrollLeft) {
        var _a, _b;
        scrollPos.value.scrollLeft = scrollLeft;
        (_b = (_a = mainTableRef.value) == null ? void 0 : _a.scrollTo) == null ? void 0 : _b.call(_a, vue.unref(scrollPos));
      }
      function onScroll(params) {
        var _a;
        scrollTo(params);
        (_a = props.onScroll) == null ? void 0 : _a.call(props, params);
      }
      function onVerticalScroll({ scrollTop }) {
        const { scrollTop: currentScrollTop } = vue.unref(scrollPos);
        if (scrollTop !== currentScrollTop)
          scrollToTop(scrollTop);
      }
      function scrollToRow(row, strategy = "auto") {
        var _a;
        (_a = mainTableRef.value) == null ? void 0 : _a.scrollToRow(row, strategy);
      }
      vue.watch(() => vue.unref(scrollPos).scrollTop, (cur, prev) => {
        if (cur > prev)
          onMaybeEndReached();
      });
      return {
        scrollPos,
        scrollTo,
        scrollToLeft,
        scrollToTop,
        scrollToRow,
        onScroll,
        onVerticalScroll
      };
    };
  
    const useRow = (props, { mainTableRef, leftTableRef, rightTableRef, onMaybeEndReached }) => {
      const vm = vue.getCurrentInstance();
      const { emit } = vm;
      const isResetting = vue.shallowRef(false);
      const hoveringRowKey = vue.shallowRef(null);
      const expandedRowKeys = vue.ref(props.defaultExpandedRowKeys || []);
      const lastRenderedRowIndex = vue.ref(-1);
      const resetIndex = vue.shallowRef(null);
      const rowHeights = vue.ref({});
      const pendingRowHeights = vue.ref({});
      const leftTableHeights = vue.shallowRef({});
      const mainTableHeights = vue.shallowRef({});
      const rightTableHeights = vue.shallowRef({});
      const isDynamic = vue.computed(() => isNumber(props.estimatedRowHeight));
      function onRowsRendered(params) {
        var _a;
        (_a = props.onRowsRendered) == null ? void 0 : _a.call(props, params);
        if (params.rowCacheEnd > vue.unref(lastRenderedRowIndex)) {
          lastRenderedRowIndex.value = params.rowCacheEnd;
        }
      }
      function onRowHovered({ hovered, rowKey }) {
        hoveringRowKey.value = hovered ? rowKey : null;
      }
      function onRowExpanded({
        expanded,
        rowData,
        rowIndex,
        rowKey
      }) {
        var _a, _b;
        const _expandedRowKeys = [...vue.unref(expandedRowKeys)];
        const currentKeyIndex = _expandedRowKeys.indexOf(rowKey);
        if (expanded) {
          if (currentKeyIndex === -1)
            _expandedRowKeys.push(rowKey);
        } else {
          if (currentKeyIndex > -1)
            _expandedRowKeys.splice(currentKeyIndex, 1);
        }
        expandedRowKeys.value = _expandedRowKeys;
        emit("update:expandedRowKeys", _expandedRowKeys);
        (_a = props.onRowExpand) == null ? void 0 : _a.call(props, {
          expanded,
          rowData,
          rowIndex,
          rowKey
        });
        (_b = props.onExpandedRowsChange) == null ? void 0 : _b.call(props, _expandedRowKeys);
      }
      const flushingRowHeights = debounce(() => {
        var _a, _b, _c, _d;
        isResetting.value = true;
        rowHeights.value = { ...vue.unref(rowHeights), ...vue.unref(pendingRowHeights) };
        resetAfterIndex(vue.unref(resetIndex), false);
        pendingRowHeights.value = {};
        resetIndex.value = null;
        (_a = mainTableRef.value) == null ? void 0 : _a.forceUpdate();
        (_b = leftTableRef.value) == null ? void 0 : _b.forceUpdate();
        (_c = rightTableRef.value) == null ? void 0 : _c.forceUpdate();
        (_d = vm.proxy) == null ? void 0 : _d.$forceUpdate();
        isResetting.value = false;
      }, 0);
      function resetAfterIndex(index, forceUpdate = false) {
        if (!vue.unref(isDynamic))
          return;
        [mainTableRef, leftTableRef, rightTableRef].forEach((tableRef) => {
          const table = vue.unref(tableRef);
          if (table)
            table.resetAfterRowIndex(index, forceUpdate);
        });
      }
      function resetHeights(rowKey, height, rowIdx) {
        const resetIdx = vue.unref(resetIndex);
        if (resetIdx === null) {
          resetIndex.value = rowIdx;
        } else {
          if (resetIdx > rowIdx) {
            resetIndex.value = rowIdx;
          }
        }
        pendingRowHeights.value[rowKey] = height;
      }
      function onRowHeightChange({ rowKey, height, rowIndex }, fixedDir) {
        if (!fixedDir) {
          mainTableHeights.value[rowKey] = height;
        } else {
          if (fixedDir === FixedDir.RIGHT) {
            rightTableHeights.value[rowKey] = height;
          } else {
            leftTableHeights.value[rowKey] = height;
          }
        }
        const maximumHeight = Math.max(...[leftTableHeights, rightTableHeights, mainTableHeights].map((records) => records.value[rowKey] || 0));
        if (vue.unref(rowHeights)[rowKey] !== maximumHeight) {
          resetHeights(rowKey, maximumHeight, rowIndex);
          flushingRowHeights();
        }
      }
      vue.watch(lastRenderedRowIndex, () => onMaybeEndReached());
      return {
        hoveringRowKey,
        expandedRowKeys,
        lastRenderedRowIndex,
        isDynamic,
        isResetting,
        rowHeights,
        resetAfterIndex,
        onRowExpanded,
        onRowHovered,
        onRowsRendered,
        onRowHeightChange
      };
    };
  
    const useData = (props, { expandedRowKeys, lastRenderedRowIndex, resetAfterIndex }) => {
      const depthMap = vue.ref({});
      const flattenedData = vue.computed(() => {
        const depths = {};
        const { data: data2, rowKey } = props;
        const _expandedRowKeys = vue.unref(expandedRowKeys);
        if (!_expandedRowKeys || !_expandedRowKeys.length)
          return data2;
        const array = [];
        const keysSet = /* @__PURE__ */ new Set();
        _expandedRowKeys.forEach((x) => keysSet.add(x));
        let copy = data2.slice();
        copy.forEach((x) => depths[x[rowKey]] = 0);
        while (copy.length > 0) {
          const item = copy.shift();
          array.push(item);
          if (keysSet.has(item[rowKey]) && Array.isArray(item.children) && item.children.length > 0) {
            copy = [...item.children, ...copy];
            item.children.forEach((child) => depths[child[rowKey]] = depths[item[rowKey]] + 1);
          }
        }
        depthMap.value = depths;
        return array;
      });
      const data = vue.computed(() => {
        const { data: data2, expandColumnKey } = props;
        return expandColumnKey ? vue.unref(flattenedData) : data2;
      });
      vue.watch(data, (val, prev) => {
        if (val !== prev) {
          lastRenderedRowIndex.value = -1;
          resetAfterIndex(0, true);
        }
      });
      return {
        data,
        depthMap
      };
    };
  
    const sumReducer = (sum2, num) => sum2 + num;
    const sum = (listLike) => {
      return isArray(listLike) ? listLike.reduce(sumReducer, 0) : listLike;
    };
    const tryCall = (fLike, params, defaultRet = {}) => {
      return isFunction(fLike) ? fLike(params) : fLike != null ? fLike : defaultRet;
    };
    const enforceUnit = (style) => {
      ["width", "maxWidth", "minWidth", "height"].forEach((key) => {
        style[key] = addUnit(style[key]);
      });
      return style;
    };
    const componentToSlot = (ComponentLike) => vue.isVNode(ComponentLike) ? (props) => vue.h(ComponentLike, props) : ComponentLike;
  
    const useStyles = (props, {
      columnsTotalWidth,
      data,
      fixedColumnsOnLeft,
      fixedColumnsOnRight
    }) => {
      const bodyWidth = vue.computed(() => {
        const { fixed, width, vScrollbarSize } = props;
        const ret = width - vScrollbarSize;
        return fixed ? Math.max(Math.round(vue.unref(columnsTotalWidth)), ret) : ret;
      });
      const headerWidth = vue.computed(() => vue.unref(bodyWidth) + (props.fixed ? props.vScrollbarSize : 0));
      const mainTableHeight = vue.computed(() => {
        const { height = 0, maxHeight = 0, footerHeight: footerHeight2, hScrollbarSize } = props;
        if (maxHeight > 0) {
          const _fixedRowsHeight = vue.unref(fixedRowsHeight);
          const _rowsHeight = vue.unref(rowsHeight);
          const _headerHeight = vue.unref(headerHeight);
          const total = _headerHeight + _fixedRowsHeight + _rowsHeight + hScrollbarSize;
          return Math.min(total, maxHeight - footerHeight2);
        }
        return height - footerHeight2;
      });
      const rowsHeight = vue.computed(() => {
        const { rowHeight, estimatedRowHeight } = props;
        const _data = vue.unref(data);
        if (isNumber(estimatedRowHeight)) {
          return _data.length * estimatedRowHeight;
        }
        return _data.length * rowHeight;
      });
      const fixedTableHeight = vue.computed(() => {
        const { maxHeight } = props;
        const tableHeight = vue.unref(mainTableHeight);
        if (isNumber(maxHeight) && maxHeight > 0)
          return tableHeight;
        const totalHeight = vue.unref(rowsHeight) + vue.unref(headerHeight) + vue.unref(fixedRowsHeight);
        return Math.min(tableHeight, totalHeight);
      });
      const mapColumn = (column) => column.width;
      const leftTableWidth = vue.computed(() => sum(vue.unref(fixedColumnsOnLeft).map(mapColumn)));
      const rightTableWidth = vue.computed(() => sum(vue.unref(fixedColumnsOnRight).map(mapColumn)));
      const headerHeight = vue.computed(() => sum(props.headerHeight));
      const fixedRowsHeight = vue.computed(() => {
        var _a;
        return (((_a = props.fixedData) == null ? void 0 : _a.length) || 0) * props.rowHeight;
      });
      const windowHeight = vue.computed(() => {
        return vue.unref(mainTableHeight) - vue.unref(headerHeight) - vue.unref(fixedRowsHeight);
      });
      const rootStyle = vue.computed(() => {
        const { style = {}, height, width } = props;
        return enforceUnit({
          ...style,
          height,
          width
        });
      });
      const footerHeight = vue.computed(() => enforceUnit({ height: props.footerHeight }));
      const emptyStyle = vue.computed(() => ({
        top: addUnit(vue.unref(headerHeight)),
        bottom: addUnit(props.footerHeight),
        width: addUnit(props.width)
      }));
      return {
        bodyWidth,
        fixedTableHeight,
        mainTableHeight,
        leftTableWidth,
        rightTableWidth,
        headerWidth,
        rowsHeight,
        windowHeight,
        footerHeight,
        emptyStyle,
        rootStyle,
        headerHeight
      };
    };
  
    const useAutoResize = (props) => {
      const sizer = vue.ref();
      const width$ = vue.ref(0);
      const height$ = vue.ref(0);
      let resizerStopper;
      vue.onMounted(() => {
        resizerStopper = useResizeObserver(sizer, ([entry]) => {
          const { width, height } = entry.contentRect;
          const { paddingLeft, paddingRight, paddingTop, paddingBottom } = getComputedStyle(entry.target);
          const left = Number.parseInt(paddingLeft) || 0;
          const right = Number.parseInt(paddingRight) || 0;
          const top = Number.parseInt(paddingTop) || 0;
          const bottom = Number.parseInt(paddingBottom) || 0;
          width$.value = width - left - right;
          height$.value = height - top - bottom;
        }).stop;
      });
      vue.onBeforeUnmount(() => {
        resizerStopper == null ? void 0 : resizerStopper();
      });
      vue.watch([width$, height$], ([width, height]) => {
        var _a;
        (_a = props.onResize) == null ? void 0 : _a.call(props, {
          width,
          height
        });
      });
      return {
        sizer,
        width: width$,
        height: height$
      };
    };
  
    function useTable(props) {
      const mainTableRef = vue.ref();
      const leftTableRef = vue.ref();
      const rightTableRef = vue.ref();
      const {
        columns,
        columnsStyles,
        columnsTotalWidth,
        fixedColumnsOnLeft,
        fixedColumnsOnRight,
        hasFixedColumns,
        mainColumns,
        onColumnSorted
      } = useColumns(props, vue.toRef(props, "columns"), vue.toRef(props, "fixed"));
      const {
        scrollTo,
        scrollToLeft,
        scrollToTop,
        scrollToRow,
        onScroll,
        onVerticalScroll,
        scrollPos
      } = useScrollbar(props, {
        mainTableRef,
        leftTableRef,
        rightTableRef,
        onMaybeEndReached
      });
      const {
        expandedRowKeys,
        hoveringRowKey,
        lastRenderedRowIndex,
        isDynamic,
        isResetting,
        rowHeights,
        resetAfterIndex,
        onRowExpanded,
        onRowHeightChange,
        onRowHovered,
        onRowsRendered
      } = useRow(props, {
        mainTableRef,
        leftTableRef,
        rightTableRef,
        onMaybeEndReached
      });
      const { data, depthMap } = useData(props, {
        expandedRowKeys,
        lastRenderedRowIndex,
        resetAfterIndex
      });
      const {
        bodyWidth,
        fixedTableHeight,
        mainTableHeight,
        leftTableWidth,
        rightTableWidth,
        headerWidth,
        rowsHeight,
        windowHeight,
        footerHeight,
        emptyStyle,
        rootStyle,
        headerHeight
      } = useStyles(props, {
        columnsTotalWidth,
        data,
        fixedColumnsOnLeft,
        fixedColumnsOnRight
      });
      const isScrolling = vue.shallowRef(false);
      const containerRef = vue.ref();
      const showEmpty = vue.computed(() => {
        const noData = vue.unref(data).length === 0;
        return isArray(props.fixedData) ? props.fixedData.length === 0 && noData : noData;
      });
      function getRowHeight(rowIndex) {
        const { estimatedRowHeight, rowHeight, rowKey } = props;
        if (!estimatedRowHeight)
          return rowHeight;
        return vue.unref(rowHeights)[vue.unref(data)[rowIndex][rowKey]] || estimatedRowHeight;
      }
      function onMaybeEndReached() {
        const { onEndReached } = props;
        if (!onEndReached)
          return;
        const { scrollTop } = vue.unref(scrollPos);
        const _totalHeight = vue.unref(rowsHeight);
        const clientHeight = vue.unref(windowHeight);
        const heightUntilEnd = _totalHeight - (scrollTop + clientHeight) + props.hScrollbarSize;
        if (vue.unref(lastRenderedRowIndex) >= 0 && _totalHeight === scrollTop + vue.unref(mainTableHeight) - vue.unref(headerHeight)) {
          onEndReached(heightUntilEnd);
        }
      }
      vue.watch(() => props.expandedRowKeys, (val) => expandedRowKeys.value = val, {
        deep: true
      });
      return {
        columns,
        containerRef,
        mainTableRef,
        leftTableRef,
        rightTableRef,
        isDynamic,
        isResetting,
        isScrolling,
        hoveringRowKey,
        hasFixedColumns,
        columnsStyles,
        columnsTotalWidth,
        data,
        expandedRowKeys,
        depthMap,
        fixedColumnsOnLeft,
        fixedColumnsOnRight,
        mainColumns,
        bodyWidth,
        emptyStyle,
        rootStyle,
        headerWidth,
        footerHeight,
        mainTableHeight,
        fixedTableHeight,
        leftTableWidth,
        rightTableWidth,
        showEmpty,
        getRowHeight,
        onColumnSorted,
        onRowHovered,
        onRowExpanded,
        onRowsRendered,
        onRowHeightChange,
        scrollTo,
        scrollToLeft,
        scrollToTop,
        scrollToRow,
        onScroll,
        onVerticalScroll
      };
    }
  
    const TableV2InjectionKey = Symbol("tableV2");
  
    const classType = String;
    const columns = {
      type: definePropType(Array),
      required: true
    };
    const fixedDataType = {
      type: definePropType(Array)
    };
    const dataType = {
      ...fixedDataType,
      required: true
    };
    const expandColumnKey = String;
    const expandKeys = {
      type: definePropType(Array),
      default: () => mutable([])
    };
    const requiredNumber = {
      type: Number,
      required: true
    };
    const rowKey = {
      type: definePropType([String, Number, Symbol]),
      default: "id"
    };
    const styleType = {
      type: definePropType(Object)
    };
  
    const tableV2RowProps = buildProps({
      class: String,
      columns,
      columnsStyles: {
        type: definePropType(Object),
        required: true
      },
      depth: Number,
      expandColumnKey,
      estimatedRowHeight: {
        ...virtualizedGridProps.estimatedRowHeight,
        default: void 0
      },
      isScrolling: Boolean,
      onRowExpand: {
        type: definePropType(Function)
      },
      onRowHover: {
        type: definePropType(Function)
      },
      onRowHeightChange: {
        type: definePropType(Function)
      },
      rowData: {
        type: definePropType(Object),
        required: true
      },
      rowEventHandlers: {
        type: definePropType(Object)
      },
      rowIndex: {
        type: Number,
        required: true
      },
      rowKey,
      style: {
        type: definePropType(Object)
      }
    });
  
    const requiredNumberType = {
      type: Number,
      required: true
    };
    const tableV2HeaderProps = buildProps({
      class: String,
      columns,
      fixedHeaderData: {
        type: definePropType(Array)
      },
      headerData: {
        type: definePropType(Array),
        required: true
      },
      headerHeight: {
        type: definePropType([Number, Array]),
        default: 50
      },
      rowWidth: requiredNumberType,
      rowHeight: {
        type: Number,
        default: 50
      },
      height: requiredNumberType,
      width: requiredNumberType
    });
  
    const tableV2GridProps = buildProps({
      columns,
      data: dataType,
      fixedData: fixedDataType,
      estimatedRowHeight: tableV2RowProps.estimatedRowHeight,
      width: requiredNumber,
      height: requiredNumber,
      headerWidth: requiredNumber,
      headerHeight: tableV2HeaderProps.headerHeight,
      bodyWidth: requiredNumber,
      rowHeight: requiredNumber,
      cache: virtualizedListProps.cache,
      useIsScrolling: Boolean,
      scrollbarAlwaysOn: virtualizedGridProps.scrollbarAlwaysOn,
      scrollbarStartGap: virtualizedGridProps.scrollbarStartGap,
      scrollbarEndGap: virtualizedGridProps.scrollbarEndGap,
      class: classType,
      style: styleType,
      containerStyle: styleType,
      getRowHeight: {
        type: definePropType(Function),
        required: true
      },
      rowKey: tableV2RowProps.rowKey,
      onRowsRendered: {
        type: definePropType(Function)
      },
      onScroll: {
        type: definePropType(Function)
      }
    });
  
    const tableV2Props = buildProps({
      cache: tableV2GridProps.cache,
      estimatedRowHeight: tableV2RowProps.estimatedRowHeight,
      rowKey,
      headerClass: {
        type: definePropType([
          String,
          Function
        ])
      },
      headerProps: {
        type: definePropType([
          Object,
          Function
        ])
      },
      headerCellProps: {
        type: definePropType([
          Object,
          Function
        ])
      },
      headerHeight: tableV2HeaderProps.headerHeight,
      footerHeight: {
        type: Number,
        default: 0
      },
      rowClass: {
        type: definePropType([String, Function])
      },
      rowProps: {
        type: definePropType([Object, Function])
      },
      rowHeight: {
        type: Number,
        default: 50
      },
      cellProps: {
        type: definePropType([
          Object,
          Function
        ])
      },
      columns,
      data: dataType,
      dataGetter: {
        type: definePropType(Function)
      },
      fixedData: fixedDataType,
      expandColumnKey: tableV2RowProps.expandColumnKey,
      expandedRowKeys: expandKeys,
      defaultExpandedRowKeys: expandKeys,
      class: classType,
      fixed: Boolean,
      style: {
        type: definePropType(Object)
      },
      width: requiredNumber,
      height: requiredNumber,
      maxHeight: Number,
      useIsScrolling: Boolean,
      indentSize: {
        type: Number,
        default: 12
      },
      iconSize: {
        type: Number,
        default: 12
      },
      hScrollbarSize: virtualizedGridProps.hScrollbarSize,
      vScrollbarSize: virtualizedGridProps.vScrollbarSize,
      scrollbarAlwaysOn: virtualizedScrollbarProps.alwaysOn,
      sortBy: {
        type: definePropType(Object),
        default: () => ({})
      },
      sortState: {
        type: definePropType(Object),
        default: void 0
      },
      onColumnSort: {
        type: definePropType(Function)
      },
      onExpandedRowsChange: {
        type: definePropType(Function)
      },
      onEndReached: {
        type: definePropType(Function)
      },
      onRowExpand: tableV2RowProps.onRowExpand,
      onScroll: tableV2GridProps.onScroll,
      onRowsRendered: tableV2GridProps.onRowsRendered,
      rowEventHandlers: tableV2RowProps.rowEventHandlers
    });
  
    const TableV2Cell = (props, {
      slots
    }) => {
      var _a;
      const {
        cellData,
        style
      } = props;
      const displayText = ((_a = cellData == null ? void 0 : cellData.toString) == null ? void 0 : _a.call(cellData)) || "";
      return vue.createVNode("div", {
        "class": props.class,
        "title": displayText,
        "style": style
      }, [slots.default ? slots.default(props) : displayText]);
    };
    TableV2Cell.displayName = "ElTableV2Cell";
    TableV2Cell.inheritAttrs = false;
    var TableCell = TableV2Cell;
  
    const HeaderCell = (props, {
      slots
    }) => {
      var _a, _b;
      return slots.default ? slots.default(props) : vue.createVNode("div", {
        "class": props.class,
        "title": (_a = props.column) == null ? void 0 : _a.title
      }, [(_b = props.column) == null ? void 0 : _b.title]);
    };
    HeaderCell.displayName = "ElTableV2HeaderCell";
    HeaderCell.inheritAttrs = false;
    var HeaderCell$1 = HeaderCell;
  
    const tableV2HeaderRowProps = buildProps({
      class: String,
      columns,
      columnsStyles: {
        type: definePropType(Object),
        required: true
      },
      headerIndex: Number,
      style: { type: definePropType(Object) }
    });
  
    const TableV2HeaderRow = vue.defineComponent({
      name: "ElTableV2HeaderRow",
      props: tableV2HeaderRowProps,
      setup(props, {
        slots
      }) {
        return () => {
          const {
            columns,
            columnsStyles,
            headerIndex,
            style
          } = props;
          let Cells = columns.map((column, columnIndex) => {
            return slots.cell({
              columns,
              column,
              columnIndex,
              headerIndex,
              style: columnsStyles[column.key]
            });
          });
          if (slots.header) {
            Cells = slots.header({
              cells: Cells.map((node) => {
                if (isArray(node) && node.length === 1) {
                  return node[0];
                }
                return node;
              }),
              columns,
              headerIndex
            });
          }
          return vue.createVNode("div", {
            "class": props.class,
            "style": style
          }, [Cells]);
        };
      }
    });
    var HeaderRow = TableV2HeaderRow;
  
    const COMPONENT_NAME$7 = "ElTableV2Header";
    const TableV2Header = vue.defineComponent({
      name: COMPONENT_NAME$7,
      props: tableV2HeaderProps,
      setup(props, {
        slots,
        expose
      }) {
        const ns = useNamespace("table-v2");
        const headerRef = vue.ref();
        const headerStyle = vue.computed(() => enforceUnit({
          width: props.width,
          height: props.height
        }));
        const rowStyle = vue.computed(() => enforceUnit({
          width: props.rowWidth,
          height: props.height
        }));
        const headerHeights = vue.computed(() => castArray$1(vue.unref(props.headerHeight)));
        const scrollToLeft = (left) => {
          const headerEl = vue.unref(headerRef);
          vue.nextTick(() => {
            (headerEl == null ? void 0 : headerEl.scroll) && headerEl.scroll({
              left
            });
          });
        };
        const renderFixedRows = () => {
          const fixedRowClassName = ns.e("fixed-header-row");
          const {
            columns,
            fixedHeaderData,
            rowHeight
          } = props;
          return fixedHeaderData == null ? void 0 : fixedHeaderData.map((fixedRowData, fixedRowIndex) => {
            var _a;
            const style = enforceUnit({
              height: rowHeight,
              width: "100%"
            });
            return (_a = slots.fixed) == null ? void 0 : _a.call(slots, {
              class: fixedRowClassName,
              columns,
              rowData: fixedRowData,
              rowIndex: -(fixedRowIndex + 1),
              style
            });
          });
        };
        const renderDynamicRows = () => {
          const dynamicRowClassName = ns.e("dynamic-header-row");
          const {
            columns
          } = props;
          return vue.unref(headerHeights).map((rowHeight, rowIndex) => {
            var _a;
            const style = enforceUnit({
              width: "100%",
              height: rowHeight
            });
            return (_a = slots.dynamic) == null ? void 0 : _a.call(slots, {
              class: dynamicRowClassName,
              columns,
              headerIndex: rowIndex,
              style
            });
          });
        };
        expose({
          scrollToLeft
        });
        return () => {
          if (props.height <= 0)
            return;
          return vue.createVNode("div", {
            "ref": headerRef,
            "class": props.class,
            "style": vue.unref(headerStyle)
          }, [vue.createVNode("div", {
            "style": vue.unref(rowStyle),
            "class": ns.e("header")
          }, [renderDynamicRows(), renderFixedRows()])]);
        };
      }
    });
    var Header = TableV2Header;
  
    const useTableRow = (props) => {
      const {
        isScrolling
      } = vue.inject(TableV2InjectionKey);
      const measured = vue.ref(false);
      const rowRef = vue.ref();
      const measurable = vue.computed(() => {
        return isNumber(props.estimatedRowHeight) && props.rowIndex >= 0;
      });
      const doMeasure = (isInit = false) => {
        const $rowRef = vue.unref(rowRef);
        if (!$rowRef)
          return;
        const {
          columns,
          onRowHeightChange,
          rowKey,
          rowIndex,
          style
        } = props;
        const {
          height
        } = $rowRef.getBoundingClientRect();
        measured.value = true;
        vue.nextTick(() => {
          if (isInit || height !== Number.parseInt(style.height)) {
            const firstColumn = columns[0];
            const isPlaceholder = (firstColumn == null ? void 0 : firstColumn.placeholderSign) === placeholderSign;
            onRowHeightChange == null ? void 0 : onRowHeightChange({
              rowKey,
              height,
              rowIndex
            }, firstColumn && !isPlaceholder && firstColumn.fixed);
          }
        });
      };
      const eventHandlers = vue.computed(() => {
        const {
          rowData,
          rowIndex,
          rowKey,
          onRowHover
        } = props;
        const handlers = props.rowEventHandlers || {};
        const eventHandlers2 = {};
        Object.entries(handlers).forEach(([eventName, handler]) => {
          if (isFunction(handler)) {
            eventHandlers2[eventName] = (event) => {
              handler({
                event,
                rowData,
                rowIndex,
                rowKey
              });
            };
          }
        });
        if (onRowHover) {
          [{
            name: "onMouseleave",
            hovered: false
          }, {
            name: "onMouseenter",
            hovered: true
          }].forEach(({
            name,
            hovered
          }) => {
            const existedHandler = eventHandlers2[name];
            eventHandlers2[name] = (event) => {
              onRowHover({
                event,
                hovered,
                rowData,
                rowIndex,
                rowKey
              });
              existedHandler == null ? void 0 : existedHandler(event);
            };
          });
        }
        return eventHandlers2;
      });
      const onExpand = (expanded) => {
        const {
          onRowExpand,
          rowData,
          rowIndex,
          rowKey
        } = props;
        onRowExpand == null ? void 0 : onRowExpand({
          expanded,
          rowData,
          rowIndex,
          rowKey
        });
      };
      vue.onMounted(() => {
        if (vue.unref(measurable)) {
          doMeasure(true);
        }
      });
      return {
        isScrolling,
        measurable,
        measured,
        rowRef,
        eventHandlers,
        onExpand
      };
    };
    const COMPONENT_NAME$6 = "ElTableV2TableRow";
    const TableV2Row = vue.defineComponent({
      name: COMPONENT_NAME$6,
      props: tableV2RowProps,
      setup(props, {
        expose,
        slots,
        attrs
      }) {
        const {
          eventHandlers,
          isScrolling,
          measurable,
          measured,
          rowRef,
          onExpand
        } = useTableRow(props);
        expose({
          onExpand
        });
        return () => {
          const {
            columns,
            columnsStyles,
            expandColumnKey,
            depth,
            rowData,
            rowIndex,
            style
          } = props;
          let ColumnCells = columns.map((column, columnIndex) => {
            const expandable = isArray(rowData.children) && rowData.children.length > 0 && column.key === expandColumnKey;
            return slots.cell({
              column,
              columns,
              columnIndex,
              depth,
              style: columnsStyles[column.key],
              rowData,
              rowIndex,
              isScrolling: vue.unref(isScrolling),
              expandIconProps: expandable ? {
                rowData,
                rowIndex,
                onExpand
              } : void 0
            });
          });
          if (slots.row) {
            ColumnCells = slots.row({
              cells: ColumnCells.map((node) => {
                if (isArray(node) && node.length === 1) {
                  return node[0];
                }
                return node;
              }),
              style,
              columns,
              depth,
              rowData,
              rowIndex,
              isScrolling: vue.unref(isScrolling)
            });
          }
          if (vue.unref(measurable)) {
            const {
              height,
              ...exceptHeightStyle
            } = style || {};
            const _measured = vue.unref(measured);
            return vue.createVNode("div", vue.mergeProps({
              "ref": rowRef,
              "class": props.class,
              "style": _measured ? style : exceptHeightStyle
            }, attrs, vue.unref(eventHandlers)), [ColumnCells]);
          }
          return vue.createVNode("div", vue.mergeProps(attrs, {
            "ref": rowRef,
            "class": props.class,
            "style": style
          }, vue.unref(eventHandlers)), [ColumnCells]);
        };
      }
    });
    var Row = TableV2Row;
  
    const SortIcon = (props) => {
      const {
        sortOrder
      } = props;
      return vue.createVNode(ElIcon, {
        "size": 14,
        "class": props.class
      }, {
        default: () => [sortOrder === SortOrder.ASC ? vue.createVNode(sort_up_default, null, null) : vue.createVNode(sort_down_default, null, null)]
      });
    };
    var SortIcon$1 = SortIcon;
  
    const ExpandIcon = (props) => {
      const {
        expanded,
        expandable,
        onExpand,
        style,
        size
      } = props;
      const expandIconProps = {
        onClick: expandable ? () => onExpand(!expanded) : void 0,
        class: props.class
      };
      return vue.createVNode(ElIcon, vue.mergeProps(expandIconProps, {
        "size": size,
        "style": style
      }), {
        default: () => [vue.createVNode(arrow_right_default, null, null)]
      });
    };
    var ExpandIcon$1 = ExpandIcon;
  
    const COMPONENT_NAME$5 = "ElTableV2Grid";
    const useTableGrid = (props) => {
      const headerRef = vue.ref();
      const bodyRef = vue.ref();
      const totalHeight = vue.computed(() => {
        const {
          data,
          rowHeight,
          estimatedRowHeight
        } = props;
        if (estimatedRowHeight) {
          return;
        }
        return data.length * rowHeight;
      });
      const fixedRowHeight = vue.computed(() => {
        const {
          fixedData,
          rowHeight
        } = props;
        return ((fixedData == null ? void 0 : fixedData.length) || 0) * rowHeight;
      });
      const headerHeight = vue.computed(() => sum(props.headerHeight));
      const gridHeight = vue.computed(() => {
        const {
          height
        } = props;
        return Math.max(0, height - vue.unref(headerHeight) - vue.unref(fixedRowHeight));
      });
      const hasHeader = vue.computed(() => {
        return vue.unref(headerHeight) + vue.unref(fixedRowHeight) > 0;
      });
      const itemKey = ({
        data,
        rowIndex
      }) => data[rowIndex][props.rowKey];
      function onItemRendered({
        rowCacheStart,
        rowCacheEnd,
        rowVisibleStart,
        rowVisibleEnd
      }) {
        var _a;
        (_a = props.onRowsRendered) == null ? void 0 : _a.call(props, {
          rowCacheStart,
          rowCacheEnd,
          rowVisibleStart,
          rowVisibleEnd
        });
      }
      function resetAfterRowIndex(index, forceUpdate2) {
        var _a;
        (_a = bodyRef.value) == null ? void 0 : _a.resetAfterRowIndex(index, forceUpdate2);
      }
      function scrollTo(leftOrOptions, top) {
        const header$ = vue.unref(headerRef);
        const body$ = vue.unref(bodyRef);
        if (!header$ || !body$)
          return;
        if (isObject$1(leftOrOptions)) {
          header$.scrollToLeft(leftOrOptions.scrollLeft);
          body$.scrollTo(leftOrOptions);
        } else {
          header$.scrollToLeft(leftOrOptions);
          body$.scrollTo({
            scrollLeft: leftOrOptions,
            scrollTop: top
          });
        }
      }
      function scrollToTop(scrollTop) {
        var _a;
        (_a = vue.unref(bodyRef)) == null ? void 0 : _a.scrollTo({
          scrollTop
        });
      }
      function scrollToRow(row, strategy) {
        var _a;
        (_a = vue.unref(bodyRef)) == null ? void 0 : _a.scrollToItem(row, 1, strategy);
      }
      function forceUpdate() {
        var _a, _b;
        (_a = vue.unref(bodyRef)) == null ? void 0 : _a.$forceUpdate();
        (_b = vue.unref(headerRef)) == null ? void 0 : _b.$forceUpdate();
      }
      return {
        bodyRef,
        forceUpdate,
        fixedRowHeight,
        gridHeight,
        hasHeader,
        headerHeight,
        headerRef,
        totalHeight,
        itemKey,
        onItemRendered,
        resetAfterRowIndex,
        scrollTo,
        scrollToTop,
        scrollToRow
      };
    };
    const TableGrid = vue.defineComponent({
      name: COMPONENT_NAME$5,
      props: tableV2GridProps,
      setup(props, {
        slots,
        expose
      }) {
        const {
          ns
        } = vue.inject(TableV2InjectionKey);
        const {
          bodyRef,
          fixedRowHeight,
          gridHeight,
          hasHeader,
          headerRef,
          headerHeight,
          totalHeight,
          forceUpdate,
          itemKey,
          onItemRendered,
          resetAfterRowIndex,
          scrollTo,
          scrollToTop,
          scrollToRow
        } = useTableGrid(props);
        expose({
          forceUpdate,
          totalHeight,
          scrollTo,
          scrollToTop,
          scrollToRow,
          resetAfterRowIndex
        });
        const getColumnWidth = () => props.bodyWidth;
        return () => {
          const {
            cache,
            columns,
            data,
            fixedData,
            useIsScrolling,
            scrollbarAlwaysOn,
            scrollbarEndGap,
            scrollbarStartGap,
            style,
            rowHeight,
            bodyWidth,
            estimatedRowHeight,
            headerWidth,
            height,
            width,
            getRowHeight,
            onScroll
          } = props;
          const isDynamicRowEnabled = isNumber(estimatedRowHeight);
          const Grid = isDynamicRowEnabled ? DynamicSizeGrid$1 : FixedSizeGrid$1;
          const _headerHeight = vue.unref(headerHeight);
          return vue.createVNode("div", {
            "role": "table",
            "class": [ns.e("table"), props.class],
            "style": style
          }, [vue.createVNode(Grid, {
            "ref": bodyRef,
            "data": data,
            "useIsScrolling": useIsScrolling,
            "itemKey": itemKey,
            "columnCache": 0,
            "columnWidth": isDynamicRowEnabled ? getColumnWidth : bodyWidth,
            "totalColumn": 1,
            "totalRow": data.length,
            "rowCache": cache,
            "rowHeight": isDynamicRowEnabled ? getRowHeight : rowHeight,
            "width": width,
            "height": vue.unref(gridHeight),
            "class": ns.e("body"),
            "scrollbarStartGap": scrollbarStartGap,
            "scrollbarEndGap": scrollbarEndGap,
            "scrollbarAlwaysOn": scrollbarAlwaysOn,
            "onScroll": onScroll,
            "onItemRendered": onItemRendered,
            "perfMode": false
          }, {
            default: (params) => {
              var _a;
              const rowData = data[params.rowIndex];
              return (_a = slots.row) == null ? void 0 : _a.call(slots, {
                ...params,
                columns,
                rowData
              });
            }
          }), vue.unref(hasHeader) && vue.createVNode(Header, {
            "ref": headerRef,
            "class": ns.e("header-wrapper"),
            "columns": columns,
            "headerData": data,
            "headerHeight": props.headerHeight,
            "fixedHeaderData": fixedData,
            "rowWidth": headerWidth,
            "rowHeight": rowHeight,
            "width": width,
            "height": Math.min(_headerHeight + vue.unref(fixedRowHeight), height)
          }, {
            dynamic: slots.header,
            fixed: slots.row
          })]);
        };
      }
    });
  
    function _isSlot$5(s) {
      return typeof s === "function" || Object.prototype.toString.call(s) === "[object Object]" && !vue.isVNode(s);
    }
    const MainTable = (props, {
      slots
    }) => {
      const {
        mainTableRef,
        ...rest
      } = props;
      return vue.createVNode(TableGrid, vue.mergeProps({
        "ref": mainTableRef
      }, rest), _isSlot$5(slots) ? slots : {
        default: () => [slots]
      });
    };
  
    function _isSlot$4(s) {
      return typeof s === "function" || Object.prototype.toString.call(s) === "[object Object]" && !vue.isVNode(s);
    }
    const LeftTable$1 = (props, {
      slots
    }) => {
      if (!props.columns.length)
        return;
      const {
        leftTableRef,
        ...rest
      } = props;
      return vue.createVNode(TableGrid, vue.mergeProps({
        "ref": leftTableRef
      }, rest), _isSlot$4(slots) ? slots : {
        default: () => [slots]
      });
    };
  
    function _isSlot$3(s) {
      return typeof s === "function" || Object.prototype.toString.call(s) === "[object Object]" && !vue.isVNode(s);
    }
    const LeftTable = (props, {
      slots
    }) => {
      if (!props.columns.length)
        return;
      const {
        rightTableRef,
        ...rest
      } = props;
      return vue.createVNode(TableGrid, vue.mergeProps({
        "ref": rightTableRef
      }, rest), _isSlot$3(slots) ? slots : {
        default: () => [slots]
      });
    };
  
    function _isSlot$2(s) {
      return typeof s === "function" || Object.prototype.toString.call(s) === "[object Object]" && !vue.isVNode(s);
    }
    const RowRenderer = (props, {
      slots
    }) => {
      const {
        columns,
        columnsStyles,
        depthMap,
        expandColumnKey,
        expandedRowKeys,
        estimatedRowHeight,
        hasFixedColumns,
        hoveringRowKey,
        rowData,
        rowIndex,
        style,
        isScrolling,
        rowProps,
        rowClass,
        rowKey,
        rowEventHandlers,
        ns,
        onRowHovered,
        onRowExpanded
      } = props;
      const rowKls = tryCall(rowClass, {
        columns,
        rowData,
        rowIndex
      }, "");
      const additionalProps = tryCall(rowProps, {
        columns,
        rowData,
        rowIndex
      });
      const _rowKey = rowData[rowKey];
      const depth = depthMap[_rowKey] || 0;
      const canExpand = Boolean(expandColumnKey);
      const isFixedRow = rowIndex < 0;
      const kls = [ns.e("row"), rowKls, {
        [ns.e(`row-depth-${depth}`)]: canExpand && rowIndex >= 0,
        [ns.is("expanded")]: canExpand && expandedRowKeys.includes(_rowKey),
        [ns.is("hovered")]: !isScrolling && _rowKey === hoveringRowKey,
        [ns.is("fixed")]: !depth && isFixedRow,
        [ns.is("customized")]: Boolean(slots.row)
      }];
      const onRowHover = hasFixedColumns ? onRowHovered : void 0;
      const _rowProps = {
        ...additionalProps,
        columns,
        columnsStyles,
        class: kls,
        depth,
        expandColumnKey,
        estimatedRowHeight: isFixedRow ? void 0 : estimatedRowHeight,
        isScrolling,
        rowIndex,
        rowData,
        rowKey: _rowKey,
        rowEventHandlers,
        style
      };
      return vue.createVNode(Row, vue.mergeProps(_rowProps, {
        "onRowHover": onRowHover,
        "onRowExpand": onRowExpanded
      }), _isSlot$2(slots) ? slots : {
        default: () => [slots]
      });
    };
  
    const CellRenderer = ({
      columns,
      column,
      columnIndex,
      depth,
      expandIconProps,
      isScrolling,
      rowData,
      rowIndex,
      style,
      expandedRowKeys,
      ns,
      cellProps: _cellProps,
      expandColumnKey,
      indentSize,
      iconSize,
      rowKey
    }, {
      slots
    }) => {
      const cellStyle = enforceUnit(style);
      if (column.placeholderSign === placeholderSign) {
        return vue.createVNode("div", {
          "class": ns.em("row-cell", "placeholder"),
          "style": cellStyle
        }, null);
      }
      const {
        cellRenderer,
        dataKey,
        dataGetter
      } = column;
      const columnCellRenderer = componentToSlot(cellRenderer);
      const CellComponent = columnCellRenderer || slots.default || ((props) => vue.createVNode(TableCell, props, null));
      const cellData = isFunction(dataGetter) ? dataGetter({
        columns,
        column,
        columnIndex,
        rowData,
        rowIndex
      }) : get(rowData, dataKey != null ? dataKey : "");
      const extraCellProps = tryCall(_cellProps, {
        cellData,
        columns,
        column,
        columnIndex,
        rowIndex,
        rowData
      });
      const cellProps = {
        class: ns.e("cell-text"),
        columns,
        column,
        columnIndex,
        cellData,
        isScrolling,
        rowData,
        rowIndex
      };
      const Cell = CellComponent(cellProps);
      const kls = [ns.e("row-cell"), column.align === Alignment.CENTER && ns.is("align-center"), column.align === Alignment.RIGHT && ns.is("align-right")];
      const expandable = rowIndex >= 0 && column.key === expandColumnKey;
      const expanded = rowIndex >= 0 && expandedRowKeys.includes(rowData[rowKey]);
      let IconOrPlaceholder;
      const iconStyle = `margin-inline-start: ${depth * indentSize}px;`;
      if (expandable) {
        if (isObject$1(expandIconProps)) {
          IconOrPlaceholder = vue.createVNode(ExpandIcon$1, vue.mergeProps(expandIconProps, {
            "class": [ns.e("expand-icon"), ns.is("expanded", expanded)],
            "size": iconSize,
            "expanded": expanded,
            "style": iconStyle,
            "expandable": true
          }), null);
        } else {
          IconOrPlaceholder = vue.createVNode("div", {
            "style": [iconStyle, `width: ${iconSize}px; height: ${iconSize}px;`].join(" ")
          }, null);
        }
      }
      return vue.createVNode("div", vue.mergeProps({
        "class": kls,
        "style": cellStyle
      }, extraCellProps), [IconOrPlaceholder, Cell]);
    };
    CellRenderer.inheritAttrs = false;
  
    function _isSlot$1(s) {
      return typeof s === "function" || Object.prototype.toString.call(s) === "[object Object]" && !vue.isVNode(s);
    }
    const HeaderRenderer = ({
      columns,
      columnsStyles,
      headerIndex,
      style,
      headerClass,
      headerProps,
      ns
    }, {
      slots
    }) => {
      const param = {
        columns,
        headerIndex
      };
      const kls = [ns.e("header-row"), tryCall(headerClass, param, ""), {
        [ns.is("customized")]: Boolean(slots.header)
      }];
      const extraProps = {
        ...tryCall(headerProps, param),
        columnsStyles,
        class: kls,
        columns,
        headerIndex,
        style
      };
      return vue.createVNode(HeaderRow, extraProps, _isSlot$1(slots) ? slots : {
        default: () => [slots]
      });
    };
  
    const HeaderCellRenderer = (props, {
      slots
    }) => {
      const {
        column,
        ns,
        style,
        onColumnSorted
      } = props;
      const cellStyle = enforceUnit(style);
      if (column.placeholderSign === placeholderSign) {
        return vue.createVNode("div", {
          "class": ns.em("header-row-cell", "placeholder"),
          "style": cellStyle
        }, null);
      }
      const {
        headerCellRenderer,
        headerClass,
        sortable
      } = column;
      const cellProps = {
        ...props,
        class: ns.e("header-cell-text")
      };
      const cellRenderer = componentToSlot(headerCellRenderer) || slots.default || ((props2) => vue.createVNode(HeaderCell$1, props2, null));
      const Cell = cellRenderer(cellProps);
      const {
        sortBy,
        sortState,
        headerCellProps
      } = props;
      let sorting, sortOrder;
      if (sortState) {
        const order = sortState[column.key];
        sorting = Boolean(oppositeOrderMap[order]);
        sortOrder = sorting ? order : SortOrder.ASC;
      } else {
        sorting = column.key === sortBy.key;
        sortOrder = sorting ? sortBy.order : SortOrder.ASC;
      }
      const cellKls = [ns.e("header-cell"), tryCall(headerClass, props, ""), column.align === Alignment.CENTER && ns.is("align-center"), column.align === Alignment.RIGHT && ns.is("align-right"), sortable && ns.is("sortable")];
      const cellWrapperProps = {
        ...tryCall(headerCellProps, props),
        onClick: column.sortable ? onColumnSorted : void 0,
        class: cellKls,
        style: cellStyle,
        ["data-key"]: column.key
      };
      return vue.createVNode("div", cellWrapperProps, [Cell, sortable && vue.createVNode(SortIcon$1, {
        "class": [ns.e("sort-icon"), sorting && ns.is("sorting")],
        "sortOrder": sortOrder
      }, null)]);
    };
  
    const Footer$1 = (props, {
      slots
    }) => {
      var _a;
      return vue.createVNode("div", {
        "class": props.class,
        "style": props.style
      }, [(_a = slots.default) == null ? void 0 : _a.call(slots)]);
    };
    Footer$1.displayName = "ElTableV2Footer";
  
    const Footer = (props, {
      slots
    }) => {
      return vue.createVNode("div", {
        "class": props.class,
        "style": props.style
      }, [slots.default ? slots.default() : vue.createVNode(ElEmpty, null, null)]);
    };
    Footer.displayName = "ElTableV2Empty";
  
    const Overlay = (props, {
      slots
    }) => {
      var _a;
      return vue.createVNode("div", {
        "class": props.class,
        "style": props.style
      }, [(_a = slots.default) == null ? void 0 : _a.call(slots)]);
    };
    Overlay.displayName = "ElTableV2Overlay";
  
    function _isSlot(s) {
      return typeof s === "function" || Object.prototype.toString.call(s) === "[object Object]" && !vue.isVNode(s);
    }
    const COMPONENT_NAME$4 = "ElTableV2";
    const TableV2 = vue.defineComponent({
      name: COMPONENT_NAME$4,
      props: tableV2Props,
      setup(props, {
        slots,
        expose
      }) {
        const ns = useNamespace("table-v2");
        const {
          columnsStyles,
          fixedColumnsOnLeft,
          fixedColumnsOnRight,
          mainColumns,
          mainTableHeight,
          fixedTableHeight,
          leftTableWidth,
          rightTableWidth,
          data,
          depthMap,
          expandedRowKeys,
          hasFixedColumns,
          hoveringRowKey,
          mainTableRef,
          leftTableRef,
          rightTableRef,
          isDynamic,
          isResetting,
          isScrolling,
          bodyWidth,
          emptyStyle,
          rootStyle,
          headerWidth,
          footerHeight,
          showEmpty,
          scrollTo,
          scrollToLeft,
          scrollToTop,
          scrollToRow,
          getRowHeight,
          onColumnSorted,
          onRowHeightChange,
          onRowHovered,
          onRowExpanded,
          onRowsRendered,
          onScroll,
          onVerticalScroll
        } = useTable(props);
        expose({
          scrollTo,
          scrollToLeft,
          scrollToTop,
          scrollToRow
        });
        vue.provide(TableV2InjectionKey, {
          ns,
          isResetting,
          hoveringRowKey,
          isScrolling
        });
        return () => {
          const {
            cache,
            cellProps,
            estimatedRowHeight,
            expandColumnKey,
            fixedData,
            headerHeight,
            headerClass,
            headerProps,
            headerCellProps,
            sortBy,
            sortState,
            rowHeight,
            rowClass,
            rowEventHandlers,
            rowKey,
            rowProps,
            scrollbarAlwaysOn,
            indentSize,
            iconSize,
            useIsScrolling,
            vScrollbarSize,
            width
          } = props;
          const _data = vue.unref(data);
          const mainTableProps = {
            cache,
            class: ns.e("main"),
            columns: vue.unref(mainColumns),
            data: _data,
            fixedData,
            estimatedRowHeight,
            bodyWidth: vue.unref(bodyWidth),
            headerHeight,
            headerWidth: vue.unref(headerWidth),
            height: vue.unref(mainTableHeight),
            mainTableRef,
            rowKey,
            rowHeight,
            scrollbarAlwaysOn,
            scrollbarStartGap: 2,
            scrollbarEndGap: vScrollbarSize,
            useIsScrolling,
            width,
            getRowHeight,
            onRowsRendered,
            onScroll
          };
          const leftColumnsWidth = vue.unref(leftTableWidth);
          const _fixedTableHeight = vue.unref(fixedTableHeight);
          const leftTableProps = {
            cache,
            class: ns.e("left"),
            columns: vue.unref(fixedColumnsOnLeft),
            data: _data,
            estimatedRowHeight,
            leftTableRef,
            rowHeight,
            bodyWidth: leftColumnsWidth,
            headerWidth: leftColumnsWidth,
            headerHeight,
            height: _fixedTableHeight,
            rowKey,
            scrollbarAlwaysOn,
            scrollbarStartGap: 2,
            scrollbarEndGap: vScrollbarSize,
            useIsScrolling,
            width: leftColumnsWidth,
            getRowHeight,
            onScroll: onVerticalScroll
          };
          const rightColumnsWidth = vue.unref(rightTableWidth);
          const rightColumnsWidthWithScrollbar = rightColumnsWidth + vScrollbarSize;
          const rightTableProps = {
            cache,
            class: ns.e("right"),
            columns: vue.unref(fixedColumnsOnRight),
            data: _data,
            estimatedRowHeight,
            rightTableRef,
            rowHeight,
            bodyWidth: rightColumnsWidthWithScrollbar,
            headerWidth: rightColumnsWidthWithScrollbar,
            headerHeight,
            height: _fixedTableHeight,
            rowKey,
            scrollbarAlwaysOn,
            scrollbarStartGap: 2,
            scrollbarEndGap: vScrollbarSize,
            width: rightColumnsWidthWithScrollbar,
            style: `--${vue.unref(ns.namespace)}-table-scrollbar-size: ${vScrollbarSize}px`,
            useIsScrolling,
            getRowHeight,
            onScroll: onVerticalScroll
          };
          const _columnsStyles = vue.unref(columnsStyles);
          const tableRowProps = {
            ns,
            depthMap: vue.unref(depthMap),
            columnsStyles: _columnsStyles,
            expandColumnKey,
            expandedRowKeys: vue.unref(expandedRowKeys),
            estimatedRowHeight,
            hasFixedColumns: vue.unref(hasFixedColumns),
            hoveringRowKey: vue.unref(hoveringRowKey),
            rowProps,
            rowClass,
            rowKey,
            rowEventHandlers,
            onRowHovered,
            onRowExpanded,
            onRowHeightChange
          };
          const tableCellProps = {
            cellProps,
            expandColumnKey,
            indentSize,
            iconSize,
            rowKey,
            expandedRowKeys: vue.unref(expandedRowKeys),
            ns
          };
          const tableHeaderProps = {
            ns,
            headerClass,
            headerProps,
            columnsStyles: _columnsStyles
          };
          const tableHeaderCellProps = {
            ns,
            sortBy,
            sortState,
            headerCellProps,
            onColumnSorted
          };
          const tableSlots = {
            row: (props2) => vue.createVNode(RowRenderer, vue.mergeProps(props2, tableRowProps), {
              row: slots.row,
              cell: (props3) => {
                let _slot;
                return slots.cell ? vue.createVNode(CellRenderer, vue.mergeProps(props3, tableCellProps, {
                  "style": _columnsStyles[props3.column.key]
                }), _isSlot(_slot = slots.cell(props3)) ? _slot : {
                  default: () => [_slot]
                }) : vue.createVNode(CellRenderer, vue.mergeProps(props3, tableCellProps, {
                  "style": _columnsStyles[props3.column.key]
                }), null);
              }
            }),
            header: (props2) => vue.createVNode(HeaderRenderer, vue.mergeProps(props2, tableHeaderProps), {
              header: slots.header,
              cell: (props3) => {
                let _slot2;
                return slots["header-cell"] ? vue.createVNode(HeaderCellRenderer, vue.mergeProps(props3, tableHeaderCellProps, {
                  "style": _columnsStyles[props3.column.key]
                }), _isSlot(_slot2 = slots["header-cell"](props3)) ? _slot2 : {
                  default: () => [_slot2]
                }) : vue.createVNode(HeaderCellRenderer, vue.mergeProps(props3, tableHeaderCellProps, {
                  "style": _columnsStyles[props3.column.key]
                }), null);
              }
            })
          };
          const rootKls = [props.class, ns.b(), ns.e("root"), {
            [ns.is("dynamic")]: vue.unref(isDynamic)
          }];
          const footerProps = {
            class: ns.e("footer"),
            style: vue.unref(footerHeight)
          };
          return vue.createVNode("div", {
            "class": rootKls,
            "style": vue.unref(rootStyle)
          }, [vue.createVNode(MainTable, mainTableProps, _isSlot(tableSlots) ? tableSlots : {
            default: () => [tableSlots]
          }), vue.createVNode(LeftTable$1, leftTableProps, _isSlot(tableSlots) ? tableSlots : {
            default: () => [tableSlots]
          }), vue.createVNode(LeftTable, rightTableProps, _isSlot(tableSlots) ? tableSlots : {
            default: () => [tableSlots]
          }), slots.footer && vue.createVNode(Footer$1, footerProps, {
            default: slots.footer
          }), vue.unref(showEmpty) && vue.createVNode(Footer, {
            "class": ns.e("empty"),
            "style": vue.unref(emptyStyle)
          }, {
            default: slots.empty
          }), slots.overlay && vue.createVNode(Overlay, {
            "class": ns.e("overlay")
          }, {
            default: slots.overlay
          })]);
        };
      }
    });
    var TableV2$1 = TableV2;
  
    const autoResizerProps = buildProps({
      disableWidth: Boolean,
      disableHeight: Boolean,
      onResize: {
        type: definePropType(Function)
      }
    });
  
    const AutoResizer = vue.defineComponent({
      name: "ElAutoResizer",
      props: autoResizerProps,
      setup(props, {
        slots
      }) {
        const ns = useNamespace("auto-resizer");
        const {
          height,
          width,
          sizer
        } = useAutoResize(props);
        const style = {
          width: "100%",
          height: "100%"
        };
        return () => {
          var _a;
          return vue.createVNode("div", {
            "ref": sizer,
            "class": ns.b(),
            "style": style
          }, [(_a = slots.default) == null ? void 0 : _a.call(slots, {
            height: height.value,
            width: width.value
          })]);
        };
      }
    });
  
    const ElTableV2 = withInstall(TableV2$1);
    const ElAutoResizer = withInstall(AutoResizer);
  
    const tabBarProps = buildProps({
      tabs: {
        type: definePropType(Array),
        default: () => mutable([])
      }
    });
  
    const COMPONENT_NAME$3 = "ElTabBar";
    const __default__$j = vue.defineComponent({
      name: COMPONENT_NAME$3
    });
    const _sfc_main$o = /* @__PURE__ */ vue.defineComponent({
      ...__default__$j,
      props: tabBarProps,
      setup(__props, { expose }) {
        const props = __props;
        const instance = vue.getCurrentInstance();
        const rootTabs = vue.inject(tabsRootContextKey);
        if (!rootTabs)
          throwError(COMPONENT_NAME$3, "<el-tabs><el-tab-bar /></el-tabs>");
        const ns = useNamespace("tabs");
        const barRef = vue.ref();
        const barStyle = vue.ref();
        const getBarStyle = () => {
          let offset = 0;
          let tabSize = 0;
          const sizeName = ["top", "bottom"].includes(rootTabs.props.tabPosition) ? "width" : "height";
          const sizeDir = sizeName === "width" ? "x" : "y";
          props.tabs.every((tab) => {
            var _a, _b, _c, _d;
            const $el = (_b = (_a = instance.parent) == null ? void 0 : _a.refs) == null ? void 0 : _b[`tab-${tab.uid}`];
            if (!$el)
              return false;
            if (!tab.active) {
              return true;
            }
            tabSize = $el[`client${capitalize(sizeName)}`];
            const position = sizeDir === "x" ? "left" : "top";
            offset = $el[`offset${capitalize(position)}`] - ((_d = (_c = $el.parentElement) == null ? void 0 : _c[`offset${capitalize(position)}`]) != null ? _d : 0);
            const scrollwrapEl = $el.closest(".is-scrollable");
            if (scrollwrapEl) {
              const scrollWrapStyle = window.getComputedStyle(scrollwrapEl);
              offset += Number.parseFloat(scrollWrapStyle[`padding${capitalize(position)}`]);
            }
            const tabStyles = window.getComputedStyle($el);
            if (sizeName === "width") {
              if (props.tabs.length > 1) {
                tabSize -= Number.parseFloat(tabStyles.paddingLeft) + Number.parseFloat(tabStyles.paddingRight);
              }
              offset += Number.parseFloat(tabStyles.paddingLeft);
            }
            return false;
          });
          return {
            [sizeName]: `${tabSize}px`,
            transform: `translate${capitalize(sizeDir)}(${offset}px)`
          };
        };
        const update = () => barStyle.value = getBarStyle();
        vue.watch(() => props.tabs, async () => {
          await vue.nextTick();
          update();
        }, { immediate: true });
        useResizeObserver(barRef, () => update());
        expose({
          ref: barRef,
          update
        });
        return (_ctx, _cache) => {
          return vue.openBlock(), vue.createElementBlock("div", {
            ref_key: "barRef",
            ref: barRef,
            class: vue.normalizeClass([vue.unref(ns).e("active-bar"), vue.unref(ns).is(vue.unref(rootTabs).props.tabPosition)]),
            style: vue.normalizeStyle(barStyle.value)
          }, null, 6);
        };
      }
    });
    var TabBar = /* @__PURE__ */ _export_sfc(_sfc_main$o, [["__file", "tab-bar.vue"]]);
  
    const tabNavProps = buildProps({
      panes: {
        type: definePropType(Array),
        default: () => mutable([])
      },
      currentName: {
        type: [String, Number],
        default: ""
      },
      editable: Boolean,
      type: {
        type: String,
        values: ["card", "border-card", ""],
        default: ""
      },
      stretch: Boolean
    });
    const tabNavEmits = {
      tabClick: (tab, tabName, ev) => ev instanceof Event,
      tabRemove: (tab, ev) => ev instanceof Event
    };
    const COMPONENT_NAME$2 = "ElTabNav";
    const TabNav = vue.defineComponent({
      name: COMPONENT_NAME$2,
      props: tabNavProps,
      emits: tabNavEmits,
      setup(props, {
        expose,
        emit
      }) {
        const vm = vue.getCurrentInstance();
        const rootTabs = vue.inject(tabsRootContextKey);
        if (!rootTabs)
          throwError(COMPONENT_NAME$2, `<el-tabs><tab-nav /></el-tabs>`);
        const ns = useNamespace("tabs");
        const visibility = useDocumentVisibility();
        const focused = useWindowFocus();
        const navScroll$ = vue.ref();
        const nav$ = vue.ref();
        const el$ = vue.ref();
        const scrollable = vue.ref(false);
        const navOffset = vue.ref(0);
        const isFocus = vue.ref(false);
        const focusable = vue.ref(true);
        const sizeName = vue.computed(() => ["top", "bottom"].includes(rootTabs.props.tabPosition) ? "width" : "height");
        const navStyle = vue.computed(() => {
          const dir = sizeName.value === "width" ? "X" : "Y";
          return {
            transform: `translate${dir}(-${navOffset.value}px)`
          };
        });
        const scrollPrev = () => {
          if (!navScroll$.value)
            return;
          const containerSize = navScroll$.value[`offset${capitalize(sizeName.value)}`];
          const currentOffset = navOffset.value;
          if (!currentOffset)
            return;
          const newOffset = currentOffset > containerSize ? currentOffset - containerSize : 0;
          navOffset.value = newOffset;
        };
        const scrollNext = () => {
          if (!navScroll$.value || !nav$.value)
            return;
          const navSize = nav$.value[`offset${capitalize(sizeName.value)}`];
          const containerSize = navScroll$.value[`offset${capitalize(sizeName.value)}`];
          const currentOffset = navOffset.value;
          if (navSize - currentOffset <= containerSize)
            return;
          const newOffset = navSize - currentOffset > containerSize * 2 ? currentOffset + containerSize : navSize - containerSize;
          navOffset.value = newOffset;
        };
        const scrollToActiveTab = async () => {
          const nav = nav$.value;
          if (!scrollable.value || !el$.value || !navScroll$.value || !nav)
            return;
          await vue.nextTick();
          const activeTab = el$.value.querySelector(".is-active");
          if (!activeTab)
            return;
          const navScroll = navScroll$.value;
          const isHorizontal = ["top", "bottom"].includes(rootTabs.props.tabPosition);
          const activeTabBounding = activeTab.getBoundingClientRect();
          const navScrollBounding = navScroll.getBoundingClientRect();
          const maxOffset = isHorizontal ? nav.offsetWidth - navScrollBounding.width : nav.offsetHeight - navScrollBounding.height;
          const currentOffset = navOffset.value;
          let newOffset = currentOffset;
          if (isHorizontal) {
            if (activeTabBounding.left < navScrollBounding.left) {
              newOffset = currentOffset - (navScrollBounding.left - activeTabBounding.left);
            }
            if (activeTabBounding.right > navScrollBounding.right) {
              newOffset = currentOffset + activeTabBounding.right - navScrollBounding.right;
            }
          } else {
            if (activeTabBounding.top < navScrollBounding.top) {
              newOffset = currentOffset - (navScrollBounding.top - activeTabBounding.top);
            }
            if (activeTabBounding.bottom > navScrollBounding.bottom) {
              newOffset = currentOffset + (activeTabBounding.bottom - navScrollBounding.bottom);
            }
          }
          newOffset = Math.max(newOffset, 0);
          navOffset.value = Math.min(newOffset, maxOffset);
        };
        const update = () => {
          if (!nav$.value || !navScroll$.value)
            return;
          const navSize = nav$.value[`offset${capitalize(sizeName.value)}`];
          const containerSize = navScroll$.value[`offset${capitalize(sizeName.value)}`];
          const currentOffset = navOffset.value;
          if (containerSize < navSize) {
            const currentOffset2 = navOffset.value;
            scrollable.value = scrollable.value || {};
            scrollable.value.prev = currentOffset2;
            scrollable.value.next = currentOffset2 + containerSize < navSize;
            if (navSize - currentOffset2 < containerSize) {
              navOffset.value = navSize - containerSize;
            }
          } else {
            scrollable.value = false;
            if (currentOffset > 0) {
              navOffset.value = 0;
            }
          }
        };
        const changeTab = (e) => {
          const code = e.code;
          const {
            up,
            down,
            left,
            right
          } = EVENT_CODE;
          if (![up, down, left, right].includes(code))
            return;
          const tabList = Array.from(e.currentTarget.querySelectorAll("[role=tab]:not(.is-disabled)"));
          const currentIndex = tabList.indexOf(e.target);
          let nextIndex;
          if (code === left || code === up) {
            if (currentIndex === 0) {
              nextIndex = tabList.length - 1;
            } else {
              nextIndex = currentIndex - 1;
            }
          } else {
            if (currentIndex < tabList.length - 1) {
              nextIndex = currentIndex + 1;
            } else {
              nextIndex = 0;
            }
          }
          tabList[nextIndex].focus({
            preventScroll: true
          });
          tabList[nextIndex].click();
          setFocus();
        };
        const setFocus = () => {
          if (focusable.value)
            isFocus.value = true;
        };
        const removeFocus = () => isFocus.value = false;
        vue.watch(visibility, (visibility2) => {
          if (visibility2 === "hidden") {
            focusable.value = false;
          } else if (visibility2 === "visible") {
            setTimeout(() => focusable.value = true, 50);
          }
        });
        vue.watch(focused, (focused2) => {
          if (focused2) {
            setTimeout(() => focusable.value = true, 50);
          } else {
            focusable.value = false;
          }
        });
        useResizeObserver(el$, update);
        vue.onMounted(() => setTimeout(() => scrollToActiveTab(), 0));
        vue.onUpdated(() => update());
        expose({
          scrollToActiveTab,
          removeFocus
        });
        vue.watch(() => props.panes, () => vm.update(), {
          flush: "post"
        });
        return () => {
          const scrollBtn = scrollable.value ? [vue.createVNode("span", {
            "class": [ns.e("nav-prev"), ns.is("disabled", !scrollable.value.prev)],
            "onClick": scrollPrev
          }, [vue.createVNode(ElIcon, null, {
            default: () => [vue.createVNode(arrow_left_default, null, null)]
          })]), vue.createVNode("span", {
            "class": [ns.e("nav-next"), ns.is("disabled", !scrollable.value.next)],
            "onClick": scrollNext
          }, [vue.createVNode(ElIcon, null, {
            default: () => [vue.createVNode(arrow_right_default, null, null)]
          })])] : null;
          const tabs = props.panes.map((pane, index) => {
            var _a, _b, _c, _d;
            const uid = pane.uid;
            const disabled = pane.props.disabled;
            const tabName = (_b = (_a = pane.props.name) != null ? _a : pane.index) != null ? _b : `${index}`;
            const closable = !disabled && (pane.isClosable || props.editable);
            pane.index = `${index}`;
            const btnClose = closable ? vue.createVNode(ElIcon, {
              "class": "is-icon-close",
              "onClick": (ev) => emit("tabRemove", pane, ev)
            }, {
              default: () => [vue.createVNode(close_default, null, null)]
            }) : null;
            const tabLabelContent = ((_d = (_c = pane.slots).label) == null ? void 0 : _d.call(_c)) || pane.props.label;
            const tabindex = !disabled && pane.active ? 0 : -1;
            return vue.createVNode("div", {
              "ref": `tab-${uid}`,
              "class": [ns.e("item"), ns.is(rootTabs.props.tabPosition), ns.is("active", pane.active), ns.is("disabled", disabled), ns.is("closable", closable), ns.is("focus", isFocus.value)],
              "id": `tab-${tabName}`,
              "key": `tab-${uid}`,
              "aria-controls": `pane-${tabName}`,
              "role": "tab",
              "aria-selected": pane.active,
              "tabindex": tabindex,
              "onFocus": () => setFocus(),
              "onBlur": () => removeFocus(),
              "onClick": (ev) => {
                removeFocus();
                emit("tabClick", pane, tabName, ev);
              },
              "onKeydown": (ev) => {
                if (closable && (ev.code === EVENT_CODE.delete || ev.code === EVENT_CODE.backspace)) {
                  emit("tabRemove", pane, ev);
                }
              }
            }, [...[tabLabelContent, btnClose]]);
          });
          return vue.createVNode("div", {
            "ref": el$,
            "class": [ns.e("nav-wrap"), ns.is("scrollable", !!scrollable.value), ns.is(rootTabs.props.tabPosition)]
          }, [scrollBtn, vue.createVNode("div", {
            "class": ns.e("nav-scroll"),
            "ref": navScroll$
          }, [vue.createVNode("div", {
            "class": [ns.e("nav"), ns.is(rootTabs.props.tabPosition), ns.is("stretch", props.stretch && ["top", "bottom"].includes(rootTabs.props.tabPosition))],
            "ref": nav$,
            "style": navStyle.value,
            "role": "tablist",
            "onKeydown": changeTab
          }, [...[!props.type ? vue.createVNode(TabBar, {
            "tabs": [...props.panes]
          }, null) : null, tabs]])])]);
        };
      }
    });
  
    const tabsProps = buildProps({
      type: {
        type: String,
        values: ["card", "border-card", ""],
        default: ""
      },
      activeName: {
        type: [String, Number]
      },
      closable: Boolean,
      addable: Boolean,
      modelValue: {
        type: [String, Number]
      },
      editable: Boolean,
      tabPosition: {
        type: String,
        values: ["top", "right", "bottom", "left"],
        default: "top"
      },
      beforeLeave: {
        type: definePropType(Function),
        default: () => true
      },
      stretch: Boolean
    });
    const isPaneName = (value) => isString(value) || isNumber(value);
    const tabsEmits = {
      [UPDATE_MODEL_EVENT]: (name) => isPaneName(name),
      tabClick: (pane, ev) => ev instanceof Event,
      tabChange: (name) => isPaneName(name),
      edit: (paneName, action) => ["remove", "add"].includes(action),
      tabRemove: (name) => isPaneName(name),
      tabAdd: () => true
    };
    var Tabs = vue.defineComponent({
      name: "ElTabs",
      props: tabsProps,
      emits: tabsEmits,
      setup(props, {
        emit,
        slots,
        expose
      }) {
        var _a, _b;
        const ns = useNamespace("tabs");
        const {
          children: panes,
          addChild: registerPane,
          removeChild: unregisterPane
        } = useOrderedChildren(vue.getCurrentInstance(), "ElTabPane");
        const nav$ = vue.ref();
        const currentName = vue.ref((_b = (_a = props.modelValue) != null ? _a : props.activeName) != null ? _b : "0");
        const changeCurrentName = (value) => {
          currentName.value = value;
          emit(UPDATE_MODEL_EVENT, value);
          emit("tabChange", value);
        };
        const setCurrentName = async (value) => {
          var _a2, _b2, _c;
          if (currentName.value === value || isUndefined(value))
            return;
          try {
            const canLeave = await ((_a2 = props.beforeLeave) == null ? void 0 : _a2.call(props, value, currentName.value));
            if (canLeave !== false) {
              changeCurrentName(value);
              (_c = (_b2 = nav$.value) == null ? void 0 : _b2.removeFocus) == null ? void 0 : _c.call(_b2);
            }
          } catch (e) {
          }
        };
        const handleTabClick = (tab, tabName, event) => {
          if (tab.props.disabled)
            return;
          setCurrentName(tabName);
          emit("tabClick", tab, event);
        };
        const handleTabRemove = (pane, ev) => {
          if (pane.props.disabled || isUndefined(pane.props.name))
            return;
          ev.stopPropagation();
          emit("edit", pane.props.name, "remove");
          emit("tabRemove", pane.props.name);
        };
        const handleTabAdd = () => {
          emit("edit", void 0, "add");
          emit("tabAdd");
        };
        useDeprecated({
          from: '"activeName"',
          replacement: '"model-value" or "v-model"',
          scope: "ElTabs",
          version: "2.3.0",
          ref: "https://element-plus.org/en-US/component/tabs.html#attributes",
          type: "Attribute"
        }, vue.computed(() => !!props.activeName));
        vue.watch(() => props.activeName, (modelValue) => setCurrentName(modelValue));
        vue.watch(() => props.modelValue, (modelValue) => setCurrentName(modelValue));
        vue.watch(currentName, async () => {
          var _a2;
          await vue.nextTick();
          (_a2 = nav$.value) == null ? void 0 : _a2.scrollToActiveTab();
        });
        vue.provide(tabsRootContextKey, {
          props,
          currentName,
          registerPane,
          unregisterPane
        });
        expose({
          currentName
        });
        return () => {
          const newButton = props.editable || props.addable ? vue.createVNode("span", {
            "class": ns.e("new-tab"),
            "tabindex": "0",
            "onClick": handleTabAdd,
            "onKeydown": (ev) => {
              if (ev.code === EVENT_CODE.enter)
                handleTabAdd();
            }
          }, [vue.createVNode(ElIcon, {
            "class": ns.is("icon-plus")
          }, {
            default: () => [vue.createVNode(plus_default, null, null)]
          })]) : null;
          const header = vue.createVNode("div", {
            "class": [ns.e("header"), ns.is(props.tabPosition)]
          }, [newButton, vue.createVNode(TabNav, {
            "ref": nav$,
            "currentName": currentName.value,
            "editable": props.editable,
            "type": props.type,
            "panes": panes.value,
            "stretch": props.stretch,
            "onTabClick": handleTabClick,
            "onTabRemove": handleTabRemove
          }, null)]);
          const panels = vue.createVNode("div", {
            "class": ns.e("content")
          }, [vue.renderSlot(slots, "default")]);
          return vue.createVNode("div", {
            "class": [ns.b(), ns.m(props.tabPosition), {
              [ns.m("card")]: props.type === "card",
              [ns.m("border-card")]: props.type === "border-card"
            }]
          }, [...props.tabPosition !== "bottom" ? [header, panels] : [panels, header]]);
        };
      }
    });
  
    const tabPaneProps = buildProps({
      label: {
        type: String,
        default: ""
      },
      name: {
        type: [String, Number]
      },
      closable: Boolean,
      disabled: Boolean,
      lazy: Boolean
    });
  
    const _hoisted_1$a = ["id", "aria-hidden", "aria-labelledby"];
    const COMPONENT_NAME$1 = "ElTabPane";
    const __default__$i = vue.defineComponent({
      name: COMPONENT_NAME$1
    });
    const _sfc_main$n = /* @__PURE__ */ vue.defineComponent({
      ...__default__$i,
      props: tabPaneProps,
      setup(__props) {
        const props = __props;
        const instance = vue.getCurrentInstance();
        const slots = vue.useSlots();
        const tabsRoot = vue.inject(tabsRootContextKey);
        if (!tabsRoot)
          throwError(COMPONENT_NAME$1, "usage: <el-tabs><el-tab-pane /></el-tabs/>");
        const ns = useNamespace("tab-pane");
        const index = vue.ref();
        const isClosable = vue.computed(() => props.closable || tabsRoot.props.closable);
        const active = computedEager(() => {
          var _a;
          return tabsRoot.currentName.value === ((_a = props.name) != null ? _a : index.value);
        });
        const loaded = vue.ref(active.value);
        const paneName = vue.computed(() => {
          var _a;
          return (_a = props.name) != null ? _a : index.value;
        });
        const shouldBeRender = computedEager(() => !props.lazy || loaded.value || active.value);
        vue.watch(active, (val) => {
          if (val)
            loaded.value = true;
        });
        const pane = vue.reactive({
          uid: instance.uid,
          slots,
          props,
          paneName,
          active,
          index,
          isClosable
        });
        vue.onMounted(() => {
          tabsRoot.registerPane(pane);
        });
        vue.onUnmounted(() => {
          tabsRoot.unregisterPane(pane.uid);
        });
        return (_ctx, _cache) => {
          return vue.unref(shouldBeRender) ? vue.withDirectives((vue.openBlock(), vue.createElementBlock("div", {
            key: 0,
            id: `pane-${vue.unref(paneName)}`,
            class: vue.normalizeClass(vue.unref(ns).b()),
            role: "tabpanel",
            "aria-hidden": !vue.unref(active),
            "aria-labelledby": `tab-${vue.unref(paneName)}`
          }, [
            vue.renderSlot(_ctx.$slots, "default")
          ], 10, _hoisted_1$a)), [
            [vue.vShow, vue.unref(active)]
          ]) : vue.createCommentVNode("v-if", true);
        };
      }
    });
    var TabPane = /* @__PURE__ */ _export_sfc(_sfc_main$n, [["__file", "tab-pane.vue"]]);
  
    const ElTabs = withInstall(Tabs, {
      TabPane
    });
    const ElTabPane = withNoopInstall(TabPane);
  
    const timeSelectProps = buildProps({
      format: {
        type: String,
        default: "HH:mm"
      },
      modelValue: String,
      disabled: Boolean,
      editable: {
        type: Boolean,
        default: true
      },
      effect: {
        type: String,
        default: "light"
      },
      clearable: {
        type: Boolean,
        default: true
      },
      size: useSizeProp,
      placeholder: String,
      start: {
        type: String,
        default: "09:00"
      },
      end: {
        type: String,
        default: "18:00"
      },
      step: {
        type: String,
        default: "00:30"
      },
      minTime: String,
      maxTime: String,
      name: String,
      prefixIcon: {
        type: definePropType([String, Object]),
        default: () => clock_default
      },
      clearIcon: {
        type: definePropType([String, Object]),
        default: () => circle_close_default
      }
    });
  
    const parseTime = (time) => {
      const values = (time || "").split(":");
      if (values.length >= 2) {
        let hours = Number.parseInt(values[0], 10);
        const minutes = Number.parseInt(values[1], 10);
        const timeUpper = time.toUpperCase();
        if (timeUpper.includes("AM") && hours === 12) {
          hours = 0;
        } else if (timeUpper.includes("PM") && hours !== 12) {
          hours += 12;
        }
        return {
          hours,
          minutes
        };
      }
      return null;
    };
    const compareTime = (time1, time2) => {
      const value1 = parseTime(time1);
      if (!value1)
        return -1;
      const value2 = parseTime(time2);
      if (!value2)
        return -1;
      const minutes1 = value1.minutes + value1.hours * 60;
      const minutes2 = value2.minutes + value2.hours * 60;
      if (minutes1 === minutes2) {
        return 0;
      }
      return minutes1 > minutes2 ? 1 : -1;
    };
    const padTime = (time) => {
      return `${time}`.padStart(2, "0");
    };
    const formatTime = (time) => {
      return `${padTime(time.hours)}:${padTime(time.minutes)}`;
    };
    const nextTime = (time, step) => {
      const timeValue = parseTime(time);
      if (!timeValue)
        return "";
      const stepValue = parseTime(step);
      if (!stepValue)
        return "";
      const next = {
        hours: timeValue.hours,
        minutes: timeValue.minutes
      };
      next.minutes += stepValue.minutes;
      next.hours += stepValue.hours;
      next.hours += Math.floor(next.minutes / 60);
      next.minutes = next.minutes % 60;
      return formatTime(next);
    };
  
    const __default__$h = vue.defineComponent({
      name: "ElTimeSelect"
    });
    const _sfc_main$m = /* @__PURE__ */ vue.defineComponent({
      ...__default__$h,
      props: timeSelectProps,
      emits: ["change", "blur", "focus", "update:modelValue"],
      setup(__props, { expose }) {
        const props = __props;
        dayjs.extend(customParseFormat);
        const { Option: ElOption } = ElSelect;
        const nsInput = useNamespace("input");
        const select = vue.ref();
        const _disabled = useDisabled();
        const value = vue.computed(() => props.modelValue);
        const start = vue.computed(() => {
          const time = parseTime(props.start);
          return time ? formatTime(time) : null;
        });
        const end = vue.computed(() => {
          const time = parseTime(props.end);
          return time ? formatTime(time) : null;
        });
        const step = vue.computed(() => {
          const time = parseTime(props.step);
          return time ? formatTime(time) : null;
        });
        const minTime = vue.computed(() => {
          const time = parseTime(props.minTime || "");
          return time ? formatTime(time) : null;
        });
        const maxTime = vue.computed(() => {
          const time = parseTime(props.maxTime || "");
          return time ? formatTime(time) : null;
        });
        const items = vue.computed(() => {
          const result = [];
          if (props.start && props.end && props.step) {
            let current = start.value;
            let currentTime;
            while (current && end.value && compareTime(current, end.value) <= 0) {
              currentTime = dayjs(current, "HH:mm").format(props.format);
              result.push({
                value: currentTime,
                disabled: compareTime(current, minTime.value || "-1:-1") <= 0 || compareTime(current, maxTime.value || "100:100") >= 0
              });
              current = nextTime(current, step.value);
            }
          }
          return result;
        });
        const blur = () => {
          var _a, _b;
          (_b = (_a = select.value) == null ? void 0 : _a.blur) == null ? void 0 : _b.call(_a);
        };
        const focus = () => {
          var _a, _b;
          (_b = (_a = select.value) == null ? void 0 : _a.focus) == null ? void 0 : _b.call(_a);
        };
        expose({
          blur,
          focus
        });
        return (_ctx, _cache) => {
          return vue.openBlock(), vue.createBlock(vue.unref(ElSelect), {
            ref_key: "select",
            ref: select,
            "model-value": vue.unref(value),
            disabled: vue.unref(_disabled),
            clearable: _ctx.clearable,
            "clear-icon": _ctx.clearIcon,
            size: _ctx.size,
            effect: _ctx.effect,
            placeholder: _ctx.placeholder,
            "default-first-option": "",
            filterable: _ctx.editable,
            "onUpdate:modelValue": _cache[0] || (_cache[0] = (event) => _ctx.$emit("update:modelValue", event)),
            onChange: _cache[1] || (_cache[1] = (event) => _ctx.$emit("change", event)),
            onBlur: _cache[2] || (_cache[2] = (event) => _ctx.$emit("blur", event)),
            onFocus: _cache[3] || (_cache[3] = (event) => _ctx.$emit("focus", event))
          }, {
            prefix: vue.withCtx(() => [
              _ctx.prefixIcon ? (vue.openBlock(), vue.createBlock(vue.unref(ElIcon), {
                key: 0,
                class: vue.normalizeClass(vue.unref(nsInput).e("prefix-icon"))
              }, {
                default: vue.withCtx(() => [
                  (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(_ctx.prefixIcon)))
                ]),
                _: 1
              }, 8, ["class"])) : vue.createCommentVNode("v-if", true)
            ]),
            default: vue.withCtx(() => [
              (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(vue.unref(items), (item) => {
                return vue.openBlock(), vue.createBlock(vue.unref(ElOption), {
                  key: item.value,
                  label: item.value,
                  value: item.value,
                  disabled: item.disabled
                }, null, 8, ["label", "value", "disabled"]);
              }), 128))
            ]),
            _: 1
          }, 8, ["model-value", "disabled", "clearable", "clear-icon", "size", "effect", "placeholder", "filterable"]);
        };
      }
    });
    var TimeSelect = /* @__PURE__ */ _export_sfc(_sfc_main$m, [["__file", "time-select.vue"]]);
  
    TimeSelect.install = (app) => {
      app.component(TimeSelect.name, TimeSelect);
    };
    const _TimeSelect = TimeSelect;
    const ElTimeSelect = _TimeSelect;
  
    const Timeline = vue.defineComponent({
      name: "ElTimeline",
      setup(_, { slots }) {
        const ns = useNamespace("timeline");
        vue.provide("timeline", slots);
        return () => {
          return vue.h("ul", { class: [ns.b()] }, [vue.renderSlot(slots, "default")]);
        };
      }
    });
    var Timeline$1 = Timeline;
  
    const timelineItemProps = buildProps({
      timestamp: {
        type: String,
        default: ""
      },
      hideTimestamp: {
        type: Boolean,
        default: false
      },
      center: {
        type: Boolean,
        default: false
      },
      placement: {
        type: String,
        values: ["top", "bottom"],
        default: "bottom"
      },
      type: {
        type: String,
        values: ["primary", "success", "warning", "danger", "info"],
        default: ""
      },
      color: {
        type: String,
        default: ""
      },
      size: {
        type: String,
        values: ["normal", "large"],
        default: "normal"
      },
      icon: {
        type: iconPropType
      },
      hollow: {
        type: Boolean,
        default: false
      }
    });
  
    const __default__$g = vue.defineComponent({
      name: "ElTimelineItem"
    });
    const _sfc_main$l = /* @__PURE__ */ vue.defineComponent({
      ...__default__$g,
      props: timelineItemProps,
      setup(__props) {
        const ns = useNamespace("timeline-item");
        return (_ctx, _cache) => {
          return vue.openBlock(), vue.createElementBlock("li", {
            class: vue.normalizeClass([vue.unref(ns).b(), { [vue.unref(ns).e("center")]: _ctx.center }])
          }, [
            vue.createElementVNode("div", {
              class: vue.normalizeClass(vue.unref(ns).e("tail"))
            }, null, 2),
            !_ctx.$slots.dot ? (vue.openBlock(), vue.createElementBlock("div", {
              key: 0,
              class: vue.normalizeClass([
                vue.unref(ns).e("node"),
                vue.unref(ns).em("node", _ctx.size || ""),
                vue.unref(ns).em("node", _ctx.type || ""),
                vue.unref(ns).is("hollow", _ctx.hollow)
              ]),
              style: vue.normalizeStyle({
                backgroundColor: _ctx.color
              })
            }, [
              _ctx.icon ? (vue.openBlock(), vue.createBlock(vue.unref(ElIcon), {
                key: 0,
                class: vue.normalizeClass(vue.unref(ns).e("icon"))
              }, {
                default: vue.withCtx(() => [
                  (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(_ctx.icon)))
                ]),
                _: 1
              }, 8, ["class"])) : vue.createCommentVNode("v-if", true)
            ], 6)) : vue.createCommentVNode("v-if", true),
            _ctx.$slots.dot ? (vue.openBlock(), vue.createElementBlock("div", {
              key: 1,
              class: vue.normalizeClass(vue.unref(ns).e("dot"))
            }, [
              vue.renderSlot(_ctx.$slots, "dot")
            ], 2)) : vue.createCommentVNode("v-if", true),
            vue.createElementVNode("div", {
              class: vue.normalizeClass(vue.unref(ns).e("wrapper"))
            }, [
              !_ctx.hideTimestamp && _ctx.placement === "top" ? (vue.openBlock(), vue.createElementBlock("div", {
                key: 0,
                class: vue.normalizeClass([vue.unref(ns).e("timestamp"), vue.unref(ns).is("top")])
              }, vue.toDisplayString(_ctx.timestamp), 3)) : vue.createCommentVNode("v-if", true),
              vue.createElementVNode("div", {
                class: vue.normalizeClass(vue.unref(ns).e("content"))
              }, [
                vue.renderSlot(_ctx.$slots, "default")
              ], 2),
              !_ctx.hideTimestamp && _ctx.placement === "bottom" ? (vue.openBlock(), vue.createElementBlock("div", {
                key: 1,
                class: vue.normalizeClass([vue.unref(ns).e("timestamp"), vue.unref(ns).is("bottom")])
              }, vue.toDisplayString(_ctx.timestamp), 3)) : vue.createCommentVNode("v-if", true)
            ], 2)
          ], 2);
        };
      }
    });
    var TimelineItem = /* @__PURE__ */ _export_sfc(_sfc_main$l, [["__file", "timeline-item.vue"]]);
  
    const ElTimeline = withInstall(Timeline$1, {
      TimelineItem
    });
    const ElTimelineItem = withNoopInstall(TimelineItem);
  
    const tooltipV2CommonProps = buildProps({
      nowrap: Boolean
    });
    var TooltipV2Sides = /* @__PURE__ */ ((TooltipV2Sides2) => {
      TooltipV2Sides2["top"] = "top";
      TooltipV2Sides2["bottom"] = "bottom";
      TooltipV2Sides2["left"] = "left";
      TooltipV2Sides2["right"] = "right";
      return TooltipV2Sides2;
    })(TooltipV2Sides || {});
    const tooltipV2Sides = Object.values(TooltipV2Sides);
  
    const tooltipV2ArrowProps = buildProps({
      width: {
        type: Number,
        default: 10
      },
      height: {
        type: Number,
        default: 10
      },
      style: {
        type: definePropType(Object),
        default: null
      }
    });
    const tooltipV2ArrowSpecialProps = buildProps({
      side: {
        type: definePropType(String),
        values: tooltipV2Sides,
        required: true
      }
    });
  
    const tooltipV2Strategies = ["absolute", "fixed"];
    const tooltipV2Placements = [
      "top-start",
      "top-end",
      "top",
      "bottom-start",
      "bottom-end",
      "bottom",
      "left-start",
      "left-end",
      "left",
      "right-start",
      "right-end",
      "right"
    ];
    const tooltipV2ContentProps = buildProps({
      ariaLabel: String,
      arrowPadding: {
        type: definePropType(Number),
        default: 5
      },
      effect: {
        type: String,
        default: ""
      },
      contentClass: String,
      placement: {
        type: definePropType(String),
        values: tooltipV2Placements,
        default: "bottom"
      },
      reference: {
        type: definePropType(Object),
        default: null
      },
      offset: {
        type: Number,
        default: 8
      },
      strategy: {
        type: definePropType(String),
        values: tooltipV2Strategies,
        default: "absolute"
      },
      showArrow: {
        type: Boolean,
        default: false
      }
    });
  
    const tooltipV2RootProps = buildProps({
      delayDuration: {
        type: Number,
        default: 300
      },
      defaultOpen: Boolean,
      open: {
        type: Boolean,
        default: void 0
      },
      onOpenChange: {
        type: definePropType(Function)
      },
      "onUpdate:open": {
        type: definePropType(Function)
      }
    });
  
    const EventHandler = {
      type: definePropType(Function)
    };
    const tooltipV2TriggerProps = buildProps({
      onBlur: EventHandler,
      onClick: EventHandler,
      onFocus: EventHandler,
      onMouseDown: EventHandler,
      onMouseEnter: EventHandler,
      onMouseLeave: EventHandler
    });
  
    const tooltipV2Props = buildProps({
      ...tooltipV2RootProps,
      ...tooltipV2ArrowProps,
      ...tooltipV2TriggerProps,
      ...tooltipV2ContentProps,
      alwaysOn: Boolean,
      fullTransition: Boolean,
      transitionProps: {
        type: definePropType(Object),
        default: null
      },
      teleported: Boolean,
      to: {
        type: definePropType(String),
        default: "body"
      }
    });
  
    const __default__$f = vue.defineComponent({
      name: "ElTooltipV2Root"
    });
    const _sfc_main$k = /* @__PURE__ */ vue.defineComponent({
      ...__default__$f,
      props: tooltipV2RootProps,
      setup(__props, { expose }) {
        const props = __props;
        const _open = vue.ref(props.defaultOpen);
        const triggerRef = vue.ref(null);
        const open = vue.computed({
          get: () => isPropAbsent(props.open) ? _open.value : props.open,
          set: (open2) => {
            var _a;
            _open.value = open2;
            (_a = props["onUpdate:open"]) == null ? void 0 : _a.call(props, open2);
          }
        });
        const isOpenDelayed = vue.computed(() => isNumber(props.delayDuration) && props.delayDuration > 0);
        const { start: onDelayedOpen, stop: clearTimer } = useTimeoutFn(() => {
          open.value = true;
        }, vue.computed(() => props.delayDuration), {
          immediate: false
        });
        const ns = useNamespace("tooltip-v2");
        const contentId = useId();
        const onNormalOpen = () => {
          clearTimer();
          open.value = true;
        };
        const onDelayOpen = () => {
          vue.unref(isOpenDelayed) ? onDelayedOpen() : onNormalOpen();
        };
        const onOpen = onNormalOpen;
        const onClose = () => {
          clearTimer();
          open.value = false;
        };
        const onChange = (open2) => {
          var _a;
          if (open2) {
            document.dispatchEvent(new CustomEvent(TOOLTIP_V2_OPEN));
            onOpen();
          }
          (_a = props.onOpenChange) == null ? void 0 : _a.call(props, open2);
        };
        vue.watch(open, onChange);
        vue.onMounted(() => {
          document.addEventListener(TOOLTIP_V2_OPEN, onClose);
        });
        vue.onBeforeUnmount(() => {
          clearTimer();
          document.removeEventListener(TOOLTIP_V2_OPEN, onClose);
        });
        vue.provide(tooltipV2RootKey, {
          contentId,
          triggerRef,
          ns,
          onClose,
          onDelayOpen,
          onOpen
        });
        expose({
          onOpen,
          onClose
        });
        return (_ctx, _cache) => {
          return vue.renderSlot(_ctx.$slots, "default", { open: vue.unref(open) });
        };
      }
    });
    var TooltipV2Root = /* @__PURE__ */ _export_sfc(_sfc_main$k, [["__file", "root.vue"]]);
  
    const __default__$e = vue.defineComponent({
      name: "ElTooltipV2Arrow"
    });
    const _sfc_main$j = /* @__PURE__ */ vue.defineComponent({
      ...__default__$e,
      props: {
        ...tooltipV2ArrowProps,
        ...tooltipV2ArrowSpecialProps
      },
      setup(__props) {
        const props = __props;
        const { ns } = vue.inject(tooltipV2RootKey);
        const { arrowRef } = vue.inject(tooltipV2ContentKey);
        const arrowStyle = vue.computed(() => {
          const { style, width, height } = props;
          const namespace = ns.namespace.value;
          return {
            [`--${namespace}-tooltip-v2-arrow-width`]: `${width}px`,
            [`--${namespace}-tooltip-v2-arrow-height`]: `${height}px`,
            [`--${namespace}-tooltip-v2-arrow-border-width`]: `${width / 2}px`,
            [`--${namespace}-tooltip-v2-arrow-cover-width`]: width / 2 - 1,
            ...style || {}
          };
        });
        return (_ctx, _cache) => {
          return vue.openBlock(), vue.createElementBlock("span", {
            ref_key: "arrowRef",
            ref: arrowRef,
            style: vue.normalizeStyle(vue.unref(arrowStyle)),
            class: vue.normalizeClass(vue.unref(ns).e("arrow"))
          }, null, 6);
        };
      }
    });
    var TooltipV2Arrow = /* @__PURE__ */ _export_sfc(_sfc_main$j, [["__file", "arrow.vue"]]);
  
    const visualHiddenProps = buildProps({
      style: {
        type: definePropType([String, Object, Array]),
        default: () => ({})
      }
    });
  
    const __default__$d = vue.defineComponent({
      name: "ElVisuallyHidden"
    });
    const _sfc_main$i = /* @__PURE__ */ vue.defineComponent({
      ...__default__$d,
      props: visualHiddenProps,
      setup(__props) {
        const props = __props;
        const computedStyle = vue.computed(() => {
          return [
            props.style,
            {
              position: "absolute",
              border: 0,
              width: 1,
              height: 1,
              padding: 0,
              margin: -1,
              overflow: "hidden",
              clip: "rect(0, 0, 0, 0)",
              whiteSpace: "nowrap",
              wordWrap: "normal"
            }
          ];
        });
        return (_ctx, _cache) => {
          return vue.openBlock(), vue.createElementBlock("span", vue.mergeProps(_ctx.$attrs, { style: vue.unref(computedStyle) }), [
            vue.renderSlot(_ctx.$slots, "default")
          ], 16);
        };
      }
    });
    var ElVisuallyHidden = /* @__PURE__ */ _export_sfc(_sfc_main$i, [["__file", "visual-hidden.vue"]]);
  
    const _hoisted_1$9 = ["data-side"];
    const __default__$c = vue.defineComponent({
      name: "ElTooltipV2Content"
    });
    const _sfc_main$h = /* @__PURE__ */ vue.defineComponent({
      ...__default__$c,
      props: { ...tooltipV2ContentProps, ...tooltipV2CommonProps },
      setup(__props) {
        const props = __props;
        const { triggerRef, contentId } = vue.inject(tooltipV2RootKey);
        const placement = vue.ref(props.placement);
        const strategy = vue.ref(props.strategy);
        const arrowRef = vue.ref(null);
        const { referenceRef, contentRef, middlewareData, x, y, update } = useFloating({
          placement,
          strategy,
          middleware: vue.computed(() => {
            const middleware = [offset(props.offset)];
            if (props.showArrow) {
              middleware.push(arrowMiddleware({
                arrowRef
              }));
            }
            return middleware;
          })
        });
        const zIndex = useZIndex().nextZIndex();
        const ns = useNamespace("tooltip-v2");
        const side = vue.computed(() => {
          return placement.value.split("-")[0];
        });
        const contentStyle = vue.computed(() => {
          return {
            position: vue.unref(strategy),
            top: `${vue.unref(y) || 0}px`,
            left: `${vue.unref(x) || 0}px`,
            zIndex
          };
        });
        const arrowStyle = vue.computed(() => {
          if (!props.showArrow)
            return {};
          const { arrow } = vue.unref(middlewareData);
          return {
            [`--${ns.namespace.value}-tooltip-v2-arrow-x`]: `${arrow == null ? void 0 : arrow.x}px` || "",
            [`--${ns.namespace.value}-tooltip-v2-arrow-y`]: `${arrow == null ? void 0 : arrow.y}px` || ""
          };
        });
        const contentClass = vue.computed(() => [
          ns.e("content"),
          ns.is("dark", props.effect === "dark"),
          ns.is(vue.unref(strategy)),
          props.contentClass
        ]);
        vue.watch(arrowRef, () => update());
        vue.watch(() => props.placement, (val) => placement.value = val);
        vue.onMounted(() => {
          vue.watch(() => props.reference || triggerRef.value, (el) => {
            referenceRef.value = el || void 0;
          }, {
            immediate: true
          });
        });
        vue.provide(tooltipV2ContentKey, { arrowRef });
        return (_ctx, _cache) => {
          return vue.openBlock(), vue.createElementBlock("div", {
            ref_key: "contentRef",
            ref: contentRef,
            style: vue.normalizeStyle(vue.unref(contentStyle)),
            "data-tooltip-v2-root": ""
          }, [
            !_ctx.nowrap ? (vue.openBlock(), vue.createElementBlock("div", {
              key: 0,
              "data-side": vue.unref(side),
              class: vue.normalizeClass(vue.unref(contentClass))
            }, [
              vue.renderSlot(_ctx.$slots, "default", {
                contentStyle: vue.unref(contentStyle),
                contentClass: vue.unref(contentClass)
              }),
              vue.createVNode(vue.unref(ElVisuallyHidden), {
                id: vue.unref(contentId),
                role: "tooltip"
              }, {
                default: vue.withCtx(() => [
                  _ctx.ariaLabel ? (vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: 0 }, [
                    vue.createTextVNode(vue.toDisplayString(_ctx.ariaLabel), 1)
                  ], 64)) : vue.renderSlot(_ctx.$slots, "default", { key: 1 })
                ]),
                _: 3
              }, 8, ["id"]),
              vue.renderSlot(_ctx.$slots, "arrow", {
                style: vue.normalizeStyle(vue.unref(arrowStyle)),
                side: vue.unref(side)
              })
            ], 10, _hoisted_1$9)) : vue.createCommentVNode("v-if", true)
          ], 4);
        };
      }
    });
    var TooltipV2Content = /* @__PURE__ */ _export_sfc(_sfc_main$h, [["__file", "content.vue"]]);
  
    const forwardRefProps = buildProps({
      setRef: {
        type: definePropType(Function),
        required: true
      },
      onlyChild: Boolean
    });
    var ForwardRef = vue.defineComponent({
      props: forwardRefProps,
      setup(props, {
        slots
      }) {
        const fragmentRef = vue.ref();
        const setRef = composeRefs(fragmentRef, (el) => {
          if (el) {
            props.setRef(el.nextElementSibling);
          } else {
            props.setRef(null);
          }
        });
        return () => {
          var _a;
          const [firstChild] = ((_a = slots.default) == null ? void 0 : _a.call(slots)) || [];
          const child = props.onlyChild ? ensureOnlyChild(firstChild.children) : firstChild.children;
          return vue.createVNode(vue.Fragment, {
            "ref": setRef
          }, [child]);
        };
      }
    });
  
    const __default__$b = vue.defineComponent({
      name: "ElTooltipV2Trigger"
    });
    const _sfc_main$g = /* @__PURE__ */ vue.defineComponent({
      ...__default__$b,
      props: {
        ...tooltipV2CommonProps,
        ...tooltipV2TriggerProps
      },
      setup(__props) {
        const props = __props;
        const { onClose, onOpen, onDelayOpen, triggerRef, contentId } = vue.inject(tooltipV2RootKey);
        let isMousedown = false;
        const setTriggerRef = (el) => {
          triggerRef.value = el;
        };
        const onMouseup = () => {
          isMousedown = false;
        };
        const onMouseenter = composeEventHandlers(props.onMouseEnter, onDelayOpen);
        const onMouseleave = composeEventHandlers(props.onMouseLeave, onClose);
        const onMousedown = composeEventHandlers(props.onMouseDown, () => {
          onClose();
          isMousedown = true;
          document.addEventListener("mouseup", onMouseup, { once: true });
        });
        const onFocus = composeEventHandlers(props.onFocus, () => {
          if (!isMousedown)
            onOpen();
        });
        const onBlur = composeEventHandlers(props.onBlur, onClose);
        const onClick = composeEventHandlers(props.onClick, (e) => {
          if (e.detail === 0)
            onClose();
        });
        const events = {
          blur: onBlur,
          click: onClick,
          focus: onFocus,
          mousedown: onMousedown,
          mouseenter: onMouseenter,
          mouseleave: onMouseleave
        };
        const setEvents = (el, events2, type) => {
          if (el) {
            Object.entries(events2).forEach(([name, handler]) => {
              el[type](name, handler);
            });
          }
        };
        vue.watch(triggerRef, (triggerEl, previousTriggerEl) => {
          setEvents(triggerEl, events, "addEventListener");
          setEvents(previousTriggerEl, events, "removeEventListener");
          if (triggerEl) {
            triggerEl.setAttribute("aria-describedby", contentId.value);
          }
        });
        vue.onBeforeUnmount(() => {
          setEvents(triggerRef.value, events, "removeEventListener");
          document.removeEventListener("mouseup", onMouseup);
        });
        return (_ctx, _cache) => {
          return _ctx.nowrap ? (vue.openBlock(), vue.createBlock(vue.unref(ForwardRef), {
            key: 0,
            "set-ref": setTriggerRef,
            "only-child": ""
          }, {
            default: vue.withCtx(() => [
              vue.renderSlot(_ctx.$slots, "default")
            ]),
            _: 3
          })) : (vue.openBlock(), vue.createElementBlock("button", vue.mergeProps({
            key: 1,
            ref_key: "triggerRef",
            ref: triggerRef
          }, _ctx.$attrs), [
            vue.renderSlot(_ctx.$slots, "default")
          ], 16));
        };
      }
    });
    var TooltipV2Trigger = /* @__PURE__ */ _export_sfc(_sfc_main$g, [["__file", "trigger.vue"]]);
  
    const __default__$a = vue.defineComponent({
      name: "ElTooltipV2"
    });
    const _sfc_main$f = /* @__PURE__ */ vue.defineComponent({
      ...__default__$a,
      props: tooltipV2Props,
      setup(__props) {
        const props = __props;
        const refedProps = vue.toRefs(props);
        const arrowProps = vue.reactive(pick(refedProps, Object.keys(tooltipV2ArrowProps)));
        const contentProps = vue.reactive(pick(refedProps, Object.keys(tooltipV2ContentProps)));
        const rootProps = vue.reactive(pick(refedProps, Object.keys(tooltipV2RootProps)));
        const triggerProps = vue.reactive(pick(refedProps, Object.keys(tooltipV2TriggerProps)));
        return (_ctx, _cache) => {
          return vue.openBlock(), vue.createBlock(TooltipV2Root, vue.normalizeProps(vue.guardReactiveProps(rootProps)), {
            default: vue.withCtx(({ open }) => [
              vue.createVNode(TooltipV2Trigger, vue.mergeProps(triggerProps, { nowrap: "" }), {
                default: vue.withCtx(() => [
                  vue.renderSlot(_ctx.$slots, "trigger")
                ]),
                _: 3
              }, 16),
              (vue.openBlock(), vue.createBlock(vue.Teleport, {
                to: _ctx.to,
                disabled: !_ctx.teleported
              }, [
                _ctx.fullTransition ? (vue.openBlock(), vue.createBlock(vue.Transition, vue.normalizeProps(vue.mergeProps({ key: 0 }, _ctx.transitionProps)), {
                  default: vue.withCtx(() => [
                    _ctx.alwaysOn || open ? (vue.openBlock(), vue.createBlock(TooltipV2Content, vue.normalizeProps(vue.mergeProps({ key: 0 }, contentProps)), {
                      arrow: vue.withCtx(({ style, side }) => [
                        _ctx.showArrow ? (vue.openBlock(), vue.createBlock(TooltipV2Arrow, vue.mergeProps({ key: 0 }, arrowProps, {
                          style,
                          side
                        }), null, 16, ["style", "side"])) : vue.createCommentVNode("v-if", true)
                      ]),
                      default: vue.withCtx(() => [
                        vue.renderSlot(_ctx.$slots, "default")
                      ]),
                      _: 3
                    }, 16)) : vue.createCommentVNode("v-if", true)
                  ]),
                  _: 2
                }, 1040)) : (vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: 1 }, [
                  _ctx.alwaysOn || open ? (vue.openBlock(), vue.createBlock(TooltipV2Content, vue.normalizeProps(vue.mergeProps({ key: 0 }, contentProps)), {
                    arrow: vue.withCtx(({ style, side }) => [
                      _ctx.showArrow ? (vue.openBlock(), vue.createBlock(TooltipV2Arrow, vue.mergeProps({ key: 0 }, arrowProps, {
                        style,
                        side
                      }), null, 16, ["style", "side"])) : vue.createCommentVNode("v-if", true)
                    ]),
                    default: vue.withCtx(() => [
                      vue.renderSlot(_ctx.$slots, "default")
                    ]),
                    _: 3
                  }, 16)) : vue.createCommentVNode("v-if", true)
                ], 64))
              ], 8, ["to", "disabled"]))
            ]),
            _: 3
          }, 16);
        };
      }
    });
    var TooltipV2 = /* @__PURE__ */ _export_sfc(_sfc_main$f, [["__file", "tooltip.vue"]]);
  
    const ElTooltipV2 = withInstall(TooltipV2);
  
    const LEFT_CHECK_CHANGE_EVENT = "left-check-change";
    const RIGHT_CHECK_CHANGE_EVENT = "right-check-change";
    const transferProps = buildProps({
      data: {
        type: definePropType(Array),
        default: () => []
      },
      titles: {
        type: definePropType(Array),
        default: () => []
      },
      buttonTexts: {
        type: definePropType(Array),
        default: () => []
      },
      filterPlaceholder: String,
      filterMethod: {
        type: definePropType(Function)
      },
      leftDefaultChecked: {
        type: definePropType(Array),
        default: () => []
      },
      rightDefaultChecked: {
        type: definePropType(Array),
        default: () => []
      },
      renderContent: {
        type: definePropType(Function)
      },
      modelValue: {
        type: definePropType(Array),
        default: () => []
      },
      format: {
        type: definePropType(Object),
        default: () => ({})
      },
      filterable: Boolean,
      props: {
        type: definePropType(Object),
        default: () => mutable({
          label: "label",
          key: "key",
          disabled: "disabled"
        })
      },
      targetOrder: {
        type: String,
        values: ["original", "push", "unshift"],
        default: "original"
      },
      validateEvent: {
        type: Boolean,
        default: true
      }
    });
    const transferCheckedChangeFn = (value, movedKeys) => [value, movedKeys].every(isArray) || isArray(value) && isNil(movedKeys);
    const transferEmits = {
      [CHANGE_EVENT]: (value, direction, movedKeys) => [value, movedKeys].every(isArray) && ["left", "right"].includes(direction),
      [UPDATE_MODEL_EVENT]: (value) => isArray(value),
      [LEFT_CHECK_CHANGE_EVENT]: transferCheckedChangeFn,
      [RIGHT_CHECK_CHANGE_EVENT]: transferCheckedChangeFn
    };
  
    const CHECKED_CHANGE_EVENT = "checked-change";
    const transferPanelProps = buildProps({
      data: transferProps.data,
      optionRender: {
        type: definePropType(Function)
      },
      placeholder: String,
      title: String,
      filterable: Boolean,
      format: transferProps.format,
      filterMethod: transferProps.filterMethod,
      defaultChecked: transferProps.leftDefaultChecked,
      props: transferProps.props
    });
    const transferPanelEmits = {
      [CHECKED_CHANGE_EVENT]: transferCheckedChangeFn
    };
  
    const usePropsAlias = (props) => {
      const initProps = {
        label: "label",
        key: "key",
        disabled: "disabled"
      };
      return vue.computed(() => ({
        ...initProps,
        ...props.props
      }));
    };
  
    const useCheck$1 = (props, panelState, emit) => {
      const propsAlias = usePropsAlias(props);
      const filteredData = vue.computed(() => {
        return props.data.filter((item) => {
          if (isFunction(props.filterMethod)) {
            return props.filterMethod(panelState.query, item);
          } else {
            const label = String(item[propsAlias.value.label] || item[propsAlias.value.key]);
            return label.toLowerCase().includes(panelState.query.toLowerCase());
          }
        });
      });
      const checkableData = vue.computed(() => filteredData.value.filter((item) => !item[propsAlias.value.disabled]));
      const checkedSummary = vue.computed(() => {
        const checkedLength = panelState.checked.length;
        const dataLength = props.data.length;
        const { noChecked, hasChecked } = props.format;
        if (noChecked && hasChecked) {
          return checkedLength > 0 ? hasChecked.replace(/\${checked}/g, checkedLength.toString()).replace(/\${total}/g, dataLength.toString()) : noChecked.replace(/\${total}/g, dataLength.toString());
        } else {
          return `${checkedLength}/${dataLength}`;
        }
      });
      const isIndeterminate = vue.computed(() => {
        const checkedLength = panelState.checked.length;
        return checkedLength > 0 && checkedLength < checkableData.value.length;
      });
      const updateAllChecked = () => {
        const checkableDataKeys = checkableData.value.map((item) => item[propsAlias.value.key]);
        panelState.allChecked = checkableDataKeys.length > 0 && checkableDataKeys.every((item) => panelState.checked.includes(item));
      };
      const handleAllCheckedChange = (value) => {
        panelState.checked = value ? checkableData.value.map((item) => item[propsAlias.value.key]) : [];
      };
      vue.watch(() => panelState.checked, (val, oldVal) => {
        updateAllChecked();
        if (panelState.checkChangeByUser) {
          const movedKeys = val.concat(oldVal).filter((v) => !val.includes(v) || !oldVal.includes(v));
          emit(CHECKED_CHANGE_EVENT, val, movedKeys);
        } else {
          emit(CHECKED_CHANGE_EVENT, val);
          panelState.checkChangeByUser = true;
        }
      });
      vue.watch(checkableData, () => {
        updateAllChecked();
      });
      vue.watch(() => props.data, () => {
        const checked = [];
        const filteredDataKeys = filteredData.value.map((item) => item[propsAlias.value.key]);
        panelState.checked.forEach((item) => {
          if (filteredDataKeys.includes(item)) {
            checked.push(item);
          }
        });
        panelState.checkChangeByUser = false;
        panelState.checked = checked;
      });
      vue.watch(() => props.defaultChecked, (val, oldVal) => {
        if (oldVal && val.length === oldVal.length && val.every((item) => oldVal.includes(item)))
          return;
        const checked = [];
        const checkableDataKeys = checkableData.value.map((item) => item[propsAlias.value.key]);
        val.forEach((item) => {
          if (checkableDataKeys.includes(item)) {
            checked.push(item);
          }
        });
        panelState.checkChangeByUser = false;
        panelState.checked = checked;
      }, {
        immediate: true
      });
      return {
        filteredData,
        checkableData,
        checkedSummary,
        isIndeterminate,
        updateAllChecked,
        handleAllCheckedChange
      };
    };
  
    const useCheckedChange = (checkedState, emit) => {
      const onSourceCheckedChange = (val, movedKeys) => {
        checkedState.leftChecked = val;
        if (!movedKeys)
          return;
        emit(LEFT_CHECK_CHANGE_EVENT, val, movedKeys);
      };
      const onTargetCheckedChange = (val, movedKeys) => {
        checkedState.rightChecked = val;
        if (!movedKeys)
          return;
        emit(RIGHT_CHECK_CHANGE_EVENT, val, movedKeys);
      };
      return {
        onSourceCheckedChange,
        onTargetCheckedChange
      };
    };
  
    const useComputedData = (props) => {
      const propsAlias = usePropsAlias(props);
      const dataObj = vue.computed(() => props.data.reduce((o, cur) => (o[cur[propsAlias.value.key]] = cur) && o, {}));
      const sourceData = vue.computed(() => props.data.filter((item) => !props.modelValue.includes(item[propsAlias.value.key])));
      const targetData = vue.computed(() => {
        if (props.targetOrder === "original") {
          return props.data.filter((item) => props.modelValue.includes(item[propsAlias.value.key]));
        } else {
          return props.modelValue.reduce((arr, cur) => {
            const val = dataObj.value[cur];
            if (val) {
              arr.push(val);
            }
            return arr;
          }, []);
        }
      });
      return {
        sourceData,
        targetData
      };
    };
  
    const useMove = (props, checkedState, emit) => {
      const propsAlias = usePropsAlias(props);
      const _emit = (value, direction, movedKeys) => {
        emit(UPDATE_MODEL_EVENT, value);
        emit(CHANGE_EVENT, value, direction, movedKeys);
      };
      const addToLeft = () => {
        const currentValue = props.modelValue.slice();
        checkedState.rightChecked.forEach((item) => {
          const index = currentValue.indexOf(item);
          if (index > -1) {
            currentValue.splice(index, 1);
          }
        });
        _emit(currentValue, "left", checkedState.rightChecked);
      };
      const addToRight = () => {
        let currentValue = props.modelValue.slice();
        const itemsToBeMoved = props.data.filter((item) => {
          const itemKey = item[propsAlias.value.key];
          return checkedState.leftChecked.includes(itemKey) && !props.modelValue.includes(itemKey);
        }).map((item) => item[propsAlias.value.key]);
        currentValue = props.targetOrder === "unshift" ? itemsToBeMoved.concat(currentValue) : currentValue.concat(itemsToBeMoved);
        if (props.targetOrder === "original") {
          currentValue = props.data.filter((item) => currentValue.includes(item[propsAlias.value.key])).map((item) => item[propsAlias.value.key]);
        }
        _emit(currentValue, "right", checkedState.leftChecked);
      };
      return {
        addToLeft,
        addToRight
      };
    };
  
    const __default__$9 = vue.defineComponent({
      name: "ElTransferPanel"
    });
    const _sfc_main$e = /* @__PURE__ */ vue.defineComponent({
      ...__default__$9,
      props: transferPanelProps,
      emits: transferPanelEmits,
      setup(__props, { expose, emit }) {
        const props = __props;
        const slots = vue.useSlots();
        const OptionContent = ({ option }) => option;
        const { t } = useLocale();
        const ns = useNamespace("transfer");
        const panelState = vue.reactive({
          checked: [],
          allChecked: false,
          query: "",
          inputHover: false,
          checkChangeByUser: true
        });
        const propsAlias = usePropsAlias(props);
        const {
          filteredData,
          checkedSummary,
          isIndeterminate,
          handleAllCheckedChange
        } = useCheck$1(props, panelState, emit);
        const hasNoMatch = vue.computed(() => !isEmpty(panelState.query) && isEmpty(filteredData.value));
        const hasFooter = vue.computed(() => !isEmpty(slots.default()[0].children));
        const { checked, allChecked, query, inputHover } = vue.toRefs(panelState);
        expose({
          query
        });
        return (_ctx, _cache) => {
          return vue.openBlock(), vue.createElementBlock("div", {
            class: vue.normalizeClass(vue.unref(ns).b("panel"))
          }, [
            vue.createElementVNode("p", {
              class: vue.normalizeClass(vue.unref(ns).be("panel", "header"))
            }, [
              vue.createVNode(vue.unref(ElCheckbox), {
                modelValue: vue.unref(allChecked),
                "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => vue.isRef(allChecked) ? allChecked.value = $event : null),
                indeterminate: vue.unref(isIndeterminate),
                "validate-event": false,
                onChange: vue.unref(handleAllCheckedChange)
              }, {
                default: vue.withCtx(() => [
                  vue.createTextVNode(vue.toDisplayString(_ctx.title) + " ", 1),
                  vue.createElementVNode("span", null, vue.toDisplayString(vue.unref(checkedSummary)), 1)
                ]),
                _: 1
              }, 8, ["modelValue", "indeterminate", "onChange"])
            ], 2),
            vue.createElementVNode("div", {
              class: vue.normalizeClass([vue.unref(ns).be("panel", "body"), vue.unref(ns).is("with-footer", vue.unref(hasFooter))])
            }, [
              _ctx.filterable ? (vue.openBlock(), vue.createBlock(vue.unref(ElInput), {
                key: 0,
                modelValue: vue.unref(query),
                "onUpdate:modelValue": _cache[1] || (_cache[1] = ($event) => vue.isRef(query) ? query.value = $event : null),
                class: vue.normalizeClass(vue.unref(ns).be("panel", "filter")),
                size: "default",
                placeholder: _ctx.placeholder,
                "prefix-icon": vue.unref(search_default),
                clearable: "",
                "validate-event": false,
                onMouseenter: _cache[2] || (_cache[2] = ($event) => inputHover.value = true),
                onMouseleave: _cache[3] || (_cache[3] = ($event) => inputHover.value = false)
              }, null, 8, ["modelValue", "class", "placeholder", "prefix-icon"])) : vue.createCommentVNode("v-if", true),
              vue.withDirectives(vue.createVNode(vue.unref(ElCheckboxGroup$1), {
                modelValue: vue.unref(checked),
                "onUpdate:modelValue": _cache[4] || (_cache[4] = ($event) => vue.isRef(checked) ? checked.value = $event : null),
                "validate-event": false,
                class: vue.normalizeClass([vue.unref(ns).is("filterable", _ctx.filterable), vue.unref(ns).be("panel", "list")])
              }, {
                default: vue.withCtx(() => [
                  (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(vue.unref(filteredData), (item) => {
                    return vue.openBlock(), vue.createBlock(vue.unref(ElCheckbox), {
                      key: item[vue.unref(propsAlias).key],
                      class: vue.normalizeClass(vue.unref(ns).be("panel", "item")),
                      label: item[vue.unref(propsAlias).key],
                      disabled: item[vue.unref(propsAlias).disabled],
                      "validate-event": false
                    }, {
                      default: vue.withCtx(() => {
                        var _a;
                        return [
                          vue.createVNode(OptionContent, {
                            option: (_a = _ctx.optionRender) == null ? void 0 : _a.call(_ctx, item)
                          }, null, 8, ["option"])
                        ];
                      }),
                      _: 2
                    }, 1032, ["class", "label", "disabled"]);
                  }), 128))
                ]),
                _: 1
              }, 8, ["modelValue", "class"]), [
                [vue.vShow, !vue.unref(hasNoMatch) && !vue.unref(isEmpty)(_ctx.data)]
              ]),
              vue.withDirectives(vue.createElementVNode("p", {
                class: vue.normalizeClass(vue.unref(ns).be("panel", "empty"))
              }, vue.toDisplayString(vue.unref(hasNoMatch) ? vue.unref(t)("el.transfer.noMatch") : vue.unref(t)("el.transfer.noData")), 3), [
                [vue.vShow, vue.unref(hasNoMatch) || vue.unref(isEmpty)(_ctx.data)]
              ])
            ], 2),
            vue.unref(hasFooter) ? (vue.openBlock(), vue.createElementBlock("p", {
              key: 0,
              class: vue.normalizeClass(vue.unref(ns).be("panel", "footer"))
            }, [
              vue.renderSlot(_ctx.$slots, "default")
            ], 2)) : vue.createCommentVNode("v-if", true)
          ], 2);
        };
      }
    });
    var TransferPanel = /* @__PURE__ */ _export_sfc(_sfc_main$e, [["__file", "transfer-panel.vue"]]);
  
    const _hoisted_1$8 = { key: 0 };
    const _hoisted_2$6 = { key: 0 };
    const __default__$8 = vue.defineComponent({
      name: "ElTransfer"
    });
    const _sfc_main$d = /* @__PURE__ */ vue.defineComponent({
      ...__default__$8,
      props: transferProps,
      emits: transferEmits,
      setup(__props, { expose, emit }) {
        const props = __props;
        const slots = vue.useSlots();
        const { t } = useLocale();
        const ns = useNamespace("transfer");
        const { formItem } = useFormItem();
        const checkedState = vue.reactive({
          leftChecked: [],
          rightChecked: []
        });
        const propsAlias = usePropsAlias(props);
        const { sourceData, targetData } = useComputedData(props);
        const { onSourceCheckedChange, onTargetCheckedChange } = useCheckedChange(checkedState, emit);
        const { addToLeft, addToRight } = useMove(props, checkedState, emit);
        const leftPanel = vue.ref();
        const rightPanel = vue.ref();
        const clearQuery = (which) => {
          switch (which) {
            case "left":
              leftPanel.value.query = "";
              break;
            case "right":
              rightPanel.value.query = "";
              break;
          }
        };
        const hasButtonTexts = vue.computed(() => props.buttonTexts.length === 2);
        const leftPanelTitle = vue.computed(() => props.titles[0] || t("el.transfer.titles.0"));
        const rightPanelTitle = vue.computed(() => props.titles[1] || t("el.transfer.titles.1"));
        const panelFilterPlaceholder = vue.computed(() => props.filterPlaceholder || t("el.transfer.filterPlaceholder"));
        vue.watch(() => props.modelValue, () => {
          var _a;
          if (props.validateEvent) {
            (_a = formItem == null ? void 0 : formItem.validate) == null ? void 0 : _a.call(formItem, "change").catch((err) => debugWarn());
          }
        });
        const optionRender = vue.computed(() => (option) => {
          if (props.renderContent)
            return props.renderContent(vue.h, option);
          if (slots.default)
            return slots.default({ option });
          return vue.h("span", option[propsAlias.value.label] || option[propsAlias.value.key]);
        });
        expose({
          clearQuery,
          leftPanel,
          rightPanel
        });
        return (_ctx, _cache) => {
          return vue.openBlock(), vue.createElementBlock("div", {
            class: vue.normalizeClass(vue.unref(ns).b())
          }, [
            vue.createVNode(TransferPanel, {
              ref_key: "leftPanel",
              ref: leftPanel,
              data: vue.unref(sourceData),
              "option-render": vue.unref(optionRender),
              placeholder: vue.unref(panelFilterPlaceholder),
              title: vue.unref(leftPanelTitle),
              filterable: _ctx.filterable,
              format: _ctx.format,
              "filter-method": _ctx.filterMethod,
              "default-checked": _ctx.leftDefaultChecked,
              props: props.props,
              onCheckedChange: vue.unref(onSourceCheckedChange)
            }, {
              default: vue.withCtx(() => [
                vue.renderSlot(_ctx.$slots, "left-footer")
              ]),
              _: 3
            }, 8, ["data", "option-render", "placeholder", "title", "filterable", "format", "filter-method", "default-checked", "props", "onCheckedChange"]),
            vue.createElementVNode("div", {
              class: vue.normalizeClass(vue.unref(ns).e("buttons"))
            }, [
              vue.createVNode(vue.unref(ElButton), {
                type: "primary",
                class: vue.normalizeClass([vue.unref(ns).e("button"), vue.unref(ns).is("with-texts", vue.unref(hasButtonTexts))]),
                disabled: vue.unref(isEmpty)(checkedState.rightChecked),
                onClick: vue.unref(addToLeft)
              }, {
                default: vue.withCtx(() => [
                  vue.createVNode(vue.unref(ElIcon), null, {
                    default: vue.withCtx(() => [
                      vue.createVNode(vue.unref(arrow_left_default))
                    ]),
                    _: 1
                  }),
                  !vue.unref(isUndefined)(_ctx.buttonTexts[0]) ? (vue.openBlock(), vue.createElementBlock("span", _hoisted_1$8, vue.toDisplayString(_ctx.buttonTexts[0]), 1)) : vue.createCommentVNode("v-if", true)
                ]),
                _: 1
              }, 8, ["class", "disabled", "onClick"]),
              vue.createVNode(vue.unref(ElButton), {
                type: "primary",
                class: vue.normalizeClass([vue.unref(ns).e("button"), vue.unref(ns).is("with-texts", vue.unref(hasButtonTexts))]),
                disabled: vue.unref(isEmpty)(checkedState.leftChecked),
                onClick: vue.unref(addToRight)
              }, {
                default: vue.withCtx(() => [
                  !vue.unref(isUndefined)(_ctx.buttonTexts[1]) ? (vue.openBlock(), vue.createElementBlock("span", _hoisted_2$6, vue.toDisplayString(_ctx.buttonTexts[1]), 1)) : vue.createCommentVNode("v-if", true),
                  vue.createVNode(vue.unref(ElIcon), null, {
                    default: vue.withCtx(() => [
                      vue.createVNode(vue.unref(arrow_right_default))
                    ]),
                    _: 1
                  })
                ]),
                _: 1
              }, 8, ["class", "disabled", "onClick"])
            ], 2),
            vue.createVNode(TransferPanel, {
              ref_key: "rightPanel",
              ref: rightPanel,
              data: vue.unref(targetData),
              "option-render": vue.unref(optionRender),
              placeholder: vue.unref(panelFilterPlaceholder),
              filterable: _ctx.filterable,
              format: _ctx.format,
              "filter-method": _ctx.filterMethod,
              title: vue.unref(rightPanelTitle),
              "default-checked": _ctx.rightDefaultChecked,
              props: props.props,
              onCheckedChange: vue.unref(onTargetCheckedChange)
            }, {
              default: vue.withCtx(() => [
                vue.renderSlot(_ctx.$slots, "right-footer")
              ]),
              _: 3
            }, 8, ["data", "option-render", "placeholder", "filterable", "format", "filter-method", "title", "default-checked", "props", "onCheckedChange"])
          ], 2);
        };
      }
    });
    var Transfer = /* @__PURE__ */ _export_sfc(_sfc_main$d, [["__file", "transfer.vue"]]);
  
    const ElTransfer = withInstall(Transfer);
  
    const NODE_KEY = "$treeNodeId";
    const markNodeData = function(node, data) {
      if (!data || data[NODE_KEY])
        return;
      Object.defineProperty(data, NODE_KEY, {
        value: node.id,
        enumerable: false,
        configurable: false,
        writable: false
      });
    };
    const getNodeKey = function(key, data) {
      if (!key)
        return data[NODE_KEY];
      return data[key];
    };
    const handleCurrentChange = (store, emit, setCurrent) => {
      const preCurrentNode = store.value.currentNode;
      setCurrent();
      const currentNode = store.value.currentNode;
      if (preCurrentNode === currentNode)
        return;
      emit("current-change", currentNode ? currentNode.data : null, currentNode);
    };
  
    const getChildState = (node) => {
      let all = true;
      let none = true;
      let allWithoutDisable = true;
      for (let i = 0, j = node.length; i < j; i++) {
        const n = node[i];
        if (n.checked !== true || n.indeterminate) {
          all = false;
          if (!n.disabled) {
            allWithoutDisable = false;
          }
        }
        if (n.checked !== false || n.indeterminate) {
          none = false;
        }
      }
      return { all, none, allWithoutDisable, half: !all && !none };
    };
    const reInitChecked = function(node) {
      if (node.childNodes.length === 0 || node.loading)
        return;
      const { all, none, half } = getChildState(node.childNodes);
      if (all) {
        node.checked = true;
        node.indeterminate = false;
      } else if (half) {
        node.checked = false;
        node.indeterminate = true;
      } else if (none) {
        node.checked = false;
        node.indeterminate = false;
      }
      const parent = node.parent;
      if (!parent || parent.level === 0)
        return;
      if (!node.store.checkStrictly) {
        reInitChecked(parent);
      }
    };
    const getPropertyFromData = function(node, prop) {
      const props = node.store.props;
      const data = node.data || {};
      const config = props[prop];
      if (typeof config === "function") {
        return config(data, node);
      } else if (typeof config === "string") {
        return data[config];
      } else if (typeof config === "undefined") {
        const dataProp = data[prop];
        return dataProp === void 0 ? "" : dataProp;
      }
    };
    let nodeIdSeed = 0;
    class Node {
      constructor(options) {
        this.id = nodeIdSeed++;
        this.text = null;
        this.checked = false;
        this.indeterminate = false;
        this.data = null;
        this.expanded = false;
        this.parent = null;
        this.visible = true;
        this.isCurrent = false;
        this.canFocus = false;
        for (const name in options) {
          if (hasOwn(options, name)) {
            this[name] = options[name];
          }
        }
        this.level = 0;
        this.loaded = false;
        this.childNodes = [];
        this.loading = false;
        if (this.parent) {
          this.level = this.parent.level + 1;
        }
      }
      initialize() {
        const store = this.store;
        if (!store) {
          throw new Error("[Node]store is required!");
        }
        store.registerNode(this);
        const props = store.props;
        if (props && typeof props.isLeaf !== "undefined") {
          const isLeaf = getPropertyFromData(this, "isLeaf");
          if (typeof isLeaf === "boolean") {
            this.isLeafByUser = isLeaf;
          }
        }
        if (store.lazy !== true && this.data) {
          this.setData(this.data);
          if (store.defaultExpandAll) {
            this.expanded = true;
            this.canFocus = true;
          }
        } else if (this.level > 0 && store.lazy && store.defaultExpandAll) {
          this.expand();
        }
        if (!Array.isArray(this.data)) {
          markNodeData(this, this.data);
        }
        if (!this.data)
          return;
        const defaultExpandedKeys = store.defaultExpandedKeys;
        const key = store.key;
        if (key && defaultExpandedKeys && defaultExpandedKeys.includes(this.key)) {
          this.expand(null, store.autoExpandParent);
        }
        if (key && store.currentNodeKey !== void 0 && this.key === store.currentNodeKey) {
          store.currentNode = this;
          store.currentNode.isCurrent = true;
        }
        if (store.lazy) {
          store._initDefaultCheckedNode(this);
        }
        this.updateLeafState();
        if (this.parent && (this.level === 1 || this.parent.expanded === true))
          this.canFocus = true;
      }
      setData(data) {
        if (!Array.isArray(data)) {
          markNodeData(this, data);
        }
        this.data = data;
        this.childNodes = [];
        let children;
        if (this.level === 0 && Array.isArray(this.data)) {
          children = this.data;
        } else {
          children = getPropertyFromData(this, "children") || [];
        }
        for (let i = 0, j = children.length; i < j; i++) {
          this.insertChild({ data: children[i] });
        }
      }
      get label() {
        return getPropertyFromData(this, "label");
      }
      get key() {
        const nodeKey = this.store.key;
        if (this.data)
          return this.data[nodeKey];
        return null;
      }
      get disabled() {
        return getPropertyFromData(this, "disabled");
      }
      get nextSibling() {
        const parent = this.parent;
        if (parent) {
          const index = parent.childNodes.indexOf(this);
          if (index > -1) {
            return parent.childNodes[index + 1];
          }
        }
        return null;
      }
      get previousSibling() {
        const parent = this.parent;
        if (parent) {
          const index = parent.childNodes.indexOf(this);
          if (index > -1) {
            return index > 0 ? parent.childNodes[index - 1] : null;
          }
        }
        return null;
      }
      contains(target, deep = true) {
        return (this.childNodes || []).some((child) => child === target || deep && child.contains(target));
      }
      remove() {
        const parent = this.parent;
        if (parent) {
          parent.removeChild(this);
        }
      }
      insertChild(child, index, batch) {
        if (!child)
          throw new Error("InsertChild error: child is required.");
        if (!(child instanceof Node)) {
          if (!batch) {
            const children = this.getChildren(true);
            if (!children.includes(child.data)) {
              if (typeof index === "undefined" || index < 0) {
                children.push(child.data);
              } else {
                children.splice(index, 0, child.data);
              }
            }
          }
          Object.assign(child, {
            parent: this,
            store: this.store
          });
          child = vue.reactive(new Node(child));
          if (child instanceof Node) {
            child.initialize();
          }
        }
        child.level = this.level + 1;
        if (typeof index === "undefined" || index < 0) {
          this.childNodes.push(child);
        } else {
          this.childNodes.splice(index, 0, child);
        }
        this.updateLeafState();
      }
      insertBefore(child, ref) {
        let index;
        if (ref) {
          index = this.childNodes.indexOf(ref);
        }
        this.insertChild(child, index);
      }
      insertAfter(child, ref) {
        let index;
        if (ref) {
          index = this.childNodes.indexOf(ref);
          if (index !== -1)
            index += 1;
        }
        this.insertChild(child, index);
      }
      removeChild(child) {
        const children = this.getChildren() || [];
        const dataIndex = children.indexOf(child.data);
        if (dataIndex > -1) {
          children.splice(dataIndex, 1);
        }
        const index = this.childNodes.indexOf(child);
        if (index > -1) {
          this.store && this.store.deregisterNode(child);
          child.parent = null;
          this.childNodes.splice(index, 1);
        }
        this.updateLeafState();
      }
      removeChildByData(data) {
        let targetNode = null;
        for (let i = 0; i < this.childNodes.length; i++) {
          if (this.childNodes[i].data === data) {
            targetNode = this.childNodes[i];
            break;
          }
        }
        if (targetNode) {
          this.removeChild(targetNode);
        }
      }
      expand(callback, expandParent) {
        const done = () => {
          if (expandParent) {
            let parent = this.parent;
            while (parent.level > 0) {
              parent.expanded = true;
              parent = parent.parent;
            }
          }
          this.expanded = true;
          if (callback)
            callback();
          this.childNodes.forEach((item) => {
            item.canFocus = true;
          });
        };
        if (this.shouldLoadData()) {
          this.loadData((data) => {
            if (Array.isArray(data)) {
              if (this.checked) {
                this.setChecked(true, true);
              } else if (!this.store.checkStrictly) {
                reInitChecked(this);
              }
              done();
            }
          });
        } else {
          done();
        }
      }
      doCreateChildren(array, defaultProps = {}) {
        array.forEach((item) => {
          this.insertChild(Object.assign({ data: item }, defaultProps), void 0, true);
        });
      }
      collapse() {
        this.expanded = false;
        this.childNodes.forEach((item) => {
          item.canFocus = false;
        });
      }
      shouldLoadData() {
        return this.store.lazy === true && this.store.load && !this.loaded;
      }
      updateLeafState() {
        if (this.store.lazy === true && this.loaded !== true && typeof this.isLeafByUser !== "undefined") {
          this.isLeaf = this.isLeafByUser;
          return;
        }
        const childNodes = this.childNodes;
        if (!this.store.lazy || this.store.lazy === true && this.loaded === true) {
          this.isLeaf = !childNodes || childNodes.length === 0;
          return;
        }
        this.isLeaf = false;
      }
      setChecked(value, deep, recursion, passValue) {
        this.indeterminate = value === "half";
        this.checked = value === true;
        if (this.store.checkStrictly)
          return;
        if (!(this.shouldLoadData() && !this.store.checkDescendants)) {
          const { all, allWithoutDisable } = getChildState(this.childNodes);
          if (!this.isLeaf && !all && allWithoutDisable) {
            this.checked = false;
            value = false;
          }
          const handleDescendants = () => {
            if (deep) {
              const childNodes = this.childNodes;
              for (let i = 0, j = childNodes.length; i < j; i++) {
                const child = childNodes[i];
                passValue = passValue || value !== false;
                const isCheck = child.disabled ? child.checked : passValue;
                child.setChecked(isCheck, deep, true, passValue);
              }
              const { half, all: all2 } = getChildState(childNodes);
              if (!all2) {
                this.checked = all2;
                this.indeterminate = half;
              }
            }
          };
          if (this.shouldLoadData()) {
            this.loadData(() => {
              handleDescendants();
              reInitChecked(this);
            }, {
              checked: value !== false
            });
            return;
          } else {
            handleDescendants();
          }
        }
        const parent = this.parent;
        if (!parent || parent.level === 0)
          return;
        if (!recursion) {
          reInitChecked(parent);
        }
      }
      getChildren(forceInit = false) {
        if (this.level === 0)
          return this.data;
        const data = this.data;
        if (!data)
          return null;
        const props = this.store.props;
        let children = "children";
        if (props) {
          children = props.children || "children";
        }
        if (data[children] === void 0) {
          data[children] = null;
        }
        if (forceInit && !data[children]) {
          data[children] = [];
        }
        return data[children];
      }
      updateChildren() {
        const newData = this.getChildren() || [];
        const oldData = this.childNodes.map((node) => node.data);
        const newDataMap = {};
        const newNodes = [];
        newData.forEach((item, index) => {
          const key = item[NODE_KEY];
          const isNodeExists = !!key && oldData.findIndex((data) => data[NODE_KEY] === key) >= 0;
          if (isNodeExists) {
            newDataMap[key] = { index, data: item };
          } else {
            newNodes.push({ index, data: item });
          }
        });
        if (!this.store.lazy) {
          oldData.forEach((item) => {
            if (!newDataMap[item[NODE_KEY]])
              this.removeChildByData(item);
          });
        }
        newNodes.forEach(({ index, data }) => {
          this.insertChild({ data }, index);
        });
        this.updateLeafState();
      }
      loadData(callback, defaultProps = {}) {
        if (this.store.lazy === true && this.store.load && !this.loaded && (!this.loading || Object.keys(defaultProps).length)) {
          this.loading = true;
          const resolve = (children) => {
            this.childNodes = [];
            this.doCreateChildren(children, defaultProps);
            this.loaded = true;
            this.loading = false;
            this.updateLeafState();
            if (callback) {
              callback.call(this, children);
            }
          };
          this.store.load(this, resolve);
        } else {
          if (callback) {
            callback.call(this);
          }
        }
      }
    }
    var Node$1 = Node;
  
    class TreeStore {
      constructor(options) {
        this.currentNode = null;
        this.currentNodeKey = null;
        for (const option in options) {
          if (hasOwn(options, option)) {
            this[option] = options[option];
          }
        }
        this.nodesMap = {};
      }
      initialize() {
        this.root = new Node$1({
          data: this.data,
          store: this
        });
        this.root.initialize();
        if (this.lazy && this.load) {
          const loadFn = this.load;
          loadFn(this.root, (data) => {
            this.root.doCreateChildren(data);
            this._initDefaultCheckedNodes();
          });
        } else {
          this._initDefaultCheckedNodes();
        }
      }
      filter(value) {
        const filterNodeMethod = this.filterNodeMethod;
        const lazy = this.lazy;
        const traverse = function(node) {
          const childNodes = node.root ? node.root.childNodes : node.childNodes;
          childNodes.forEach((child) => {
            child.visible = filterNodeMethod.call(child, value, child.data, child);
            traverse(child);
          });
          if (!node.visible && childNodes.length) {
            let allHidden = true;
            allHidden = !childNodes.some((child) => child.visible);
            if (node.root) {
              node.root.visible = allHidden === false;
            } else {
              node.visible = allHidden === false;
            }
          }
          if (!value)
            return;
          if (node.visible && !node.isLeaf && !lazy)
            node.expand();
        };
        traverse(this);
      }
      setData(newVal) {
        const instanceChanged = newVal !== this.root.data;
        if (instanceChanged) {
          this.root.setData(newVal);
          this._initDefaultCheckedNodes();
        } else {
          this.root.updateChildren();
        }
      }
      getNode(data) {
        if (data instanceof Node$1)
          return data;
        const key = isObject$1(data) ? getNodeKey(this.key, data) : data;
        return this.nodesMap[key] || null;
      }
      insertBefore(data, refData) {
        const refNode = this.getNode(refData);
        refNode.parent.insertBefore({ data }, refNode);
      }
      insertAfter(data, refData) {
        const refNode = this.getNode(refData);
        refNode.parent.insertAfter({ data }, refNode);
      }
      remove(data) {
        const node = this.getNode(data);
        if (node && node.parent) {
          if (node === this.currentNode) {
            this.currentNode = null;
          }
          node.parent.removeChild(node);
        }
      }
      append(data, parentData) {
        const parentNode = parentData ? this.getNode(parentData) : this.root;
        if (parentNode) {
          parentNode.insertChild({ data });
        }
      }
      _initDefaultCheckedNodes() {
        const defaultCheckedKeys = this.defaultCheckedKeys || [];
        const nodesMap = this.nodesMap;
        defaultCheckedKeys.forEach((checkedKey) => {
          const node = nodesMap[checkedKey];
          if (node) {
            node.setChecked(true, !this.checkStrictly);
          }
        });
      }
      _initDefaultCheckedNode(node) {
        const defaultCheckedKeys = this.defaultCheckedKeys || [];
        if (defaultCheckedKeys.includes(node.key)) {
          node.setChecked(true, !this.checkStrictly);
        }
      }
      setDefaultCheckedKey(newVal) {
        if (newVal !== this.defaultCheckedKeys) {
          this.defaultCheckedKeys = newVal;
          this._initDefaultCheckedNodes();
        }
      }
      registerNode(node) {
        const key = this.key;
        if (!node || !node.data)
          return;
        if (!key) {
          this.nodesMap[node.id] = node;
        } else {
          const nodeKey = node.key;
          if (nodeKey !== void 0)
            this.nodesMap[node.key] = node;
        }
      }
      deregisterNode(node) {
        const key = this.key;
        if (!key || !node || !node.data)
          return;
        node.childNodes.forEach((child) => {
          this.deregisterNode(child);
        });
        delete this.nodesMap[node.key];
      }
      getCheckedNodes(leafOnly = false, includeHalfChecked = false) {
        const checkedNodes = [];
        const traverse = function(node) {
          const childNodes = node.root ? node.root.childNodes : node.childNodes;
          childNodes.forEach((child) => {
            if ((child.checked || includeHalfChecked && child.indeterminate) && (!leafOnly || leafOnly && child.isLeaf)) {
              checkedNodes.push(child.data);
            }
            traverse(child);
          });
        };
        traverse(this);
        return checkedNodes;
      }
      getCheckedKeys(leafOnly = false) {
        return this.getCheckedNodes(leafOnly).map((data) => (data || {})[this.key]);
      }
      getHalfCheckedNodes() {
        const nodes = [];
        const traverse = function(node) {
          const childNodes = node.root ? node.root.childNodes : node.childNodes;
          childNodes.forEach((child) => {
            if (child.indeterminate) {
              nodes.push(child.data);
            }
            traverse(child);
          });
        };
        traverse(this);
        return nodes;
      }
      getHalfCheckedKeys() {
        return this.getHalfCheckedNodes().map((data) => (data || {})[this.key]);
      }
      _getAllNodes() {
        const allNodes = [];
        const nodesMap = this.nodesMap;
        for (const nodeKey in nodesMap) {
          if (hasOwn(nodesMap, nodeKey)) {
            allNodes.push(nodesMap[nodeKey]);
          }
        }
        return allNodes;
      }
      updateChildren(key, data) {
        const node = this.nodesMap[key];
        if (!node)
          return;
        const childNodes = node.childNodes;
        for (let i = childNodes.length - 1; i >= 0; i--) {
          const child = childNodes[i];
          this.remove(child.data);
        }
        for (let i = 0, j = data.length; i < j; i++) {
          const child = data[i];
          this.append(child, node.data);
        }
      }
      _setCheckedKeys(key, leafOnly = false, checkedKeys) {
        const allNodes = this._getAllNodes().sort((a, b) => b.level - a.level);
        const cache = /* @__PURE__ */ Object.create(null);
        const keys = Object.keys(checkedKeys);
        allNodes.forEach((node) => node.setChecked(false, false));
        for (let i = 0, j = allNodes.length; i < j; i++) {
          const node = allNodes[i];
          const nodeKey = node.data[key].toString();
          const checked = keys.includes(nodeKey);
          if (!checked) {
            if (node.checked && !cache[nodeKey]) {
              node.setChecked(false, false);
            }
            continue;
          }
          let parent = node.parent;
          while (parent && parent.level > 0) {
            cache[parent.data[key]] = true;
            parent = parent.parent;
          }
          if (node.isLeaf || this.checkStrictly) {
            node.setChecked(true, false);
            continue;
          }
          node.setChecked(true, true);
          if (leafOnly) {
            node.setChecked(false, false);
            const traverse = function(node2) {
              const childNodes = node2.childNodes;
              childNodes.forEach((child) => {
                if (!child.isLeaf) {
                  child.setChecked(false, false);
                }
                traverse(child);
              });
            };
            traverse(node);
          }
        }
      }
      setCheckedNodes(array, leafOnly = false) {
        const key = this.key;
        const checkedKeys = {};
        array.forEach((item) => {
          checkedKeys[(item || {})[key]] = true;
        });
        this._setCheckedKeys(key, leafOnly, checkedKeys);
      }
      setCheckedKeys(keys, leafOnly = false) {
        this.defaultCheckedKeys = keys;
        const key = this.key;
        const checkedKeys = {};
        keys.forEach((key2) => {
          checkedKeys[key2] = true;
        });
        this._setCheckedKeys(key, leafOnly, checkedKeys);
      }
      setDefaultExpandedKeys(keys) {
        keys = keys || [];
        this.defaultExpandedKeys = keys;
        keys.forEach((key) => {
          const node = this.getNode(key);
          if (node)
            node.expand(null, this.autoExpandParent);
        });
      }
      setChecked(data, checked, deep) {
        const node = this.getNode(data);
        if (node) {
          node.setChecked(!!checked, deep);
        }
      }
      getCurrentNode() {
        return this.currentNode;
      }
      setCurrentNode(currentNode) {
        const prevCurrentNode = this.currentNode;
        if (prevCurrentNode) {
          prevCurrentNode.isCurrent = false;
        }
        this.currentNode = currentNode;
        this.currentNode.isCurrent = true;
      }
      setUserCurrentNode(node, shouldAutoExpandParent = true) {
        const key = node[this.key];
        const currNode = this.nodesMap[key];
        this.setCurrentNode(currNode);
        if (shouldAutoExpandParent && this.currentNode.level > 1) {
          this.currentNode.parent.expand(null, true);
        }
      }
      setCurrentNodeKey(key, shouldAutoExpandParent = true) {
        if (key === null || key === void 0) {
          this.currentNode && (this.currentNode.isCurrent = false);
          this.currentNode = null;
          return;
        }
        const node = this.getNode(key);
        if (node) {
          this.setCurrentNode(node);
          if (shouldAutoExpandParent && this.currentNode.level > 1) {
            this.currentNode.parent.expand(null, true);
          }
        }
      }
    }
  
    const _sfc_main$c = vue.defineComponent({
      name: "ElTreeNodeContent",
      props: {
        node: {
          type: Object,
          required: true
        },
        renderContent: Function
      },
      setup(props) {
        const ns = useNamespace("tree");
        const nodeInstance = vue.inject("NodeInstance");
        const tree = vue.inject("RootTree");
        return () => {
          const node = props.node;
          const { data, store } = node;
          return props.renderContent ? props.renderContent(vue.h, { _self: nodeInstance, node, data, store }) : vue.h("span", { class: ns.be("node", "label") }, [
            tree.ctx.slots.default ? tree.ctx.slots.default({ node, data }) : node.label
          ]);
        };
      }
    });
    var NodeContent = /* @__PURE__ */ _export_sfc(_sfc_main$c, [["__file", "tree-node-content.vue"]]);
  
    function useNodeExpandEventBroadcast(props) {
      const parentNodeMap = vue.inject("TreeNodeMap", null);
      const currentNodeMap = {
        treeNodeExpand: (node) => {
          if (props.node !== node) {
            props.node.collapse();
          }
        },
        children: []
      };
      if (parentNodeMap) {
        parentNodeMap.children.push(currentNodeMap);
      }
      vue.provide("TreeNodeMap", currentNodeMap);
      return {
        broadcastExpanded: (node) => {
          if (!props.accordion)
            return;
          for (const childNode of currentNodeMap.children) {
            childNode.treeNodeExpand(node);
          }
        }
      };
    }
  
    const dragEventsKey = Symbol("dragEvents");
    function useDragNodeHandler({ props, ctx, el$, dropIndicator$, store }) {
      const ns = useNamespace("tree");
      const dragState = vue.ref({
        showDropIndicator: false,
        draggingNode: null,
        dropNode: null,
        allowDrop: true,
        dropType: null
      });
      const treeNodeDragStart = ({ event, treeNode }) => {
        if (typeof props.allowDrag === "function" && !props.allowDrag(treeNode.node)) {
          event.preventDefault();
          return false;
        }
        event.dataTransfer.effectAllowed = "move";
        try {
          event.dataTransfer.setData("text/plain", "");
        } catch (e) {
        }
        dragState.value.draggingNode = treeNode;
        ctx.emit("node-drag-start", treeNode.node, event);
      };
      const treeNodeDragOver = ({ event, treeNode }) => {
        const dropNode = treeNode;
        const oldDropNode = dragState.value.dropNode;
        if (oldDropNode && oldDropNode !== dropNode) {
          removeClass(oldDropNode.$el, ns.is("drop-inner"));
        }
        const draggingNode = dragState.value.draggingNode;
        if (!draggingNode || !dropNode)
          return;
        let dropPrev = true;
        let dropInner = true;
        let dropNext = true;
        let userAllowDropInner = true;
        if (typeof props.allowDrop === "function") {
          dropPrev = props.allowDrop(draggingNode.node, dropNode.node, "prev");
          userAllowDropInner = dropInner = props.allowDrop(draggingNode.node, dropNode.node, "inner");
          dropNext = props.allowDrop(draggingNode.node, dropNode.node, "next");
        }
        event.dataTransfer.dropEffect = dropInner || dropPrev || dropNext ? "move" : "none";
        if ((dropPrev || dropInner || dropNext) && oldDropNode !== dropNode) {
          if (oldDropNode) {
            ctx.emit("node-drag-leave", draggingNode.node, oldDropNode.node, event);
          }
          ctx.emit("node-drag-enter", draggingNode.node, dropNode.node, event);
        }
        if (dropPrev || dropInner || dropNext) {
          dragState.value.dropNode = dropNode;
        }
        if (dropNode.node.nextSibling === draggingNode.node) {
          dropNext = false;
        }
        if (dropNode.node.previousSibling === draggingNode.node) {
          dropPrev = false;
        }
        if (dropNode.node.contains(draggingNode.node, false)) {
          dropInner = false;
        }
        if (draggingNode.node === dropNode.node || draggingNode.node.contains(dropNode.node)) {
          dropPrev = false;
          dropInner = false;
          dropNext = false;
        }
        const targetPosition = dropNode.$el.getBoundingClientRect();
        const treePosition = el$.value.getBoundingClientRect();
        let dropType;
        const prevPercent = dropPrev ? dropInner ? 0.25 : dropNext ? 0.45 : 1 : -1;
        const nextPercent = dropNext ? dropInner ? 0.75 : dropPrev ? 0.55 : 0 : 1;
        let indicatorTop = -9999;
        const distance = event.clientY - targetPosition.top;
        if (distance < targetPosition.height * prevPercent) {
          dropType = "before";
        } else if (distance > targetPosition.height * nextPercent) {
          dropType = "after";
        } else if (dropInner) {
          dropType = "inner";
        } else {
          dropType = "none";
        }
        const iconPosition = dropNode.$el.querySelector(`.${ns.be("node", "expand-icon")}`).getBoundingClientRect();
        const dropIndicator = dropIndicator$.value;
        if (dropType === "before") {
          indicatorTop = iconPosition.top - treePosition.top;
        } else if (dropType === "after") {
          indicatorTop = iconPosition.bottom - treePosition.top;
        }
        dropIndicator.style.top = `${indicatorTop}px`;
        dropIndicator.style.left = `${iconPosition.right - treePosition.left}px`;
        if (dropType === "inner") {
          addClass(dropNode.$el, ns.is("drop-inner"));
        } else {
          removeClass(dropNode.$el, ns.is("drop-inner"));
        }
        dragState.value.showDropIndicator = dropType === "before" || dropType === "after";
        dragState.value.allowDrop = dragState.value.showDropIndicator || userAllowDropInner;
        dragState.value.dropType = dropType;
        ctx.emit("node-drag-over", draggingNode.node, dropNode.node, event);
      };
      const treeNodeDragEnd = (event) => {
        const { draggingNode, dropType, dropNode } = dragState.value;
        event.preventDefault();
        event.dataTransfer.dropEffect = "move";
        if (draggingNode && dropNode) {
          const draggingNodeCopy = { data: draggingNode.node.data };
          if (dropType !== "none") {
            draggingNode.node.remove();
          }
          if (dropType === "before") {
            dropNode.node.parent.insertBefore(draggingNodeCopy, dropNode.node);
          } else if (dropType === "after") {
            dropNode.node.parent.insertAfter(draggingNodeCopy, dropNode.node);
          } else if (dropType === "inner") {
            dropNode.node.insertChild(draggingNodeCopy);
          }
          if (dropType !== "none") {
            store.value.registerNode(draggingNodeCopy);
          }
          removeClass(dropNode.$el, ns.is("drop-inner"));
          ctx.emit("node-drag-end", draggingNode.node, dropNode.node, dropType, event);
          if (dropType !== "none") {
            ctx.emit("node-drop", draggingNode.node, dropNode.node, dropType, event);
          }
        }
        if (draggingNode && !dropNode) {
          ctx.emit("node-drag-end", draggingNode.node, null, dropType, event);
        }
        dragState.value.showDropIndicator = false;
        dragState.value.draggingNode = null;
        dragState.value.dropNode = null;
        dragState.value.allowDrop = true;
      };
      vue.provide(dragEventsKey, {
        treeNodeDragStart,
        treeNodeDragOver,
        treeNodeDragEnd
      });
      return {
        dragState
      };
    }
  
    const _sfc_main$b = vue.defineComponent({
      name: "ElTreeNode",
      components: {
        ElCollapseTransition: _CollapseTransition,
        ElCheckbox,
        NodeContent,
        ElIcon,
        Loading: loading_default
      },
      props: {
        node: {
          type: Node$1,
          default: () => ({})
        },
        props: {
          type: Object,
          default: () => ({})
        },
        accordion: Boolean,
        renderContent: Function,
        renderAfterExpand: Boolean,
        showCheckbox: {
          type: Boolean,
          default: false
        }
      },
      emits: ["node-expand"],
      setup(props, ctx) {
        const ns = useNamespace("tree");
        const { broadcastExpanded } = useNodeExpandEventBroadcast(props);
        const tree = vue.inject("RootTree");
        const expanded = vue.ref(false);
        const childNodeRendered = vue.ref(false);
        const oldChecked = vue.ref(null);
        const oldIndeterminate = vue.ref(null);
        const node$ = vue.ref(null);
        const dragEvents = vue.inject(dragEventsKey);
        const instance = vue.getCurrentInstance();
        vue.provide("NodeInstance", instance);
        if (props.node.expanded) {
          expanded.value = true;
          childNodeRendered.value = true;
        }
        const childrenKey = tree.props["children"] || "children";
        vue.watch(() => {
          const children = props.node.data[childrenKey];
          return children && [...children];
        }, () => {
          props.node.updateChildren();
        });
        vue.watch(() => props.node.indeterminate, (val) => {
          handleSelectChange(props.node.checked, val);
        });
        vue.watch(() => props.node.checked, (val) => {
          handleSelectChange(val, props.node.indeterminate);
        });
        vue.watch(() => props.node.expanded, (val) => {
          vue.nextTick(() => expanded.value = val);
          if (val) {
            childNodeRendered.value = true;
          }
        });
        const getNodeKey$1 = (node) => {
          return getNodeKey(tree.props.nodeKey, node.data);
        };
        const getNodeClass = (node) => {
          const nodeClassFunc = props.props.class;
          if (!nodeClassFunc) {
            return {};
          }
          let className;
          if (isFunction(nodeClassFunc)) {
            const { data } = node;
            className = nodeClassFunc(data, node);
          } else {
            className = nodeClassFunc;
          }
          if (isString(className)) {
            return { [className]: true };
          } else {
            return className;
          }
        };
        const handleSelectChange = (checked, indeterminate) => {
          if (oldChecked.value !== checked || oldIndeterminate.value !== indeterminate) {
            tree.ctx.emit("check-change", props.node.data, checked, indeterminate);
          }
          oldChecked.value = checked;
          oldIndeterminate.value = indeterminate;
        };
        const handleClick = (e) => {
          handleCurrentChange(tree.store, tree.ctx.emit, () => tree.store.value.setCurrentNode(props.node));
          tree.currentNode.value = props.node;
          if (tree.props.expandOnClickNode) {
            handleExpandIconClick();
          }
          if (tree.props.checkOnClickNode && !props.node.disabled) {
            handleCheckChange(null, {
              target: { checked: !props.node.checked }
            });
          }
          tree.ctx.emit("node-click", props.node.data, props.node, instance, e);
        };
        const handleContextMenu = (event) => {
          if (tree.instance.vnode.props["onNodeContextmenu"]) {
            event.stopPropagation();
            event.preventDefault();
          }
          tree.ctx.emit("node-contextmenu", event, props.node.data, props.node, instance);
        };
        const handleExpandIconClick = () => {
          if (props.node.isLeaf)
            return;
          if (expanded.value) {
            tree.ctx.emit("node-collapse", props.node.data, props.node, instance);
            props.node.collapse();
          } else {
            props.node.expand();
            ctx.emit("node-expand", props.node.data, props.node, instance);
          }
        };
        const handleCheckChange = (value, ev) => {
          props.node.setChecked(ev.target.checked, !tree.props.checkStrictly);
          vue.nextTick(() => {
            const store = tree.store.value;
            tree.ctx.emit("check", props.node.data, {
              checkedNodes: store.getCheckedNodes(),
              checkedKeys: store.getCheckedKeys(),
              halfCheckedNodes: store.getHalfCheckedNodes(),
              halfCheckedKeys: store.getHalfCheckedKeys()
            });
          });
        };
        const handleChildNodeExpand = (nodeData, node, instance2) => {
          broadcastExpanded(node);
          tree.ctx.emit("node-expand", nodeData, node, instance2);
        };
        const handleDragStart = (event) => {
          if (!tree.props.draggable)
            return;
          dragEvents.treeNodeDragStart({ event, treeNode: props });
        };
        const handleDragOver = (event) => {
          event.preventDefault();
          if (!tree.props.draggable)
            return;
          dragEvents.treeNodeDragOver({
            event,
            treeNode: { $el: node$.value, node: props.node }
          });
        };
        const handleDrop = (event) => {
          event.preventDefault();
        };
        const handleDragEnd = (event) => {
          if (!tree.props.draggable)
            return;
          dragEvents.treeNodeDragEnd(event);
        };
        return {
          ns,
          node$,
          tree,
          expanded,
          childNodeRendered,
          oldChecked,
          oldIndeterminate,
          getNodeKey: getNodeKey$1,
          getNodeClass,
          handleSelectChange,
          handleClick,
          handleContextMenu,
          handleExpandIconClick,
          handleCheckChange,
          handleChildNodeExpand,
          handleDragStart,
          handleDragOver,
          handleDrop,
          handleDragEnd,
          CaretRight: caret_right_default
        };
      }
    });
    const _hoisted_1$7 = ["aria-expanded", "aria-disabled", "aria-checked", "draggable", "data-key"];
    const _hoisted_2$5 = ["aria-expanded"];
    function _sfc_render$2(_ctx, _cache, $props, $setup, $data, $options) {
      const _component_el_icon = vue.resolveComponent("el-icon");
      const _component_el_checkbox = vue.resolveComponent("el-checkbox");
      const _component_loading = vue.resolveComponent("loading");
      const _component_node_content = vue.resolveComponent("node-content");
      const _component_el_tree_node = vue.resolveComponent("el-tree-node");
      const _component_el_collapse_transition = vue.resolveComponent("el-collapse-transition");
      return vue.withDirectives((vue.openBlock(), vue.createElementBlock("div", {
        ref: "node$",
        class: vue.normalizeClass([
          _ctx.ns.b("node"),
          _ctx.ns.is("expanded", _ctx.expanded),
          _ctx.ns.is("current", _ctx.node.isCurrent),
          _ctx.ns.is("hidden", !_ctx.node.visible),
          _ctx.ns.is("focusable", !_ctx.node.disabled),
          _ctx.ns.is("checked", !_ctx.node.disabled && _ctx.node.checked),
          _ctx.getNodeClass(_ctx.node)
        ]),
        role: "treeitem",
        tabindex: "-1",
        "aria-expanded": _ctx.expanded,
        "aria-disabled": _ctx.node.disabled,
        "aria-checked": _ctx.node.checked,
        draggable: _ctx.tree.props.draggable,
        "data-key": _ctx.getNodeKey(_ctx.node),
        onClick: _cache[1] || (_cache[1] = vue.withModifiers((...args) => _ctx.handleClick && _ctx.handleClick(...args), ["stop"])),
        onContextmenu: _cache[2] || (_cache[2] = (...args) => _ctx.handleContextMenu && _ctx.handleContextMenu(...args)),
        onDragstart: _cache[3] || (_cache[3] = vue.withModifiers((...args) => _ctx.handleDragStart && _ctx.handleDragStart(...args), ["stop"])),
        onDragover: _cache[4] || (_cache[4] = vue.withModifiers((...args) => _ctx.handleDragOver && _ctx.handleDragOver(...args), ["stop"])),
        onDragend: _cache[5] || (_cache[5] = vue.withModifiers((...args) => _ctx.handleDragEnd && _ctx.handleDragEnd(...args), ["stop"])),
        onDrop: _cache[6] || (_cache[6] = vue.withModifiers((...args) => _ctx.handleDrop && _ctx.handleDrop(...args), ["stop"]))
      }, [
        vue.createElementVNode("div", {
          class: vue.normalizeClass(_ctx.ns.be("node", "content")),
          style: vue.normalizeStyle({ paddingLeft: (_ctx.node.level - 1) * _ctx.tree.props.indent + "px" })
        }, [
          _ctx.tree.props.icon || _ctx.CaretRight ? (vue.openBlock(), vue.createBlock(_component_el_icon, {
            key: 0,
            class: vue.normalizeClass([
              _ctx.ns.be("node", "expand-icon"),
              _ctx.ns.is("leaf", _ctx.node.isLeaf),
              {
                expanded: !_ctx.node.isLeaf && _ctx.expanded
              }
            ]),
            onClick: vue.withModifiers(_ctx.handleExpandIconClick, ["stop"])
          }, {
            default: vue.withCtx(() => [
              (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(_ctx.tree.props.icon || _ctx.CaretRight)))
            ]),
            _: 1
          }, 8, ["class", "onClick"])) : vue.createCommentVNode("v-if", true),
          _ctx.showCheckbox ? (vue.openBlock(), vue.createBlock(_component_el_checkbox, {
            key: 1,
            "model-value": _ctx.node.checked,
            indeterminate: _ctx.node.indeterminate,
            disabled: !!_ctx.node.disabled,
            onClick: _cache[0] || (_cache[0] = vue.withModifiers(() => {
            }, ["stop"])),
            onChange: _ctx.handleCheckChange
          }, null, 8, ["model-value", "indeterminate", "disabled", "onChange"])) : vue.createCommentVNode("v-if", true),
          _ctx.node.loading ? (vue.openBlock(), vue.createBlock(_component_el_icon, {
            key: 2,
            class: vue.normalizeClass([_ctx.ns.be("node", "loading-icon"), _ctx.ns.is("loading")])
          }, {
            default: vue.withCtx(() => [
              vue.createVNode(_component_loading)
            ]),
            _: 1
          }, 8, ["class"])) : vue.createCommentVNode("v-if", true),
          vue.createVNode(_component_node_content, {
            node: _ctx.node,
            "render-content": _ctx.renderContent
          }, null, 8, ["node", "render-content"])
        ], 6),
        vue.createVNode(_component_el_collapse_transition, null, {
          default: vue.withCtx(() => [
            !_ctx.renderAfterExpand || _ctx.childNodeRendered ? vue.withDirectives((vue.openBlock(), vue.createElementBlock("div", {
              key: 0,
              class: vue.normalizeClass(_ctx.ns.be("node", "children")),
              role: "group",
              "aria-expanded": _ctx.expanded
            }, [
              (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(_ctx.node.childNodes, (child) => {
                return vue.openBlock(), vue.createBlock(_component_el_tree_node, {
                  key: _ctx.getNodeKey(child),
                  "render-content": _ctx.renderContent,
                  "render-after-expand": _ctx.renderAfterExpand,
                  "show-checkbox": _ctx.showCheckbox,
                  node: child,
                  accordion: _ctx.accordion,
                  props: _ctx.props,
                  onNodeExpand: _ctx.handleChildNodeExpand
                }, null, 8, ["render-content", "render-after-expand", "show-checkbox", "node", "accordion", "props", "onNodeExpand"]);
              }), 128))
            ], 10, _hoisted_2$5)), [
              [vue.vShow, _ctx.expanded]
            ]) : vue.createCommentVNode("v-if", true)
          ]),
          _: 1
        })
      ], 42, _hoisted_1$7)), [
        [vue.vShow, _ctx.node.visible]
      ]);
    }
    var ElTreeNode$1 = /* @__PURE__ */ _export_sfc(_sfc_main$b, [["render", _sfc_render$2], ["__file", "tree-node.vue"]]);
  
    function useKeydown({ el$ }, store) {
      const ns = useNamespace("tree");
      const treeItems = vue.shallowRef([]);
      const checkboxItems = vue.shallowRef([]);
      vue.onMounted(() => {
        initTabIndex();
      });
      vue.onUpdated(() => {
        treeItems.value = Array.from(el$.value.querySelectorAll("[role=treeitem]"));
        checkboxItems.value = Array.from(el$.value.querySelectorAll("input[type=checkbox]"));
      });
      vue.watch(checkboxItems, (val) => {
        val.forEach((checkbox) => {
          checkbox.setAttribute("tabindex", "-1");
        });
      });
      const handleKeydown = (ev) => {
        const currentItem = ev.target;
        if (!currentItem.className.includes(ns.b("node")))
          return;
        const code = ev.code;
        treeItems.value = Array.from(el$.value.querySelectorAll(`.${ns.is("focusable")}[role=treeitem]`));
        const currentIndex = treeItems.value.indexOf(currentItem);
        let nextIndex;
        if ([EVENT_CODE.up, EVENT_CODE.down].includes(code)) {
          ev.preventDefault();
          if (code === EVENT_CODE.up) {
            nextIndex = currentIndex === -1 ? 0 : currentIndex !== 0 ? currentIndex - 1 : treeItems.value.length - 1;
            const startIndex = nextIndex;
            while (true) {
              if (store.value.getNode(treeItems.value[nextIndex].dataset.key).canFocus)
                break;
              nextIndex--;
              if (nextIndex === startIndex) {
                nextIndex = -1;
                break;
              }
              if (nextIndex < 0) {
                nextIndex = treeItems.value.length - 1;
              }
            }
          } else {
            nextIndex = currentIndex === -1 ? 0 : currentIndex < treeItems.value.length - 1 ? currentIndex + 1 : 0;
            const startIndex = nextIndex;
            while (true) {
              if (store.value.getNode(treeItems.value[nextIndex].dataset.key).canFocus)
                break;
              nextIndex++;
              if (nextIndex === startIndex) {
                nextIndex = -1;
                break;
              }
              if (nextIndex >= treeItems.value.length) {
                nextIndex = 0;
              }
            }
          }
          nextIndex !== -1 && treeItems.value[nextIndex].focus();
        }
        if ([EVENT_CODE.left, EVENT_CODE.right].includes(code)) {
          ev.preventDefault();
          currentItem.click();
        }
        const hasInput = currentItem.querySelector('[type="checkbox"]');
        if ([EVENT_CODE.enter, EVENT_CODE.space].includes(code) && hasInput) {
          ev.preventDefault();
          hasInput.click();
        }
      };
      useEventListener(el$, "keydown", handleKeydown);
      const initTabIndex = () => {
        var _a;
        treeItems.value = Array.from(el$.value.querySelectorAll(`.${ns.is("focusable")}[role=treeitem]`));
        checkboxItems.value = Array.from(el$.value.querySelectorAll("input[type=checkbox]"));
        const checkedItem = el$.value.querySelectorAll(`.${ns.is("checked")}[role=treeitem]`);
        if (checkedItem.length) {
          checkedItem[0].setAttribute("tabindex", "0");
          return;
        }
        (_a = treeItems.value[0]) == null ? void 0 : _a.setAttribute("tabindex", "0");
      };
    }
  
    const _sfc_main$a = vue.defineComponent({
      name: "ElTree",
      components: { ElTreeNode: ElTreeNode$1 },
      props: {
        data: {
          type: Array,
          default: () => []
        },
        emptyText: {
          type: String
        },
        renderAfterExpand: {
          type: Boolean,
          default: true
        },
        nodeKey: String,
        checkStrictly: Boolean,
        defaultExpandAll: Boolean,
        expandOnClickNode: {
          type: Boolean,
          default: true
        },
        checkOnClickNode: Boolean,
        checkDescendants: {
          type: Boolean,
          default: false
        },
        autoExpandParent: {
          type: Boolean,
          default: true
        },
        defaultCheckedKeys: Array,
        defaultExpandedKeys: Array,
        currentNodeKey: [String, Number],
        renderContent: Function,
        showCheckbox: {
          type: Boolean,
          default: false
        },
        draggable: {
          type: Boolean,
          default: false
        },
        allowDrag: Function,
        allowDrop: Function,
        props: {
          type: Object,
          default: () => ({
            children: "children",
            label: "label",
            disabled: "disabled"
          })
        },
        lazy: {
          type: Boolean,
          default: false
        },
        highlightCurrent: Boolean,
        load: Function,
        filterNodeMethod: Function,
        accordion: Boolean,
        indent: {
          type: Number,
          default: 18
        },
        icon: {
          type: iconPropType
        }
      },
      emits: [
        "check-change",
        "current-change",
        "node-click",
        "node-contextmenu",
        "node-collapse",
        "node-expand",
        "check",
        "node-drag-start",
        "node-drag-end",
        "node-drop",
        "node-drag-leave",
        "node-drag-enter",
        "node-drag-over"
      ],
      setup(props, ctx) {
        const { t } = useLocale();
        const ns = useNamespace("tree");
        const store = vue.ref(new TreeStore({
          key: props.nodeKey,
          data: props.data,
          lazy: props.lazy,
          props: props.props,
          load: props.load,
          currentNodeKey: props.currentNodeKey,
          checkStrictly: props.checkStrictly,
          checkDescendants: props.checkDescendants,
          defaultCheckedKeys: props.defaultCheckedKeys,
          defaultExpandedKeys: props.defaultExpandedKeys,
          autoExpandParent: props.autoExpandParent,
          defaultExpandAll: props.defaultExpandAll,
          filterNodeMethod: props.filterNodeMethod
        }));
        store.value.initialize();
        const root = vue.ref(store.value.root);
        const currentNode = vue.ref(null);
        const el$ = vue.ref(null);
        const dropIndicator$ = vue.ref(null);
        const { broadcastExpanded } = useNodeExpandEventBroadcast(props);
        const { dragState } = useDragNodeHandler({
          props,
          ctx,
          el$,
          dropIndicator$,
          store
        });
        useKeydown({ el$ }, store);
        const isEmpty = vue.computed(() => {
          const { childNodes } = root.value;
          return !childNodes || childNodes.length === 0 || childNodes.every(({ visible }) => !visible);
        });
        vue.watch(() => props.currentNodeKey, (newVal) => {
          store.value.setCurrentNodeKey(newVal);
        });
        vue.watch(() => props.defaultCheckedKeys, (newVal) => {
          store.value.setDefaultCheckedKey(newVal);
        });
        vue.watch(() => props.defaultExpandedKeys, (newVal) => {
          store.value.setDefaultExpandedKeys(newVal);
        });
        vue.watch(() => props.data, (newVal) => {
          store.value.setData(newVal);
        }, { deep: true });
        vue.watch(() => props.checkStrictly, (newVal) => {
          store.value.checkStrictly = newVal;
        });
        const filter = (value) => {
          if (!props.filterNodeMethod)
            throw new Error("[Tree] filterNodeMethod is required when filter");
          store.value.filter(value);
        };
        const getNodeKey$1 = (node) => {
          return getNodeKey(props.nodeKey, node.data);
        };
        const getNodePath = (data) => {
          if (!props.nodeKey)
            throw new Error("[Tree] nodeKey is required in getNodePath");
          const node = store.value.getNode(data);
          if (!node)
            return [];
          const path = [node.data];
          let parent = node.parent;
          while (parent && parent !== root.value) {
            path.push(parent.data);
            parent = parent.parent;
          }
          return path.reverse();
        };
        const getCheckedNodes = (leafOnly, includeHalfChecked) => {
          return store.value.getCheckedNodes(leafOnly, includeHalfChecked);
        };
        const getCheckedKeys = (leafOnly) => {
          return store.value.getCheckedKeys(leafOnly);
        };
        const getCurrentNode = () => {
          const currentNode2 = store.value.getCurrentNode();
          return currentNode2 ? currentNode2.data : null;
        };
        const getCurrentKey = () => {
          if (!props.nodeKey)
            throw new Error("[Tree] nodeKey is required in getCurrentKey");
          const currentNode2 = getCurrentNode();
          return currentNode2 ? currentNode2[props.nodeKey] : null;
        };
        const setCheckedNodes = (nodes, leafOnly) => {
          if (!props.nodeKey)
            throw new Error("[Tree] nodeKey is required in setCheckedNodes");
          store.value.setCheckedNodes(nodes, leafOnly);
        };
        const setCheckedKeys = (keys, leafOnly) => {
          if (!props.nodeKey)
            throw new Error("[Tree] nodeKey is required in setCheckedKeys");
          store.value.setCheckedKeys(keys, leafOnly);
        };
        const setChecked = (data, checked, deep) => {
          store.value.setChecked(data, checked, deep);
        };
        const getHalfCheckedNodes = () => {
          return store.value.getHalfCheckedNodes();
        };
        const getHalfCheckedKeys = () => {
          return store.value.getHalfCheckedKeys();
        };
        const setCurrentNode = (node, shouldAutoExpandParent = true) => {
          if (!props.nodeKey)
            throw new Error("[Tree] nodeKey is required in setCurrentNode");
          handleCurrentChange(store, ctx.emit, () => store.value.setUserCurrentNode(node, shouldAutoExpandParent));
        };
        const setCurrentKey = (key, shouldAutoExpandParent = true) => {
          if (!props.nodeKey)
            throw new Error("[Tree] nodeKey is required in setCurrentKey");
          handleCurrentChange(store, ctx.emit, () => store.value.setCurrentNodeKey(key, shouldAutoExpandParent));
        };
        const getNode = (data) => {
          return store.value.getNode(data);
        };
        const remove = (data) => {
          store.value.remove(data);
        };
        const append = (data, parentNode) => {
          store.value.append(data, parentNode);
        };
        const insertBefore = (data, refNode) => {
          store.value.insertBefore(data, refNode);
        };
        const insertAfter = (data, refNode) => {
          store.value.insertAfter(data, refNode);
        };
        const handleNodeExpand = (nodeData, node, instance) => {
          broadcastExpanded(node);
          ctx.emit("node-expand", nodeData, node, instance);
        };
        const updateKeyChildren = (key, data) => {
          if (!props.nodeKey)
            throw new Error("[Tree] nodeKey is required in updateKeyChild");
          store.value.updateChildren(key, data);
        };
        vue.provide("RootTree", {
          ctx,
          props,
          store,
          root,
          currentNode,
          instance: vue.getCurrentInstance()
        });
        vue.provide(formItemContextKey, void 0);
        return {
          ns,
          store,
          root,
          currentNode,
          dragState,
          el$,
          dropIndicator$,
          isEmpty,
          filter,
          getNodeKey: getNodeKey$1,
          getNodePath,
          getCheckedNodes,
          getCheckedKeys,
          getCurrentNode,
          getCurrentKey,
          setCheckedNodes,
          setCheckedKeys,
          setChecked,
          getHalfCheckedNodes,
          getHalfCheckedKeys,
          setCurrentNode,
          setCurrentKey,
          t,
          getNode,
          remove,
          append,
          insertBefore,
          insertAfter,
          handleNodeExpand,
          updateKeyChildren
        };
      }
    });
    function _sfc_render$1(_ctx, _cache, $props, $setup, $data, $options) {
      var _a;
      const _component_el_tree_node = vue.resolveComponent("el-tree-node");
      return vue.openBlock(), vue.createElementBlock("div", {
        ref: "el$",
        class: vue.normalizeClass([
          _ctx.ns.b(),
          _ctx.ns.is("dragging", !!_ctx.dragState.draggingNode),
          _ctx.ns.is("drop-not-allow", !_ctx.dragState.allowDrop),
          _ctx.ns.is("drop-inner", _ctx.dragState.dropType === "inner"),
          { [_ctx.ns.m("highlight-current")]: _ctx.highlightCurrent }
        ]),
        role: "tree"
      }, [
        (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(_ctx.root.childNodes, (child) => {
          return vue.openBlock(), vue.createBlock(_component_el_tree_node, {
            key: _ctx.getNodeKey(child),
            node: child,
            props: _ctx.props,
            accordion: _ctx.accordion,
            "render-after-expand": _ctx.renderAfterExpand,
            "show-checkbox": _ctx.showCheckbox,
            "render-content": _ctx.renderContent,
            onNodeExpand: _ctx.handleNodeExpand
          }, null, 8, ["node", "props", "accordion", "render-after-expand", "show-checkbox", "render-content", "onNodeExpand"]);
        }), 128)),
        _ctx.isEmpty ? (vue.openBlock(), vue.createElementBlock("div", {
          key: 0,
          class: vue.normalizeClass(_ctx.ns.e("empty-block"))
        }, [
          vue.createElementVNode("span", {
            class: vue.normalizeClass(_ctx.ns.e("empty-text"))
          }, vue.toDisplayString((_a = _ctx.emptyText) != null ? _a : _ctx.t("el.tree.emptyText")), 3)
        ], 2)) : vue.createCommentVNode("v-if", true),
        vue.withDirectives(vue.createElementVNode("div", {
          ref: "dropIndicator$",
          class: vue.normalizeClass(_ctx.ns.e("drop-indicator"))
        }, null, 2), [
          [vue.vShow, _ctx.dragState.showDropIndicator]
        ])
      ], 2);
    }
    var Tree = /* @__PURE__ */ _export_sfc(_sfc_main$a, [["render", _sfc_render$1], ["__file", "tree.vue"]]);
  
    Tree.install = (app) => {
      app.component(Tree.name, Tree);
    };
    const _Tree = Tree;
    const ElTree = _Tree;
  
    const useSelect = (props, { attrs }, {
      tree,
      key
    }) => {
      const ns = useNamespace("tree-select");
      const result = {
        ...pick(vue.toRefs(props), Object.keys(ElSelect.props)),
        ...attrs,
        valueKey: key,
        popperClass: vue.computed(() => {
          const classes = [ns.e("popper")];
          if (props.popperClass)
            classes.push(props.popperClass);
          return classes.join(" ");
        }),
        filterMethod: (keyword = "") => {
          if (props.filterMethod)
            props.filterMethod(keyword);
          vue.nextTick(() => {
            var _a;
            (_a = tree.value) == null ? void 0 : _a.filter(keyword);
          });
        },
        onVisibleChange: (visible) => {
          var _a;
          (_a = attrs.onVisibleChange) == null ? void 0 : _a.call(attrs, visible);
          if (props.filterable && visible) {
            result.filterMethod();
          }
        }
      };
      return result;
    };
  
    const component = vue.defineComponent({
      extends: ElOption,
      setup(props, ctx) {
        const result = ElOption.setup(props, ctx);
        delete result.selectOptionClick;
        const vm = vue.getCurrentInstance().proxy;
        vue.nextTick(() => {
          if (!result.select.cachedOptions.get(vm.value)) {
            result.select.onOptionCreate(vm);
          }
        });
        return result;
      },
      methods: {
        selectOptionClick() {
          this.$el.parentElement.click();
        }
      }
    });
    var TreeSelectOption = component;
  
    function isValidValue(val) {
      return val || val === 0;
    }
    function isValidArray(val) {
      return Array.isArray(val) && val.length;
    }
    function toValidArray(val) {
      return Array.isArray(val) ? val : isValidValue(val) ? [val] : [];
    }
    function treeFind(treeData, findCallback, getChildren, resultCallback, parent) {
      for (let i = 0; i < treeData.length; i++) {
        const data = treeData[i];
        if (findCallback(data, i, treeData, parent)) {
          return resultCallback ? resultCallback(data, i, treeData, parent) : data;
        } else {
          const children = getChildren(data);
          if (isValidArray(children)) {
            const find = treeFind(children, findCallback, getChildren, resultCallback, data);
            if (find)
              return find;
          }
        }
      }
    }
  
    const useTree$1 = (props, { attrs, slots, emit }, {
      select,
      tree,
      key
    }) => {
      vue.watch(() => props.modelValue, () => {
        if (props.showCheckbox) {
          vue.nextTick(() => {
            const treeInstance = tree.value;
            if (treeInstance && !isEqual$1(treeInstance.getCheckedKeys(), toValidArray(props.modelValue))) {
              treeInstance.setCheckedKeys(toValidArray(props.modelValue));
            }
          });
        }
      }, {
        immediate: true,
        deep: true
      });
      const propsMap = vue.computed(() => ({
        value: key.value,
        ...props.props
      }));
      const getNodeValByProp = (prop, data) => {
        var _a;
        const propVal = propsMap.value[prop];
        if (isFunction(propVal)) {
          return propVal(data, (_a = tree.value) == null ? void 0 : _a.getNode(getNodeValByProp("value", data)));
        } else {
          return data[propVal];
        }
      };
      const defaultExpandedParentKeys = toValidArray(props.modelValue).map((value) => {
        return treeFind(props.data || [], (data) => getNodeValByProp("value", data) === value, (data) => getNodeValByProp("children", data), (data, index, array, parent) => parent && getNodeValByProp("value", parent));
      }).filter((item) => isValidValue(item));
      return {
        ...pick(vue.toRefs(props), Object.keys(_Tree.props)),
        ...attrs,
        nodeKey: key,
        expandOnClickNode: vue.computed(() => {
          return !props.checkStrictly && props.expandOnClickNode;
        }),
        defaultExpandedKeys: vue.computed(() => {
          return props.defaultExpandedKeys ? props.defaultExpandedKeys.concat(defaultExpandedParentKeys) : defaultExpandedParentKeys;
        }),
        renderContent: (h, { node, data, store }) => {
          return h(TreeSelectOption, {
            value: getNodeValByProp("value", data),
            label: getNodeValByProp("label", data),
            disabled: getNodeValByProp("disabled", data)
          }, props.renderContent ? () => props.renderContent(h, { node, data, store }) : slots.default ? () => slots.default({ node, data, store }) : void 0);
        },
        filterNodeMethod: (value, data, node) => {
          var _a;
          if (props.filterNodeMethod)
            return props.filterNodeMethod(value, data, node);
          if (!value)
            return true;
          return (_a = getNodeValByProp("label", data)) == null ? void 0 : _a.includes(value);
        },
        onNodeClick: (data, node, e) => {
          var _a, _b, _c;
          (_a = attrs.onNodeClick) == null ? void 0 : _a.call(attrs, data, node, e);
          if (props.showCheckbox && props.checkOnClickNode)
            return;
          if (!props.showCheckbox && (props.checkStrictly || node.isLeaf)) {
            if (!getNodeValByProp("disabled", data)) {
              const option = (_b = select.value) == null ? void 0 : _b.options.get(getNodeValByProp("value", data));
              (_c = select.value) == null ? void 0 : _c.handleOptionSelect(option, true);
            }
          } else if (props.expandOnClickNode) {
            e.proxy.handleExpandIconClick();
          }
        },
        onCheck: (data, params) => {
          var _a;
          (_a = attrs.onCheck) == null ? void 0 : _a.call(attrs, data, params);
          const dataValue = getNodeValByProp("value", data);
          if (props.checkStrictly) {
            emit(UPDATE_MODEL_EVENT, props.multiple ? params.checkedKeys : params.checkedKeys.includes(dataValue) ? dataValue : void 0);
          } else {
            if (props.multiple) {
              emit(UPDATE_MODEL_EVENT, tree.value.getCheckedKeys(true));
            } else {
              const firstLeaf = treeFind([data], (data2) => !isValidArray(getNodeValByProp("children", data2)) && !getNodeValByProp("disabled", data2), (data2) => getNodeValByProp("children", data2));
              const firstLeafKey = firstLeaf ? getNodeValByProp("value", firstLeaf) : void 0;
              const hasCheckedChild = isValidValue(props.modelValue) && !!treeFind([data], (data2) => getNodeValByProp("value", data2) === props.modelValue, (data2) => getNodeValByProp("children", data2));
              emit(UPDATE_MODEL_EVENT, firstLeafKey === props.modelValue || hasCheckedChild ? void 0 : firstLeafKey);
            }
          }
        }
      };
    };
  
    const _sfc_main$9 = vue.defineComponent({
      name: "ElTreeSelect",
      inheritAttrs: false,
      props: {
        ...ElSelect.props,
        ..._Tree.props
      },
      setup(props, context) {
        const { slots, expose } = context;
        const select = vue.ref();
        const tree = vue.ref();
        const key = vue.computed(() => props.nodeKey || props.valueKey || "value");
        const selectProps = useSelect(props, context, { select, tree, key });
        const treeProps = useTree$1(props, context, { select, tree, key });
        const methods = vue.reactive({});
        expose(methods);
        vue.onMounted(() => {
          Object.assign(methods, {
            ...pick(tree.value, [
              "filter",
              "updateKeyChildren",
              "getCheckedNodes",
              "setCheckedNodes",
              "getCheckedKeys",
              "setCheckedKeys",
              "setChecked",
              "getHalfCheckedNodes",
              "getHalfCheckedKeys",
              "getCurrentKey",
              "getCurrentNode",
              "setCurrentKey",
              "setCurrentNode",
              "getNode",
              "remove",
              "append",
              "insertBefore",
              "insertAfter"
            ]),
            ...pick(select.value, ["focus", "blur"])
          });
        });
        return () => vue.h(ElSelect, vue.reactive({
          ...selectProps,
          ref: (ref2) => select.value = ref2
        }), {
          ...slots,
          default: () => vue.h(_Tree, vue.reactive({
            ...treeProps,
            ref: (ref2) => tree.value = ref2
          }))
        });
      }
    });
    var TreeSelect = /* @__PURE__ */ _export_sfc(_sfc_main$9, [["__file", "tree-select.vue"]]);
  
    TreeSelect.install = (app) => {
      app.component(TreeSelect.name, TreeSelect);
    };
    const _TreeSelect = TreeSelect;
    const ElTreeSelect = _TreeSelect;
  
    const ROOT_TREE_INJECTION_KEY = Symbol();
    const EMPTY_NODE = {
      key: -1,
      level: -1,
      data: {}
    };
    var TreeOptionsEnum = /* @__PURE__ */ ((TreeOptionsEnum2) => {
      TreeOptionsEnum2["KEY"] = "id";
      TreeOptionsEnum2["LABEL"] = "label";
      TreeOptionsEnum2["CHILDREN"] = "children";
      TreeOptionsEnum2["DISABLED"] = "disabled";
      return TreeOptionsEnum2;
    })(TreeOptionsEnum || {});
    var SetOperationEnum = /* @__PURE__ */ ((SetOperationEnum2) => {
      SetOperationEnum2["ADD"] = "add";
      SetOperationEnum2["DELETE"] = "delete";
      return SetOperationEnum2;
    })(SetOperationEnum || {});
    const treeProps = buildProps({
      data: {
        type: definePropType(Array),
        default: () => mutable([])
      },
      emptyText: {
        type: String
      },
      height: {
        type: Number,
        default: 200
      },
      props: {
        type: definePropType(Object),
        default: () => mutable({
          children: "children" /* CHILDREN */,
          label: "label" /* LABEL */,
          disabled: "disabled" /* DISABLED */,
          value: "id" /* KEY */
        })
      },
      highlightCurrent: {
        type: Boolean,
        default: false
      },
      showCheckbox: {
        type: Boolean,
        default: false
      },
      defaultCheckedKeys: {
        type: definePropType(Array),
        default: () => mutable([])
      },
      checkStrictly: {
        type: Boolean,
        default: false
      },
      defaultExpandedKeys: {
        type: definePropType(Array),
        default: () => mutable([])
      },
      indent: {
        type: Number,
        default: 16
      },
      icon: {
        type: iconPropType
      },
      expandOnClickNode: {
        type: Boolean,
        default: true
      },
      checkOnClickNode: {
        type: Boolean,
        default: false
      },
      currentNodeKey: {
        type: definePropType([String, Number])
      },
      accordion: {
        type: Boolean,
        default: false
      },
      filterMethod: {
        type: definePropType(Function)
      },
      perfMode: {
        type: Boolean,
        default: true
      }
    });
    const treeNodeProps = buildProps({
      node: {
        type: definePropType(Object),
        default: () => mutable(EMPTY_NODE)
      },
      expanded: {
        type: Boolean,
        default: false
      },
      checked: {
        type: Boolean,
        default: false
      },
      indeterminate: {
        type: Boolean,
        default: false
      },
      showCheckbox: {
        type: Boolean,
        default: false
      },
      disabled: {
        type: Boolean,
        default: false
      },
      current: {
        type: Boolean,
        default: false
      },
      hiddenExpandIcon: {
        type: Boolean,
        default: false
      }
    });
    const treeNodeContentProps = buildProps({
      node: {
        type: definePropType(Object),
        required: true
      }
    });
    const NODE_CLICK = "node-click";
    const NODE_EXPAND = "node-expand";
    const NODE_COLLAPSE = "node-collapse";
    const CURRENT_CHANGE = "current-change";
    const NODE_CHECK = "check";
    const NODE_CHECK_CHANGE = "check-change";
    const NODE_CONTEXTMENU = "node-contextmenu";
    const treeEmits = {
      [NODE_CLICK]: (data, node, e) => data && node && e,
      [NODE_EXPAND]: (data, node) => data && node,
      [NODE_COLLAPSE]: (data, node) => data && node,
      [CURRENT_CHANGE]: (data, node) => data && node,
      [NODE_CHECK]: (data, checkedInfo) => data && checkedInfo,
      [NODE_CHECK_CHANGE]: (data, checked) => data && typeof checked === "boolean",
      [NODE_CONTEXTMENU]: (event, data, node) => event && data && node
    };
    const treeNodeEmits = {
      click: (node, e) => !!(node && e),
      toggle: (node) => !!node,
      check: (node, checked) => node && typeof checked === "boolean"
    };
  
    function useCheck(props, tree) {
      const checkedKeys = vue.ref(/* @__PURE__ */ new Set());
      const indeterminateKeys = vue.ref(/* @__PURE__ */ new Set());
      const { emit } = vue.getCurrentInstance();
      vue.watch([() => tree.value, () => props.defaultCheckedKeys], () => {
        return vue.nextTick(() => {
          _setCheckedKeys(props.defaultCheckedKeys);
        });
      }, {
        immediate: true
      });
      const updateCheckedKeys = () => {
        if (!tree.value || !props.showCheckbox || props.checkStrictly) {
          return;
        }
        const { levelTreeNodeMap, maxLevel } = tree.value;
        const checkedKeySet = checkedKeys.value;
        const indeterminateKeySet = /* @__PURE__ */ new Set();
        for (let level = maxLevel - 1; level >= 1; --level) {
          const nodes = levelTreeNodeMap.get(level);
          if (!nodes)
            continue;
          nodes.forEach((node) => {
            const children = node.children;
            if (children) {
              let allChecked = true;
              let hasChecked = false;
              for (const childNode of children) {
                const key = childNode.key;
                if (checkedKeySet.has(key)) {
                  hasChecked = true;
                } else if (indeterminateKeySet.has(key)) {
                  allChecked = false;
                  hasChecked = true;
                  break;
                } else {
                  allChecked = false;
                }
              }
              if (allChecked) {
                checkedKeySet.add(node.key);
              } else if (hasChecked) {
                indeterminateKeySet.add(node.key);
                checkedKeySet.delete(node.key);
              } else {
                checkedKeySet.delete(node.key);
                indeterminateKeySet.delete(node.key);
              }
            }
          });
        }
        indeterminateKeys.value = indeterminateKeySet;
      };
      const isChecked = (node) => checkedKeys.value.has(node.key);
      const isIndeterminate = (node) => indeterminateKeys.value.has(node.key);
      const toggleCheckbox = (node, isChecked2, nodeClick = true) => {
        const checkedKeySet = checkedKeys.value;
        const toggle = (node2, checked) => {
          checkedKeySet[checked ? SetOperationEnum.ADD : SetOperationEnum.DELETE](node2.key);
          const children = node2.children;
          if (!props.checkStrictly && children) {
            children.forEach((childNode) => {
              if (!childNode.disabled) {
                toggle(childNode, checked);
              }
            });
          }
        };
        toggle(node, isChecked2);
        updateCheckedKeys();
        if (nodeClick) {
          afterNodeCheck(node, isChecked2);
        }
      };
      const afterNodeCheck = (node, checked) => {
        const { checkedNodes, checkedKeys: checkedKeys2 } = getChecked();
        const { halfCheckedNodes, halfCheckedKeys } = getHalfChecked();
        emit(NODE_CHECK, node.data, {
          checkedKeys: checkedKeys2,
          checkedNodes,
          halfCheckedKeys,
          halfCheckedNodes
        });
        emit(NODE_CHECK_CHANGE, node.data, checked);
      };
      function getCheckedKeys(leafOnly = false) {
        return getChecked(leafOnly).checkedKeys;
      }
      function getCheckedNodes(leafOnly = false) {
        return getChecked(leafOnly).checkedNodes;
      }
      function getHalfCheckedKeys() {
        return getHalfChecked().halfCheckedKeys;
      }
      function getHalfCheckedNodes() {
        return getHalfChecked().halfCheckedNodes;
      }
      function getChecked(leafOnly = false) {
        const checkedNodes = [];
        const keys = [];
        if ((tree == null ? void 0 : tree.value) && props.showCheckbox) {
          const { treeNodeMap } = tree.value;
          checkedKeys.value.forEach((key) => {
            const node = treeNodeMap.get(key);
            if (node && (!leafOnly || leafOnly && node.isLeaf)) {
              keys.push(key);
              checkedNodes.push(node.data);
            }
          });
        }
        return {
          checkedKeys: keys,
          checkedNodes
        };
      }
      function getHalfChecked() {
        const halfCheckedNodes = [];
        const halfCheckedKeys = [];
        if ((tree == null ? void 0 : tree.value) && props.showCheckbox) {
          const { treeNodeMap } = tree.value;
          indeterminateKeys.value.forEach((key) => {
            const node = treeNodeMap.get(key);
            if (node) {
              halfCheckedKeys.push(key);
              halfCheckedNodes.push(node.data);
            }
          });
        }
        return {
          halfCheckedNodes,
          halfCheckedKeys
        };
      }
      function setCheckedKeys(keys) {
        checkedKeys.value.clear();
        indeterminateKeys.value.clear();
        _setCheckedKeys(keys);
      }
      function setChecked(key, isChecked2) {
        if ((tree == null ? void 0 : tree.value) && props.showCheckbox) {
          const node = tree.value.treeNodeMap.get(key);
          if (node) {
            toggleCheckbox(node, isChecked2, false);
          }
        }
      }
      function _setCheckedKeys(keys) {
        if (tree == null ? void 0 : tree.value) {
          const { treeNodeMap } = tree.value;
          if (props.showCheckbox && treeNodeMap && keys) {
            for (const key of keys) {
              const node = treeNodeMap.get(key);
              if (node && !isChecked(node)) {
                toggleCheckbox(node, true, false);
              }
            }
          }
        }
      }
      return {
        updateCheckedKeys,
        toggleCheckbox,
        isChecked,
        isIndeterminate,
        getCheckedKeys,
        getCheckedNodes,
        getHalfCheckedKeys,
        getHalfCheckedNodes,
        setChecked,
        setCheckedKeys
      };
    }
  
    function useFilter(props, tree) {
      const hiddenNodeKeySet = vue.ref(/* @__PURE__ */ new Set([]));
      const hiddenExpandIconKeySet = vue.ref(/* @__PURE__ */ new Set([]));
      const filterable = vue.computed(() => {
        return isFunction(props.filterMethod);
      });
      function doFilter(query) {
        var _a;
        if (!filterable.value) {
          return;
        }
        const expandKeySet = /* @__PURE__ */ new Set();
        const hiddenExpandIconKeys = hiddenExpandIconKeySet.value;
        const hiddenKeys = hiddenNodeKeySet.value;
        const family = [];
        const nodes = ((_a = tree.value) == null ? void 0 : _a.treeNodes) || [];
        const filter = props.filterMethod;
        hiddenKeys.clear();
        function traverse(nodes2) {
          nodes2.forEach((node) => {
            family.push(node);
            if (filter == null ? void 0 : filter(query, node.data)) {
              family.forEach((member) => {
                expandKeySet.add(member.key);
              });
            } else if (node.isLeaf) {
              hiddenKeys.add(node.key);
            }
            const children = node.children;
            if (children) {
              traverse(children);
            }
            if (!node.isLeaf) {
              if (!expandKeySet.has(node.key)) {
                hiddenKeys.add(node.key);
              } else if (children) {
                let allHidden = true;
                for (const childNode of children) {
                  if (!hiddenKeys.has(childNode.key)) {
                    allHidden = false;
                    break;
                  }
                }
                if (allHidden) {
                  hiddenExpandIconKeys.add(node.key);
                } else {
                  hiddenExpandIconKeys.delete(node.key);
                }
              }
            }
            family.pop();
          });
        }
        traverse(nodes);
        return expandKeySet;
      }
      function isForceHiddenExpandIcon(node) {
        return hiddenExpandIconKeySet.value.has(node.key);
      }
      return {
        hiddenExpandIconKeySet,
        hiddenNodeKeySet,
        doFilter,
        isForceHiddenExpandIcon
      };
    }
  
    function useTree(props, emit) {
      const expandedKeySet = vue.ref(new Set(props.defaultExpandedKeys));
      const currentKey = vue.ref();
      const tree = vue.shallowRef();
      vue.watch(() => props.currentNodeKey, (key) => {
        currentKey.value = key;
      }, {
        immediate: true
      });
      vue.watch(() => props.data, (data) => {
        setData(data);
      }, {
        immediate: true
      });
      const {
        isIndeterminate,
        isChecked,
        toggleCheckbox,
        getCheckedKeys,
        getCheckedNodes,
        getHalfCheckedKeys,
        getHalfCheckedNodes,
        setChecked,
        setCheckedKeys
      } = useCheck(props, tree);
      const { doFilter, hiddenNodeKeySet, isForceHiddenExpandIcon } = useFilter(props, tree);
      const valueKey = vue.computed(() => {
        var _a;
        return ((_a = props.props) == null ? void 0 : _a.value) || TreeOptionsEnum.KEY;
      });
      const childrenKey = vue.computed(() => {
        var _a;
        return ((_a = props.props) == null ? void 0 : _a.children) || TreeOptionsEnum.CHILDREN;
      });
      const disabledKey = vue.computed(() => {
        var _a;
        return ((_a = props.props) == null ? void 0 : _a.disabled) || TreeOptionsEnum.DISABLED;
      });
      const labelKey = vue.computed(() => {
        var _a;
        return ((_a = props.props) == null ? void 0 : _a.label) || TreeOptionsEnum.LABEL;
      });
      const flattenTree = vue.computed(() => {
        const expandedKeys = expandedKeySet.value;
        const hiddenKeys = hiddenNodeKeySet.value;
        const flattenNodes = [];
        const nodes = tree.value && tree.value.treeNodes || [];
        function traverse() {
          const stack = [];
          for (let i = nodes.length - 1; i >= 0; --i) {
            stack.push(nodes[i]);
          }
          while (stack.length) {
            const node = stack.pop();
            if (!node)
              continue;
            if (!hiddenKeys.has(node.key)) {
              flattenNodes.push(node);
            }
            if (expandedKeys.has(node.key)) {
              const children = node.children;
              if (children) {
                const length = children.length;
                for (let i = length - 1; i >= 0; --i) {
                  stack.push(children[i]);
                }
              }
            }
          }
        }
        traverse();
        return flattenNodes;
      });
      const isNotEmpty = vue.computed(() => {
        return flattenTree.value.length > 0;
      });
      function createTree(data) {
        const treeNodeMap = /* @__PURE__ */ new Map();
        const levelTreeNodeMap = /* @__PURE__ */ new Map();
        let maxLevel = 1;
        function traverse(nodes, level = 1, parent = void 0) {
          var _a;
          const siblings = [];
          for (const rawNode of nodes) {
            const value = getKey(rawNode);
            const node = {
              level,
              key: value,
              data: rawNode
            };
            node.label = getLabel(rawNode);
            node.parent = parent;
            const children = getChildren(rawNode);
            node.disabled = getDisabled(rawNode);
            node.isLeaf = !children || children.length === 0;
            if (children && children.length) {
              node.children = traverse(children, level + 1, node);
            }
            siblings.push(node);
            treeNodeMap.set(value, node);
            if (!levelTreeNodeMap.has(level)) {
              levelTreeNodeMap.set(level, []);
            }
            (_a = levelTreeNodeMap.get(level)) == null ? void 0 : _a.push(node);
          }
          if (level > maxLevel) {
            maxLevel = level;
          }
          return siblings;
        }
        const treeNodes = traverse(data);
        return {
          treeNodeMap,
          levelTreeNodeMap,
          maxLevel,
          treeNodes
        };
      }
      function filter(query) {
        const keys = doFilter(query);
        if (keys) {
          expandedKeySet.value = keys;
        }
      }
      function getChildren(node) {
        return node[childrenKey.value];
      }
      function getKey(node) {
        if (!node) {
          return "";
        }
        return node[valueKey.value];
      }
      function getDisabled(node) {
        return node[disabledKey.value];
      }
      function getLabel(node) {
        return node[labelKey.value];
      }
      function toggleExpand(node) {
        const expandedKeys = expandedKeySet.value;
        if (expandedKeys.has(node.key)) {
          collapseNode(node);
        } else {
          expandNode(node);
        }
      }
      function setExpandedKeys(keys) {
        expandedKeySet.value = new Set(keys);
      }
      function handleNodeClick(node, e) {
        emit(NODE_CLICK, node.data, node, e);
        handleCurrentChange(node);
        if (props.expandOnClickNode) {
          toggleExpand(node);
        }
        if (props.showCheckbox && props.checkOnClickNode && !node.disabled) {
          toggleCheckbox(node, !isChecked(node), true);
        }
      }
      function handleCurrentChange(node) {
        if (!isCurrent(node)) {
          currentKey.value = node.key;
          emit(CURRENT_CHANGE, node.data, node);
        }
      }
      function handleNodeCheck(node, checked) {
        toggleCheckbox(node, checked);
      }
      function expandNode(node) {
        const keySet = expandedKeySet.value;
        if (tree.value && props.accordion) {
          const { treeNodeMap } = tree.value;
          keySet.forEach((key) => {
            const treeNode = treeNodeMap.get(key);
            if (node && node.level === (treeNode == null ? void 0 : treeNode.level)) {
              keySet.delete(key);
            }
          });
        }
        keySet.add(node.key);
        emit(NODE_EXPAND, node.data, node);
      }
      function collapseNode(node) {
        expandedKeySet.value.delete(node.key);
        emit(NODE_COLLAPSE, node.data, node);
      }
      function isExpanded(node) {
        return expandedKeySet.value.has(node.key);
      }
      function isDisabled(node) {
        return !!node.disabled;
      }
      function isCurrent(node) {
        const current = currentKey.value;
        return !!current && current === node.key;
      }
      function getCurrentNode() {
        var _a, _b;
        if (!currentKey.value)
          return void 0;
        return (_b = (_a = tree.value) == null ? void 0 : _a.treeNodeMap.get(currentKey.value)) == null ? void 0 : _b.data;
      }
      function getCurrentKey() {
        return currentKey.value;
      }
      function setCurrentKey(key) {
        currentKey.value = key;
      }
      function setData(data) {
        vue.nextTick(() => tree.value = createTree(data));
      }
      function getNode(data) {
        var _a;
        const key = isObject$1(data) ? getKey(data) : data;
        return (_a = tree.value) == null ? void 0 : _a.treeNodeMap.get(key);
      }
      return {
        tree,
        flattenTree,
        isNotEmpty,
        getKey,
        getChildren,
        toggleExpand,
        toggleCheckbox,
        isExpanded,
        isChecked,
        isIndeterminate,
        isDisabled,
        isCurrent,
        isForceHiddenExpandIcon,
        handleNodeClick,
        handleNodeCheck,
        getCurrentNode,
        getCurrentKey,
        setCurrentKey,
        getCheckedKeys,
        getCheckedNodes,
        getHalfCheckedKeys,
        getHalfCheckedNodes,
        setChecked,
        setCheckedKeys,
        filter,
        setData,
        getNode,
        expandNode,
        collapseNode,
        setExpandedKeys
      };
    }
  
    var ElNodeContent = vue.defineComponent({
      name: "ElTreeNodeContent",
      props: treeNodeContentProps,
      setup(props) {
        const tree = vue.inject(ROOT_TREE_INJECTION_KEY);
        const ns = useNamespace("tree");
        return () => {
          const node = props.node;
          const { data } = node;
          return (tree == null ? void 0 : tree.ctx.slots.default) ? tree.ctx.slots.default({ node, data }) : vue.h("span", { class: ns.be("node", "label") }, [node == null ? void 0 : node.label]);
        };
      }
    });
  
    const _hoisted_1$6 = ["aria-expanded", "aria-disabled", "aria-checked", "data-key", "onClick"];
    const __default__$7 = vue.defineComponent({
      name: "ElTreeNode"
    });
    const _sfc_main$8 = /* @__PURE__ */ vue.defineComponent({
      ...__default__$7,
      props: treeNodeProps,
      emits: treeNodeEmits,
      setup(__props, { emit }) {
        const props = __props;
        const tree = vue.inject(ROOT_TREE_INJECTION_KEY);
        const ns = useNamespace("tree");
        const indent = vue.computed(() => {
          var _a;
          return (_a = tree == null ? void 0 : tree.props.indent) != null ? _a : 16;
        });
        const icon = vue.computed(() => {
          var _a;
          return (_a = tree == null ? void 0 : tree.props.icon) != null ? _a : caret_right_default;
        });
        const handleClick = (e) => {
          emit("click", props.node, e);
        };
        const handleExpandIconClick = () => {
          emit("toggle", props.node);
        };
        const handleCheckChange = (value) => {
          emit("check", props.node, value);
        };
        const handleContextMenu = (event) => {
          var _a, _b, _c, _d;
          if ((_c = (_b = (_a = tree == null ? void 0 : tree.instance) == null ? void 0 : _a.vnode) == null ? void 0 : _b.props) == null ? void 0 : _c["onNodeContextmenu"]) {
            event.stopPropagation();
            event.preventDefault();
          }
          tree == null ? void 0 : tree.ctx.emit(NODE_CONTEXTMENU, event, (_d = props.node) == null ? void 0 : _d.data, props.node);
        };
        return (_ctx, _cache) => {
          var _a, _b, _c;
          return vue.openBlock(), vue.createElementBlock("div", {
            ref: "node$",
            class: vue.normalizeClass([
              vue.unref(ns).b("node"),
              vue.unref(ns).is("expanded", _ctx.expanded),
              vue.unref(ns).is("current", _ctx.current),
              vue.unref(ns).is("focusable", !_ctx.disabled),
              vue.unref(ns).is("checked", !_ctx.disabled && _ctx.checked)
            ]),
            role: "treeitem",
            tabindex: "-1",
            "aria-expanded": _ctx.expanded,
            "aria-disabled": _ctx.disabled,
            "aria-checked": _ctx.checked,
            "data-key": (_a = _ctx.node) == null ? void 0 : _a.key,
            onClick: vue.withModifiers(handleClick, ["stop"]),
            onContextmenu: handleContextMenu
          }, [
            vue.createElementVNode("div", {
              class: vue.normalizeClass(vue.unref(ns).be("node", "content")),
              style: vue.normalizeStyle({ paddingLeft: `${(_ctx.node.level - 1) * vue.unref(indent)}px` })
            }, [
              vue.unref(icon) ? (vue.openBlock(), vue.createBlock(vue.unref(ElIcon), {
                key: 0,
                class: vue.normalizeClass([
                  vue.unref(ns).is("leaf", !!((_b = _ctx.node) == null ? void 0 : _b.isLeaf)),
                  vue.unref(ns).is("hidden", _ctx.hiddenExpandIcon),
                  {
                    expanded: !((_c = _ctx.node) == null ? void 0 : _c.isLeaf) && _ctx.expanded
                  },
                  vue.unref(ns).be("node", "expand-icon")
                ]),
                onClick: vue.withModifiers(handleExpandIconClick, ["stop"])
              }, {
                default: vue.withCtx(() => [
                  (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(vue.unref(icon))))
                ]),
                _: 1
              }, 8, ["class", "onClick"])) : vue.createCommentVNode("v-if", true),
              _ctx.showCheckbox ? (vue.openBlock(), vue.createBlock(vue.unref(ElCheckbox), {
                key: 1,
                "model-value": _ctx.checked,
                indeterminate: _ctx.indeterminate,
                disabled: _ctx.disabled,
                onChange: handleCheckChange,
                onClick: _cache[0] || (_cache[0] = vue.withModifiers(() => {
                }, ["stop"]))
              }, null, 8, ["model-value", "indeterminate", "disabled"])) : vue.createCommentVNode("v-if", true),
              vue.createVNode(vue.unref(ElNodeContent), { node: _ctx.node }, null, 8, ["node"])
            ], 6)
          ], 42, _hoisted_1$6);
        };
      }
    });
    var ElTreeNode = /* @__PURE__ */ _export_sfc(_sfc_main$8, [["__file", "tree-node.vue"]]);
  
    const itemSize = 26;
    const __default__$6 = vue.defineComponent({
      name: "ElTreeV2"
    });
    const _sfc_main$7 = /* @__PURE__ */ vue.defineComponent({
      ...__default__$6,
      props: treeProps,
      emits: treeEmits,
      setup(__props, { expose, emit }) {
        const props = __props;
        const slots = vue.useSlots();
        vue.provide(ROOT_TREE_INJECTION_KEY, {
          ctx: {
            emit,
            slots
          },
          props,
          instance: vue.getCurrentInstance()
        });
        vue.provide(formItemContextKey, void 0);
        const { t } = useLocale();
        const ns = useNamespace("tree");
        const {
          flattenTree,
          isNotEmpty,
          toggleExpand,
          isExpanded,
          isIndeterminate,
          isChecked,
          isDisabled,
          isCurrent,
          isForceHiddenExpandIcon,
          handleNodeClick,
          handleNodeCheck,
          toggleCheckbox,
          getCurrentNode,
          getCurrentKey,
          setCurrentKey,
          getCheckedKeys,
          getCheckedNodes,
          getHalfCheckedKeys,
          getHalfCheckedNodes,
          setChecked,
          setCheckedKeys,
          filter,
          setData,
          getNode,
          expandNode,
          collapseNode,
          setExpandedKeys
        } = useTree(props, emit);
        expose({
          toggleCheckbox,
          getCurrentNode,
          getCurrentKey,
          setCurrentKey,
          getCheckedKeys,
          getCheckedNodes,
          getHalfCheckedKeys,
          getHalfCheckedNodes,
          setChecked,
          setCheckedKeys,
          filter,
          setData,
          getNode,
          expandNode,
          collapseNode,
          setExpandedKeys
        });
        return (_ctx, _cache) => {
          var _a;
          return vue.openBlock(), vue.createElementBlock("div", {
            class: vue.normalizeClass([vue.unref(ns).b(), { [vue.unref(ns).m("highlight-current")]: _ctx.highlightCurrent }]),
            role: "tree"
          }, [
            vue.unref(isNotEmpty) ? (vue.openBlock(), vue.createBlock(vue.unref(FixedSizeList$1), {
              key: 0,
              "class-name": vue.unref(ns).b("virtual-list"),
              data: vue.unref(flattenTree),
              total: vue.unref(flattenTree).length,
              height: _ctx.height,
              "item-size": itemSize,
              "perf-mode": _ctx.perfMode
            }, {
              default: vue.withCtx(({ data, index, style }) => [
                (vue.openBlock(), vue.createBlock(ElTreeNode, {
                  key: data[index].key,
                  style: vue.normalizeStyle(style),
                  node: data[index],
                  expanded: vue.unref(isExpanded)(data[index]),
                  "show-checkbox": _ctx.showCheckbox,
                  checked: vue.unref(isChecked)(data[index]),
                  indeterminate: vue.unref(isIndeterminate)(data[index]),
                  disabled: vue.unref(isDisabled)(data[index]),
                  current: vue.unref(isCurrent)(data[index]),
                  "hidden-expand-icon": vue.unref(isForceHiddenExpandIcon)(data[index]),
                  onClick: vue.unref(handleNodeClick),
                  onToggle: vue.unref(toggleExpand),
                  onCheck: vue.unref(handleNodeCheck)
                }, null, 8, ["style", "node", "expanded", "show-checkbox", "checked", "indeterminate", "disabled", "current", "hidden-expand-icon", "onClick", "onToggle", "onCheck"]))
              ]),
              _: 1
            }, 8, ["class-name", "data", "total", "height", "perf-mode"])) : (vue.openBlock(), vue.createElementBlock("div", {
              key: 1,
              class: vue.normalizeClass(vue.unref(ns).e("empty-block"))
            }, [
              vue.createElementVNode("span", {
                class: vue.normalizeClass(vue.unref(ns).e("empty-text"))
              }, vue.toDisplayString((_a = _ctx.emptyText) != null ? _a : vue.unref(t)("el.tree.emptyText")), 3)
            ], 2))
          ], 2);
        };
      }
    });
    var TreeV2 = /* @__PURE__ */ _export_sfc(_sfc_main$7, [["__file", "tree.vue"]]);
  
    const ElTreeV2 = withInstall(TreeV2);
  
    const SCOPE$2 = "ElUpload";
    class UploadAjaxError extends Error {
      constructor(message, status, method, url) {
        super(message);
        this.name = "UploadAjaxError";
        this.status = status;
        this.method = method;
        this.url = url;
      }
    }
    function getError(action, option, xhr) {
      let msg;
      if (xhr.response) {
        msg = `${xhr.response.error || xhr.response}`;
      } else if (xhr.responseText) {
        msg = `${xhr.responseText}`;
      } else {
        msg = `fail to ${option.method} ${action} ${xhr.status}`;
      }
      return new UploadAjaxError(msg, xhr.status, option.method, action);
    }
    function getBody(xhr) {
      const text = xhr.responseText || xhr.response;
      if (!text) {
        return text;
      }
      try {
        return JSON.parse(text);
      } catch (e) {
        return text;
      }
    }
    const ajaxUpload = (option) => {
      if (typeof XMLHttpRequest === "undefined")
        throwError(SCOPE$2, "XMLHttpRequest is undefined");
      const xhr = new XMLHttpRequest();
      const action = option.action;
      if (xhr.upload) {
        xhr.upload.addEventListener("progress", (evt) => {
          const progressEvt = evt;
          progressEvt.percent = evt.total > 0 ? evt.loaded / evt.total * 100 : 0;
          option.onProgress(progressEvt);
        });
      }
      const formData = new FormData();
      if (option.data) {
        for (const [key, value] of Object.entries(option.data)) {
          if (Array.isArray(value))
            formData.append(key, ...value);
          else
            formData.append(key, value);
        }
      }
      formData.append(option.filename, option.file, option.file.name);
      xhr.addEventListener("error", () => {
        option.onError(getError(action, option, xhr));
      });
      xhr.addEventListener("load", () => {
        if (xhr.status < 200 || xhr.status >= 300) {
          return option.onError(getError(action, option, xhr));
        }
        option.onSuccess(getBody(xhr));
      });
      xhr.open(option.method, action, true);
      if (option.withCredentials && "withCredentials" in xhr) {
        xhr.withCredentials = true;
      }
      const headers = option.headers || {};
      if (headers instanceof Headers) {
        headers.forEach((value, key) => xhr.setRequestHeader(key, value));
      } else {
        for (const [key, value] of Object.entries(headers)) {
          if (isNil(value))
            continue;
          xhr.setRequestHeader(key, String(value));
        }
      }
      xhr.send(formData);
      return xhr;
    };
  
    const uploadListTypes = ["text", "picture", "picture-card"];
    let fileId = 1;
    const genFileId = () => Date.now() + fileId++;
    const uploadBaseProps = buildProps({
      action: {
        type: String,
        default: "#"
      },
      headers: {
        type: definePropType(Object)
      },
      method: {
        type: String,
        default: "post"
      },
      data: {
        type: Object,
        default: () => mutable({})
      },
      multiple: {
        type: Boolean,
        default: false
      },
      name: {
        type: String,
        default: "file"
      },
      drag: {
        type: Boolean,
        default: false
      },
      withCredentials: Boolean,
      showFileList: {
        type: Boolean,
        default: true
      },
      accept: {
        type: String,
        default: ""
      },
      type: {
        type: String,
        default: "select"
      },
      fileList: {
        type: definePropType(Array),
        default: () => mutable([])
      },
      autoUpload: {
        type: Boolean,
        default: true
      },
      listType: {
        type: String,
        values: uploadListTypes,
        default: "text"
      },
      httpRequest: {
        type: definePropType(Function),
        default: ajaxUpload
      },
      disabled: Boolean,
      limit: Number
    });
    const uploadProps = buildProps({
      ...uploadBaseProps,
      beforeUpload: {
        type: definePropType(Function),
        default: NOOP
      },
      beforeRemove: {
        type: definePropType(Function)
      },
      onRemove: {
        type: definePropType(Function),
        default: NOOP
      },
      onChange: {
        type: definePropType(Function),
        default: NOOP
      },
      onPreview: {
        type: definePropType(Function),
        default: NOOP
      },
      onSuccess: {
        type: definePropType(Function),
        default: NOOP
      },
      onProgress: {
        type: definePropType(Function),
        default: NOOP
      },
      onError: {
        type: definePropType(Function),
        default: NOOP
      },
      onExceed: {
        type: definePropType(Function),
        default: NOOP
      }
    });
  
    const uploadListProps = buildProps({
      files: {
        type: definePropType(Array),
        default: () => mutable([])
      },
      disabled: {
        type: Boolean,
        default: false
      },
      handlePreview: {
        type: definePropType(Function),
        default: NOOP
      },
      listType: {
        type: String,
        values: uploadListTypes,
        default: "text"
      }
    });
    const uploadListEmits = {
      remove: (file) => !!file
    };
  
    const _hoisted_1$5 = ["onKeydown"];
    const _hoisted_2$4 = ["src"];
    const _hoisted_3$2 = ["onClick"];
    const _hoisted_4$1 = ["onClick"];
    const _hoisted_5 = ["onClick"];
    const __default__$5 = vue.defineComponent({
      name: "ElUploadList"
    });
    const _sfc_main$6 = /* @__PURE__ */ vue.defineComponent({
      ...__default__$5,
      props: uploadListProps,
      emits: uploadListEmits,
      setup(__props, { emit }) {
        const { t } = useLocale();
        const nsUpload = useNamespace("upload");
        const nsIcon = useNamespace("icon");
        const nsList = useNamespace("list");
        const focusing = vue.ref(false);
        const handleRemove = (file) => {
          emit("remove", file);
        };
        return (_ctx, _cache) => {
          return vue.openBlock(), vue.createBlock(vue.TransitionGroup, {
            tag: "ul",
            class: vue.normalizeClass([
              vue.unref(nsUpload).b("list"),
              vue.unref(nsUpload).bm("list", _ctx.listType),
              vue.unref(nsUpload).is("disabled", _ctx.disabled)
            ]),
            name: vue.unref(nsList).b()
          }, {
            default: vue.withCtx(() => [
              (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(_ctx.files, (file) => {
                return vue.openBlock(), vue.createElementBlock("li", {
                  key: file.uid || file.name,
                  class: vue.normalizeClass([
                    vue.unref(nsUpload).be("list", "item"),
                    vue.unref(nsUpload).is(file.status),
                    { focusing: focusing.value }
                  ]),
                  tabindex: "0",
                  onKeydown: vue.withKeys(($event) => !_ctx.disabled && handleRemove(file), ["delete"]),
                  onFocus: _cache[0] || (_cache[0] = ($event) => focusing.value = true),
                  onBlur: _cache[1] || (_cache[1] = ($event) => focusing.value = false),
                  onClick: _cache[2] || (_cache[2] = ($event) => focusing.value = false)
                }, [
                  vue.renderSlot(_ctx.$slots, "default", { file }, () => [
                    _ctx.listType === "picture" || file.status !== "uploading" && _ctx.listType === "picture-card" ? (vue.openBlock(), vue.createElementBlock("img", {
                      key: 0,
                      class: vue.normalizeClass(vue.unref(nsUpload).be("list", "item-thumbnail")),
                      src: file.url,
                      alt: ""
                    }, null, 10, _hoisted_2$4)) : vue.createCommentVNode("v-if", true),
                    file.status === "uploading" || _ctx.listType !== "picture-card" ? (vue.openBlock(), vue.createElementBlock("div", {
                      key: 1,
                      class: vue.normalizeClass(vue.unref(nsUpload).be("list", "item-info"))
                    }, [
                      vue.createElementVNode("a", {
                        class: vue.normalizeClass(vue.unref(nsUpload).be("list", "item-name")),
                        onClick: vue.withModifiers(($event) => _ctx.handlePreview(file), ["prevent"])
                      }, [
                        vue.createVNode(vue.unref(ElIcon), {
                          class: vue.normalizeClass(vue.unref(nsIcon).m("document"))
                        }, {
                          default: vue.withCtx(() => [
                            vue.createVNode(vue.unref(document_default))
                          ]),
                          _: 1
                        }, 8, ["class"]),
                        vue.createElementVNode("span", {
                          class: vue.normalizeClass(vue.unref(nsUpload).be("list", "item-file-name"))
                        }, vue.toDisplayString(file.name), 3)
                      ], 10, _hoisted_3$2),
                      file.status === "uploading" ? (vue.openBlock(), vue.createBlock(vue.unref(ElProgress), {
                        key: 0,
                        type: _ctx.listType === "picture-card" ? "circle" : "line",
                        "stroke-width": _ctx.listType === "picture-card" ? 6 : 2,
                        percentage: Number(file.percentage),
                        style: vue.normalizeStyle(_ctx.listType === "picture-card" ? "" : "margin-top: 0.5rem")
                      }, null, 8, ["type", "stroke-width", "percentage", "style"])) : vue.createCommentVNode("v-if", true)
                    ], 2)) : vue.createCommentVNode("v-if", true),
                    vue.createElementVNode("label", {
                      class: vue.normalizeClass(vue.unref(nsUpload).be("list", "item-status-label"))
                    }, [
                      _ctx.listType === "text" ? (vue.openBlock(), vue.createBlock(vue.unref(ElIcon), {
                        key: 0,
                        class: vue.normalizeClass([vue.unref(nsIcon).m("upload-success"), vue.unref(nsIcon).m("circle-check")])
                      }, {
                        default: vue.withCtx(() => [
                          vue.createVNode(vue.unref(circle_check_default))
                        ]),
                        _: 1
                      }, 8, ["class"])) : ["picture-card", "picture"].includes(_ctx.listType) ? (vue.openBlock(), vue.createBlock(vue.unref(ElIcon), {
                        key: 1,
                        class: vue.normalizeClass([vue.unref(nsIcon).m("upload-success"), vue.unref(nsIcon).m("check")])
                      }, {
                        default: vue.withCtx(() => [
                          vue.createVNode(vue.unref(check_default))
                        ]),
                        _: 1
                      }, 8, ["class"])) : vue.createCommentVNode("v-if", true)
                    ], 2),
                    !_ctx.disabled ? (vue.openBlock(), vue.createBlock(vue.unref(ElIcon), {
                      key: 2,
                      class: vue.normalizeClass(vue.unref(nsIcon).m("close")),
                      onClick: ($event) => handleRemove(file)
                    }, {
                      default: vue.withCtx(() => [
                        vue.createVNode(vue.unref(close_default))
                      ]),
                      _: 2
                    }, 1032, ["class", "onClick"])) : vue.createCommentVNode("v-if", true),
                    vue.createCommentVNode(" Due to close btn only appears when li gets focused disappears after li gets blurred, thus keyboard navigation can never reach close btn"),
                    vue.createCommentVNode(" This is a bug which needs to be fixed "),
                    vue.createCommentVNode(" TODO: Fix the incorrect navigation interaction "),
                    !_ctx.disabled ? (vue.openBlock(), vue.createElementBlock("i", {
                      key: 3,
                      class: vue.normalizeClass(vue.unref(nsIcon).m("close-tip"))
                    }, vue.toDisplayString(vue.unref(t)("el.upload.deleteTip")), 3)) : vue.createCommentVNode("v-if", true),
                    _ctx.listType === "picture-card" ? (vue.openBlock(), vue.createElementBlock("span", {
                      key: 4,
                      class: vue.normalizeClass(vue.unref(nsUpload).be("list", "item-actions"))
                    }, [
                      vue.createElementVNode("span", {
                        class: vue.normalizeClass(vue.unref(nsUpload).be("list", "item-preview")),
                        onClick: ($event) => _ctx.handlePreview(file)
                      }, [
                        vue.createVNode(vue.unref(ElIcon), {
                          class: vue.normalizeClass(vue.unref(nsIcon).m("zoom-in"))
                        }, {
                          default: vue.withCtx(() => [
                            vue.createVNode(vue.unref(zoom_in_default))
                          ]),
                          _: 1
                        }, 8, ["class"])
                      ], 10, _hoisted_4$1),
                      !_ctx.disabled ? (vue.openBlock(), vue.createElementBlock("span", {
                        key: 0,
                        class: vue.normalizeClass(vue.unref(nsUpload).be("list", "item-delete")),
                        onClick: ($event) => handleRemove(file)
                      }, [
                        vue.createVNode(vue.unref(ElIcon), {
                          class: vue.normalizeClass(vue.unref(nsIcon).m("delete"))
                        }, {
                          default: vue.withCtx(() => [
                            vue.createVNode(vue.unref(delete_default))
                          ]),
                          _: 1
                        }, 8, ["class"])
                      ], 10, _hoisted_5)) : vue.createCommentVNode("v-if", true)
                    ], 2)) : vue.createCommentVNode("v-if", true)
                  ])
                ], 42, _hoisted_1$5);
              }), 128)),
              vue.renderSlot(_ctx.$slots, "append")
            ]),
            _: 3
          }, 8, ["class", "name"]);
        };
      }
    });
    var UploadList = /* @__PURE__ */ _export_sfc(_sfc_main$6, [["__file", "upload-list.vue"]]);
  
    const uploadDraggerProps = buildProps({
      disabled: {
        type: Boolean,
        default: false
      }
    });
    const uploadDraggerEmits = {
      file: (file) => isArray(file)
    };
  
    const _hoisted_1$4 = ["onDrop", "onDragover"];
    const COMPONENT_NAME = "ElUploadDrag";
    const __default__$4 = vue.defineComponent({
      name: COMPONENT_NAME
    });
    const _sfc_main$5 = /* @__PURE__ */ vue.defineComponent({
      ...__default__$4,
      props: uploadDraggerProps,
      emits: uploadDraggerEmits,
      setup(__props, { emit }) {
        const props = __props;
        const uploaderContext = vue.inject(uploadContextKey);
        if (!uploaderContext) {
          throwError(COMPONENT_NAME, "usage: <el-upload><el-upload-dragger /></el-upload>");
        }
        const ns = useNamespace("upload");
        const dragover = vue.ref(false);
        const onDrop = (e) => {
          if (props.disabled)
            return;
          dragover.value = false;
          const files = Array.from(e.dataTransfer.files);
          const accept = uploaderContext.accept.value;
          if (!accept) {
            emit("file", files);
            return;
          }
          const filesFiltered = files.filter((file) => {
            const { type, name } = file;
            const extension = name.includes(".") ? `.${name.split(".").pop()}` : "";
            const baseType = type.replace(/\/.*$/, "");
            return accept.split(",").map((type2) => type2.trim()).filter((type2) => type2).some((acceptedType) => {
              if (acceptedType.startsWith(".")) {
                return extension === acceptedType;
              }
              if (/\/\*$/.test(acceptedType)) {
                return baseType === acceptedType.replace(/\/\*$/, "");
              }
              if (/^[^/]+\/[^/]+$/.test(acceptedType)) {
                return type === acceptedType;
              }
              return false;
            });
          });
          emit("file", filesFiltered);
        };
        const onDragover = () => {
          if (!props.disabled)
            dragover.value = true;
        };
        return (_ctx, _cache) => {
          return vue.openBlock(), vue.createElementBlock("div", {
            class: vue.normalizeClass([vue.unref(ns).b("dragger"), vue.unref(ns).is("dragover", dragover.value)]),
            onDrop: vue.withModifiers(onDrop, ["prevent"]),
            onDragover: vue.withModifiers(onDragover, ["prevent"]),
            onDragleave: _cache[0] || (_cache[0] = vue.withModifiers(($event) => dragover.value = false, ["prevent"]))
          }, [
            vue.renderSlot(_ctx.$slots, "default")
          ], 42, _hoisted_1$4);
        };
      }
    });
    var UploadDragger = /* @__PURE__ */ _export_sfc(_sfc_main$5, [["__file", "upload-dragger.vue"]]);
  
    const uploadContentProps = buildProps({
      ...uploadBaseProps,
      beforeUpload: {
        type: definePropType(Function),
        default: NOOP
      },
      onRemove: {
        type: definePropType(Function),
        default: NOOP
      },
      onStart: {
        type: definePropType(Function),
        default: NOOP
      },
      onSuccess: {
        type: definePropType(Function),
        default: NOOP
      },
      onProgress: {
        type: definePropType(Function),
        default: NOOP
      },
      onError: {
        type: definePropType(Function),
        default: NOOP
      },
      onExceed: {
        type: definePropType(Function),
        default: NOOP
      }
    });
  
    const _hoisted_1$3 = ["onKeydown"];
    const _hoisted_2$3 = ["name", "multiple", "accept"];
    const __default__$3 = vue.defineComponent({
      name: "ElUploadContent",
      inheritAttrs: false
    });
    const _sfc_main$4 = /* @__PURE__ */ vue.defineComponent({
      ...__default__$3,
      props: uploadContentProps,
      setup(__props, { expose }) {
        const props = __props;
        const ns = useNamespace("upload");
        const requests = vue.shallowRef({});
        const inputRef = vue.shallowRef();
        const uploadFiles = (files) => {
          if (files.length === 0)
            return;
          const { autoUpload, limit, fileList, multiple, onStart, onExceed } = props;
          if (limit && fileList.length + files.length > limit) {
            onExceed(files, fileList);
            return;
          }
          if (!multiple) {
            files = files.slice(0, 1);
          }
          for (const file of files) {
            const rawFile = file;
            rawFile.uid = genFileId();
            onStart(rawFile);
            if (autoUpload)
              upload(rawFile);
          }
        };
        const upload = async (rawFile) => {
          inputRef.value.value = "";
          if (!props.beforeUpload) {
            return doUpload(rawFile);
          }
          let hookResult;
          try {
            hookResult = await props.beforeUpload(rawFile);
          } catch (e) {
            hookResult = false;
          }
          if (hookResult === false) {
            props.onRemove(rawFile);
            return;
          }
          let file = rawFile;
          if (hookResult instanceof Blob) {
            if (hookResult instanceof File) {
              file = hookResult;
            } else {
              file = new File([hookResult], rawFile.name, {
                type: rawFile.type
              });
            }
          }
          doUpload(Object.assign(file, {
            uid: rawFile.uid
          }));
        };
        const doUpload = (rawFile) => {
          const {
            headers,
            data,
            method,
            withCredentials,
            name: filename,
            action,
            onProgress,
            onSuccess,
            onError,
            httpRequest
          } = props;
          const { uid } = rawFile;
          const options = {
            headers: headers || {},
            withCredentials,
            file: rawFile,
            data,
            method,
            filename,
            action,
            onProgress: (evt) => {
              onProgress(evt, rawFile);
            },
            onSuccess: (res) => {
              onSuccess(res, rawFile);
              delete requests.value[uid];
            },
            onError: (err) => {
              onError(err, rawFile);
              delete requests.value[uid];
            }
          };
          const request = httpRequest(options);
          requests.value[uid] = request;
          if (request instanceof Promise) {
            request.then(options.onSuccess, options.onError);
          }
        };
        const handleChange = (e) => {
          const files = e.target.files;
          if (!files)
            return;
          uploadFiles(Array.from(files));
        };
        const handleClick = () => {
          if (!props.disabled) {
            inputRef.value.value = "";
            inputRef.value.click();
          }
        };
        const handleKeydown = () => {
          handleClick();
        };
        const abort = (file) => {
          const _reqs = entriesOf(requests.value).filter(file ? ([uid]) => String(file.uid) === uid : () => true);
          _reqs.forEach(([uid, req]) => {
            if (req instanceof XMLHttpRequest)
              req.abort();
            delete requests.value[uid];
          });
        };
        expose({
          abort,
          upload
        });
        return (_ctx, _cache) => {
          return vue.openBlock(), vue.createElementBlock("div", {
            class: vue.normalizeClass([vue.unref(ns).b(), vue.unref(ns).m(_ctx.listType), vue.unref(ns).is("drag", _ctx.drag)]),
            tabindex: "0",
            onClick: handleClick,
            onKeydown: vue.withKeys(vue.withModifiers(handleKeydown, ["self"]), ["enter", "space"])
          }, [
            _ctx.drag ? (vue.openBlock(), vue.createBlock(UploadDragger, {
              key: 0,
              disabled: _ctx.disabled,
              onFile: uploadFiles
            }, {
              default: vue.withCtx(() => [
                vue.renderSlot(_ctx.$slots, "default")
              ]),
              _: 3
            }, 8, ["disabled"])) : vue.renderSlot(_ctx.$slots, "default", { key: 1 }),
            vue.createElementVNode("input", {
              ref_key: "inputRef",
              ref: inputRef,
              class: vue.normalizeClass(vue.unref(ns).e("input")),
              name: _ctx.name,
              multiple: _ctx.multiple,
              accept: _ctx.accept,
              type: "file",
              onChange: handleChange,
              onClick: _cache[0] || (_cache[0] = vue.withModifiers(() => {
              }, ["stop"]))
            }, null, 42, _hoisted_2$3)
          ], 42, _hoisted_1$3);
        };
      }
    });
    var UploadContent = /* @__PURE__ */ _export_sfc(_sfc_main$4, [["__file", "upload-content.vue"]]);
  
    const SCOPE$1 = "ElUpload";
    const revokeObjectURL = (file) => {
      var _a;
      if ((_a = file.url) == null ? void 0 : _a.startsWith("blob:")) {
        URL.revokeObjectURL(file.url);
      }
    };
    const useHandlers = (props, uploadRef) => {
      const uploadFiles = useVModel(props, "fileList", void 0, { passive: true });
      const getFile = (rawFile) => uploadFiles.value.find((file) => file.uid === rawFile.uid);
      function abort(file) {
        var _a;
        (_a = uploadRef.value) == null ? void 0 : _a.abort(file);
      }
      function clearFiles(states = ["ready", "uploading", "success", "fail"]) {
        uploadFiles.value = uploadFiles.value.filter((row) => !states.includes(row.status));
      }
      const handleError = (err, rawFile) => {
        const file = getFile(rawFile);
        if (!file)
          return;
        console.error(err);
        file.status = "fail";
        uploadFiles.value.splice(uploadFiles.value.indexOf(file), 1);
        props.onError(err, file, uploadFiles.value);
        props.onChange(file, uploadFiles.value);
      };
      const handleProgress = (evt, rawFile) => {
        const file = getFile(rawFile);
        if (!file)
          return;
        props.onProgress(evt, file, uploadFiles.value);
        file.status = "uploading";
        file.percentage = Math.round(evt.percent);
      };
      const handleSuccess = (response, rawFile) => {
        const file = getFile(rawFile);
        if (!file)
          return;
        file.status = "success";
        file.response = response;
        props.onSuccess(response, file, uploadFiles.value);
        props.onChange(file, uploadFiles.value);
      };
      const handleStart = (file) => {
        if (isNil(file.uid))
          file.uid = genFileId();
        const uploadFile = {
          name: file.name,
          percentage: 0,
          status: "ready",
          size: file.size,
          raw: file,
          uid: file.uid
        };
        if (props.listType === "picture-card" || props.listType === "picture") {
          try {
            uploadFile.url = URL.createObjectURL(file);
          } catch (err) {
            debugWarn(SCOPE$1, err.message);
            props.onError(err, uploadFile, uploadFiles.value);
          }
        }
        uploadFiles.value = [...uploadFiles.value, uploadFile];
        props.onChange(uploadFile, uploadFiles.value);
      };
      const handleRemove = async (file) => {
        const uploadFile = file instanceof File ? getFile(file) : file;
        if (!uploadFile)
          throwError(SCOPE$1, "file to be removed not found");
        const doRemove = (file2) => {
          abort(file2);
          const fileList = uploadFiles.value;
          fileList.splice(fileList.indexOf(file2), 1);
          props.onRemove(file2, fileList);
          revokeObjectURL(file2);
        };
        if (props.beforeRemove) {
          const before = await props.beforeRemove(uploadFile, uploadFiles.value);
          if (before !== false)
            doRemove(uploadFile);
        } else {
          doRemove(uploadFile);
        }
      };
      function submit() {
        uploadFiles.value.filter(({ status }) => status === "ready").forEach(({ raw }) => {
          var _a;
          return raw && ((_a = uploadRef.value) == null ? void 0 : _a.upload(raw));
        });
      }
      vue.watch(() => props.listType, (val) => {
        if (val !== "picture-card" && val !== "picture") {
          return;
        }
        uploadFiles.value = uploadFiles.value.map((file) => {
          const { raw, url } = file;
          if (!url && raw) {
            try {
              file.url = URL.createObjectURL(raw);
            } catch (err) {
              props.onError(err, file, uploadFiles.value);
            }
          }
          return file;
        });
      });
      vue.watch(uploadFiles, (files) => {
        for (const file of files) {
          file.uid || (file.uid = genFileId());
          file.status || (file.status = "success");
        }
      }, { immediate: true, deep: true });
      return {
        uploadFiles,
        abort,
        clearFiles,
        handleError,
        handleProgress,
        handleStart,
        handleSuccess,
        handleRemove,
        submit
      };
    };
  
    const __default__$2 = vue.defineComponent({
      name: "ElUpload"
    });
    const _sfc_main$3 = /* @__PURE__ */ vue.defineComponent({
      ...__default__$2,
      props: uploadProps,
      setup(__props, { expose }) {
        const props = __props;
        const slots = vue.useSlots();
        const disabled = useDisabled();
        const uploadRef = vue.shallowRef();
        const {
          abort,
          submit,
          clearFiles,
          uploadFiles,
          handleStart,
          handleError,
          handleRemove,
          handleSuccess,
          handleProgress
        } = useHandlers(props, uploadRef);
        const isPictureCard = vue.computed(() => props.listType === "picture-card");
        const uploadContentProps = vue.computed(() => ({
          ...props,
          fileList: uploadFiles.value,
          onStart: handleStart,
          onProgress: handleProgress,
          onSuccess: handleSuccess,
          onError: handleError,
          onRemove: handleRemove
        }));
        vue.onBeforeUnmount(() => {
          uploadFiles.value.forEach(({ url }) => {
            if (url == null ? void 0 : url.startsWith("blob:"))
              URL.revokeObjectURL(url);
          });
        });
        vue.provide(uploadContextKey, {
          accept: vue.toRef(props, "accept")
        });
        expose({
          abort,
          submit,
          clearFiles,
          handleStart,
          handleRemove
        });
        return (_ctx, _cache) => {
          return vue.openBlock(), vue.createElementBlock("div", null, [
            vue.unref(isPictureCard) && _ctx.showFileList ? (vue.openBlock(), vue.createBlock(UploadList, {
              key: 0,
              disabled: vue.unref(disabled),
              "list-type": _ctx.listType,
              files: vue.unref(uploadFiles),
              "handle-preview": _ctx.onPreview,
              onRemove: vue.unref(handleRemove)
            }, vue.createSlots({
              append: vue.withCtx(() => [
                vue.createVNode(UploadContent, vue.mergeProps({
                  ref_key: "uploadRef",
                  ref: uploadRef
                }, vue.unref(uploadContentProps)), {
                  default: vue.withCtx(() => [
                    vue.unref(slots).trigger ? vue.renderSlot(_ctx.$slots, "trigger", { key: 0 }) : vue.createCommentVNode("v-if", true),
                    !vue.unref(slots).trigger && vue.unref(slots).default ? vue.renderSlot(_ctx.$slots, "default", { key: 1 }) : vue.createCommentVNode("v-if", true)
                  ]),
                  _: 3
                }, 16)
              ]),
              _: 2
            }, [
              _ctx.$slots.file ? {
                name: "default",
                fn: vue.withCtx(({ file }) => [
                  vue.renderSlot(_ctx.$slots, "file", { file })
                ])
              } : void 0
            ]), 1032, ["disabled", "list-type", "files", "handle-preview", "onRemove"])) : vue.createCommentVNode("v-if", true),
            !vue.unref(isPictureCard) || vue.unref(isPictureCard) && !_ctx.showFileList ? (vue.openBlock(), vue.createBlock(UploadContent, vue.mergeProps({
              key: 1,
              ref_key: "uploadRef",
              ref: uploadRef
            }, vue.unref(uploadContentProps)), {
              default: vue.withCtx(() => [
                vue.unref(slots).trigger ? vue.renderSlot(_ctx.$slots, "trigger", { key: 0 }) : vue.createCommentVNode("v-if", true),
                !vue.unref(slots).trigger && vue.unref(slots).default ? vue.renderSlot(_ctx.$slots, "default", { key: 1 }) : vue.createCommentVNode("v-if", true)
              ]),
              _: 3
            }, 16)) : vue.createCommentVNode("v-if", true),
            _ctx.$slots.trigger ? vue.renderSlot(_ctx.$slots, "default", { key: 2 }) : vue.createCommentVNode("v-if", true),
            vue.renderSlot(_ctx.$slots, "tip"),
            !vue.unref(isPictureCard) && _ctx.showFileList ? (vue.openBlock(), vue.createBlock(UploadList, {
              key: 3,
              disabled: vue.unref(disabled),
              "list-type": _ctx.listType,
              files: vue.unref(uploadFiles),
              "handle-preview": _ctx.onPreview,
              onRemove: vue.unref(handleRemove)
            }, vue.createSlots({ _: 2 }, [
              _ctx.$slots.file ? {
                name: "default",
                fn: vue.withCtx(({ file }) => [
                  vue.renderSlot(_ctx.$slots, "file", { file })
                ])
              } : void 0
            ]), 1032, ["disabled", "list-type", "files", "handle-preview", "onRemove"])) : vue.createCommentVNode("v-if", true)
          ]);
        };
      }
    });
    var Upload = /* @__PURE__ */ _export_sfc(_sfc_main$3, [["__file", "upload.vue"]]);
  
    const ElUpload = withInstall(Upload);
  
    var Components = [
      ElAffix,
      ElAlert,
      ElAutocomplete,
      ElAutoResizer,
      ElAvatar,
      ElBacktop,
      ElBadge,
      ElBreadcrumb,
      ElBreadcrumbItem,
      ElButton,
      ElButtonGroup$1,
      ElCalendar,
      ElCard,
      ElCarousel,
      ElCarouselItem,
      ElCascader,
      ElCascaderPanel,
      ElCheckTag,
      ElCheckbox,
      ElCheckboxButton,
      ElCheckboxGroup$1,
      ElCol,
      ElCollapse,
      ElCollapseItem,
      ElCollapseTransition,
      ElColorPicker,
      ElConfigProvider,
      ElContainer,
      ElAside,
      ElFooter,
      ElHeader,
      ElMain,
      ElDatePicker,
      ElDescriptions,
      ElDescriptionsItem,
      ElDialog,
      ElDivider,
      ElDrawer,
      ElDropdown,
      ElDropdownItem,
      ElDropdownMenu,
      ElEmpty,
      ElForm,
      ElFormItem,
      ElIcon,
      ElImage,
      ElImageViewer,
      ElInput,
      ElInputNumber,
      ElLink,
      ElMenu,
      ElMenuItem,
      ElMenuItemGroup,
      ElPageHeader,
      ElPagination,
      ElPopconfirm,
      ElPopover,
      ElPopper,
      ElProgress,
      ElRadio,
      ElRadioButton,
      ElRadioGroup,
      ElRate,
      ElResult,
      ElRow,
      ElScrollbar,
      ElSelect,
      ElOption,
      ElOptionGroup,
      ElSelectV2,
      ElSkeleton,
      ElSkeletonItem,
      ElSlider,
      ElSpace,
      ElSteps,
      ElStep,
      ElSwitch,
      ElTable,
      ElTableColumn,
      ElTableV2,
      ElTabs,
      ElTabPane,
      ElTag,
      ElTimePicker,
      ElTimeSelect,
      ElTimeline,
      ElTimelineItem,
      ElTooltip,
      ElTooltipV2,
      ElTransfer,
      ElTree,
      ElTreeSelect,
      ElTreeV2,
      ElUpload
    ];
  
    const SCOPE = "ElInfiniteScroll";
    const CHECK_INTERVAL = 50;
    const DEFAULT_DELAY = 200;
    const DEFAULT_DISTANCE = 0;
    const attributes = {
      delay: {
        type: Number,
        default: DEFAULT_DELAY
      },
      distance: {
        type: Number,
        default: DEFAULT_DISTANCE
      },
      disabled: {
        type: Boolean,
        default: false
      },
      immediate: {
        type: Boolean,
        default: true
      }
    };
    const getScrollOptions = (el, instance) => {
      return Object.entries(attributes).reduce((acm, [name, option]) => {
        var _a, _b;
        const { type, default: defaultValue } = option;
        const attrVal = el.getAttribute(`infinite-scroll-${name}`);
        let value = (_b = (_a = instance[attrVal]) != null ? _a : attrVal) != null ? _b : defaultValue;
        value = value === "false" ? false : value;
        value = type(value);
        acm[name] = Number.isNaN(value) ? defaultValue : value;
        return acm;
      }, {});
    };
    const destroyObserver = (el) => {
      const { observer } = el[SCOPE];
      if (observer) {
        observer.disconnect();
        delete el[SCOPE].observer;
      }
    };
    const handleScroll = (el, cb) => {
      const { container, containerEl, instance, observer, lastScrollTop } = el[SCOPE];
      const { disabled, distance } = getScrollOptions(el, instance);
      const { clientHeight, scrollHeight, scrollTop } = containerEl;
      const delta = scrollTop - lastScrollTop;
      el[SCOPE].lastScrollTop = scrollTop;
      if (observer || disabled || delta < 0)
        return;
      let shouldTrigger = false;
      if (container === el) {
        shouldTrigger = scrollHeight - (clientHeight + scrollTop) <= distance;
      } else {
        const { clientTop, scrollHeight: height } = el;
        const offsetTop = getOffsetTopDistance(el, containerEl);
        shouldTrigger = scrollTop + clientHeight >= offsetTop + clientTop + height - distance;
      }
      if (shouldTrigger) {
        cb.call(instance);
      }
    };
    function checkFull(el, cb) {
      const { containerEl, instance } = el[SCOPE];
      const { disabled } = getScrollOptions(el, instance);
      if (disabled || containerEl.clientHeight === 0)
        return;
      if (containerEl.scrollHeight <= containerEl.clientHeight) {
        cb.call(instance);
      } else {
        destroyObserver(el);
      }
    }
    const InfiniteScroll = {
      async mounted(el, binding) {
        const { instance, value: cb } = binding;
        if (!isFunction(cb)) {
          throwError(SCOPE, "'v-infinite-scroll' binding value must be a function");
        }
        await vue.nextTick();
        const { delay, immediate } = getScrollOptions(el, instance);
        const container = getScrollContainer(el, true);
        const containerEl = container === window ? document.documentElement : container;
        const onScroll = throttle(handleScroll.bind(null, el, cb), delay);
        if (!container)
          return;
        el[SCOPE] = {
          instance,
          container,
          containerEl,
          delay,
          cb,
          onScroll,
          lastScrollTop: containerEl.scrollTop
        };
        if (immediate) {
          const observer = new MutationObserver(throttle(checkFull.bind(null, el, cb), CHECK_INTERVAL));
          el[SCOPE].observer = observer;
          observer.observe(el, { childList: true, subtree: true });
          checkFull(el, cb);
        }
        container.addEventListener("scroll", onScroll);
      },
      unmounted(el) {
        const { container, onScroll } = el[SCOPE];
        container == null ? void 0 : container.removeEventListener("scroll", onScroll);
        destroyObserver(el);
      },
      async updated(el) {
        if (!el[SCOPE]) {
          await vue.nextTick();
        }
        const { containerEl, cb, observer } = el[SCOPE];
        if (containerEl.clientHeight && observer) {
          checkFull(el, cb);
        }
      }
    };
    var InfiniteScroll$1 = InfiniteScroll;
  
    const _InfiniteScroll = InfiniteScroll$1;
    _InfiniteScroll.install = (app) => {
      app.directive("InfiniteScroll", _InfiniteScroll);
    };
    const ElInfiniteScroll = _InfiniteScroll;
  
    function createLoadingComponent(options) {
      let afterLeaveTimer;
      const ns = useNamespace("loading");
      const afterLeaveFlag = vue.ref(false);
      const data = vue.reactive({
        ...options,
        originalPosition: "",
        originalOverflow: "",
        visible: false
      });
      function setText(text) {
        data.text = text;
      }
      function destroySelf() {
        const target = data.parent;
        if (!target.vLoadingAddClassList) {
          let loadingNumber = target.getAttribute("loading-number");
          loadingNumber = Number.parseInt(loadingNumber) - 1;
          if (!loadingNumber) {
            removeClass(target, ns.bm("parent", "relative"));
            target.removeAttribute("loading-number");
          } else {
            target.setAttribute("loading-number", loadingNumber.toString());
          }
          removeClass(target, ns.bm("parent", "hidden"));
        }
        removeElLoadingChild();
        loadingInstance.unmount();
      }
      function removeElLoadingChild() {
        var _a, _b;
        (_b = (_a = vm.$el) == null ? void 0 : _a.parentNode) == null ? void 0 : _b.removeChild(vm.$el);
      }
      function close() {
        var _a;
        if (options.beforeClose && !options.beforeClose())
          return;
        afterLeaveFlag.value = true;
        clearTimeout(afterLeaveTimer);
        afterLeaveTimer = window.setTimeout(handleAfterLeave, 400);
        data.visible = false;
        (_a = options.closed) == null ? void 0 : _a.call(options);
      }
      function handleAfterLeave() {
        if (!afterLeaveFlag.value)
          return;
        const target = data.parent;
        afterLeaveFlag.value = false;
        target.vLoadingAddClassList = void 0;
        destroySelf();
      }
      const elLoadingComponent = {
        name: "ElLoading",
        setup() {
          return () => {
            const svg = data.spinner || data.svg;
            const spinner = vue.h("svg", {
              class: "circular",
              viewBox: data.svgViewBox ? data.svgViewBox : "0 0 50 50",
              ...svg ? { innerHTML: svg } : {}
            }, [
              vue.h("circle", {
                class: "path",
                cx: "25",
                cy: "25",
                r: "20",
                fill: "none"
              })
            ]);
            const spinnerText = data.text ? vue.h("p", { class: ns.b("text") }, [data.text]) : void 0;
            return vue.h(vue.Transition, {
              name: ns.b("fade"),
              onAfterLeave: handleAfterLeave
            }, {
              default: vue.withCtx(() => [
                vue.withDirectives(vue.createVNode("div", {
                  style: {
                    backgroundColor: data.background || ""
                  },
                  class: [
                    ns.b("mask"),
                    data.customClass,
                    data.fullscreen ? "is-fullscreen" : ""
                  ]
                }, [
                  vue.h("div", {
                    class: ns.b("spinner")
                  }, [spinner, spinnerText])
                ]), [[vue.vShow, data.visible]])
              ])
            });
          };
        }
      };
      const loadingInstance = vue.createApp(elLoadingComponent);
      const vm = loadingInstance.mount(document.createElement("div"));
      return {
        ...vue.toRefs(data),
        setText,
        removeElLoadingChild,
        close,
        handleAfterLeave,
        vm,
        get $el() {
          return vm.$el;
        }
      };
    }
  
    let fullscreenInstance = void 0;
    const Loading = function(options = {}) {
      if (!isClient)
        return void 0;
      const resolved = resolveOptions(options);
      if (resolved.fullscreen && fullscreenInstance) {
        return fullscreenInstance;
      }
      const instance = createLoadingComponent({
        ...resolved,
        closed: () => {
          var _a;
          (_a = resolved.closed) == null ? void 0 : _a.call(resolved);
          if (resolved.fullscreen)
            fullscreenInstance = void 0;
        }
      });
      addStyle(resolved, resolved.parent, instance);
      addClassList(resolved, resolved.parent, instance);
      resolved.parent.vLoadingAddClassList = () => addClassList(resolved, resolved.parent, instance);
      let loadingNumber = resolved.parent.getAttribute("loading-number");
      if (!loadingNumber) {
        loadingNumber = "1";
      } else {
        loadingNumber = `${Number.parseInt(loadingNumber) + 1}`;
      }
      resolved.parent.setAttribute("loading-number", loadingNumber);
      resolved.parent.appendChild(instance.$el);
      vue.nextTick(() => instance.visible.value = resolved.visible);
      if (resolved.fullscreen) {
        fullscreenInstance = instance;
      }
      return instance;
    };
    const resolveOptions = (options) => {
      var _a, _b, _c, _d;
      let target;
      if (isString(options.target)) {
        target = (_a = document.querySelector(options.target)) != null ? _a : document.body;
      } else {
        target = options.target || document.body;
      }
      return {
        parent: target === document.body || options.body ? document.body : target,
        background: options.background || "",
        svg: options.svg || "",
        svgViewBox: options.svgViewBox || "",
        spinner: options.spinner || false,
        text: options.text || "",
        fullscreen: target === document.body && ((_b = options.fullscreen) != null ? _b : true),
        lock: (_c = options.lock) != null ? _c : false,
        customClass: options.customClass || "",
        visible: (_d = options.visible) != null ? _d : true,
        target
      };
    };
    const addStyle = async (options, parent, instance) => {
      const { nextZIndex } = useZIndex();
      const maskStyle = {};
      if (options.fullscreen) {
        instance.originalPosition.value = getStyle(document.body, "position");
        instance.originalOverflow.value = getStyle(document.body, "overflow");
        maskStyle.zIndex = nextZIndex();
      } else if (options.parent === document.body) {
        instance.originalPosition.value = getStyle(document.body, "position");
        await vue.nextTick();
        for (const property of ["top", "left"]) {
          const scroll = property === "top" ? "scrollTop" : "scrollLeft";
          maskStyle[property] = `${options.target.getBoundingClientRect()[property] + document.body[scroll] + document.documentElement[scroll] - Number.parseInt(getStyle(document.body, `margin-${property}`), 10)}px`;
        }
        for (const property of ["height", "width"]) {
          maskStyle[property] = `${options.target.getBoundingClientRect()[property]}px`;
        }
      } else {
        instance.originalPosition.value = getStyle(parent, "position");
      }
      for (const [key, value] of Object.entries(maskStyle)) {
        instance.$el.style[key] = value;
      }
    };
    const addClassList = (options, parent, instance) => {
      const ns = useNamespace("loading");
      if (!["absolute", "fixed", "sticky"].includes(instance.originalPosition.value)) {
        addClass(parent, ns.bm("parent", "relative"));
      } else {
        removeClass(parent, ns.bm("parent", "relative"));
      }
      if (options.fullscreen && options.lock) {
        addClass(parent, ns.bm("parent", "hidden"));
      } else {
        removeClass(parent, ns.bm("parent", "hidden"));
      }
    };
  
    const INSTANCE_KEY = Symbol("ElLoading");
    const createInstance = (el, binding) => {
      var _a, _b, _c, _d;
      const vm = binding.instance;
      const getBindingProp = (key) => isObject$1(binding.value) ? binding.value[key] : void 0;
      const resolveExpression = (key) => {
        const data = isString(key) && (vm == null ? void 0 : vm[key]) || key;
        if (data)
          return vue.ref(data);
        else
          return data;
      };
      const getProp = (name) => resolveExpression(getBindingProp(name) || el.getAttribute(`element-loading-${hyphenate(name)}`));
      const fullscreen = (_a = getBindingProp("fullscreen")) != null ? _a : binding.modifiers.fullscreen;
      const options = {
        text: getProp("text"),
        svg: getProp("svg"),
        svgViewBox: getProp("svgViewBox"),
        spinner: getProp("spinner"),
        background: getProp("background"),
        customClass: getProp("customClass"),
        fullscreen,
        target: (_b = getBindingProp("target")) != null ? _b : fullscreen ? void 0 : el,
        body: (_c = getBindingProp("body")) != null ? _c : binding.modifiers.body,
        lock: (_d = getBindingProp("lock")) != null ? _d : binding.modifiers.lock
      };
      el[INSTANCE_KEY] = {
        options,
        instance: Loading(options)
      };
    };
    const updateOptions = (newOptions, originalOptions) => {
      for (const key of Object.keys(originalOptions)) {
        if (vue.isRef(originalOptions[key]))
          originalOptions[key].value = newOptions[key];
      }
    };
    const vLoading = {
      mounted(el, binding) {
        if (binding.value) {
          createInstance(el, binding);
        }
      },
      updated(el, binding) {
        const instance = el[INSTANCE_KEY];
        if (binding.oldValue !== binding.value) {
          if (binding.value && !binding.oldValue) {
            createInstance(el, binding);
          } else if (binding.value && binding.oldValue) {
            if (isObject$1(binding.value))
              updateOptions(binding.value, instance.options);
          } else {
            instance == null ? void 0 : instance.instance.close();
          }
        }
      },
      unmounted(el) {
        var _a;
        (_a = el[INSTANCE_KEY]) == null ? void 0 : _a.instance.close();
      }
    };
  
    const ElLoading = {
      install(app) {
        app.directive("loading", vLoading);
        app.config.globalProperties.$loading = Loading;
      },
      directive: vLoading,
      service: Loading
    };
  
    const messageTypes = ["success", "info", "warning", "error"];
    const messageDefaults = mutable({
      customClass: "",
      center: false,
      dangerouslyUseHTMLString: false,
      duration: 3e3,
      icon: void 0,
      id: "",
      message: "",
      onClose: void 0,
      showClose: false,
      type: "info",
      offset: 16,
      zIndex: 0,
      grouping: false,
      repeatNum: 1,
      appendTo: isClient ? document.body : void 0
    });
    const messageProps = buildProps({
      customClass: {
        type: String,
        default: messageDefaults.customClass
      },
      center: {
        type: Boolean,
        default: messageDefaults.center
      },
      dangerouslyUseHTMLString: {
        type: Boolean,
        default: messageDefaults.dangerouslyUseHTMLString
      },
      duration: {
        type: Number,
        default: messageDefaults.duration
      },
      icon: {
        type: iconPropType,
        default: messageDefaults.icon
      },
      id: {
        type: String,
        default: messageDefaults.id
      },
      message: {
        type: definePropType([
          String,
          Object,
          Function
        ]),
        default: messageDefaults.message
      },
      onClose: {
        type: definePropType(Function),
        required: false
      },
      showClose: {
        type: Boolean,
        default: messageDefaults.showClose
      },
      type: {
        type: String,
        values: messageTypes,
        default: messageDefaults.type
      },
      offset: {
        type: Number,
        default: messageDefaults.offset
      },
      zIndex: {
        type: Number,
        default: messageDefaults.zIndex
      },
      grouping: {
        type: Boolean,
        default: messageDefaults.grouping
      },
      repeatNum: {
        type: Number,
        default: messageDefaults.repeatNum
      }
    });
    const messageEmits = {
      destroy: () => true
    };
  
    const instances = vue.shallowReactive([]);
    const getInstance = (id) => {
      const idx = instances.findIndex((instance) => instance.id === id);
      const current = instances[idx];
      let prev;
      if (idx > 0) {
        prev = instances[idx - 1];
      }
      return { current, prev };
    };
    const getLastOffset = (id) => {
      const { prev } = getInstance(id);
      if (!prev)
        return 0;
      return prev.vm.exposed.bottom.value;
    };
  
    const _hoisted_1$2 = ["id"];
    const _hoisted_2$2 = ["innerHTML"];
    const __default__$1 = vue.defineComponent({
      name: "ElMessage"
    });
    const _sfc_main$2 = /* @__PURE__ */ vue.defineComponent({
      ...__default__$1,
      props: messageProps,
      emits: messageEmits,
      setup(__props, { expose }) {
        const props = __props;
        const { Close } = TypeComponents;
        const ns = useNamespace("message");
        const messageRef = vue.ref();
        const visible = vue.ref(false);
        const height = vue.ref(0);
        let stopTimer = void 0;
        const badgeType = vue.computed(() => props.type ? props.type === "error" ? "danger" : props.type : "info");
        const typeClass = vue.computed(() => {
          const type = props.type;
          return { [ns.bm("icon", type)]: type && TypeComponentsMap[type] };
        });
        const iconComponent = vue.computed(() => props.icon || TypeComponentsMap[props.type] || "");
        const lastOffset = vue.computed(() => getLastOffset(props.id));
        const offset = vue.computed(() => props.offset + lastOffset.value);
        const bottom = vue.computed(() => height.value + offset.value);
        const customStyle = vue.computed(() => ({
          top: `${offset.value}px`,
          zIndex: props.zIndex
        }));
        function startTimer() {
          if (props.duration === 0)
            return;
          ({ stop: stopTimer } = useTimeoutFn(() => {
            close();
          }, props.duration));
        }
        function clearTimer() {
          stopTimer == null ? void 0 : stopTimer();
        }
        function close() {
          visible.value = false;
        }
        function keydown({ code }) {
          if (code === EVENT_CODE.esc) {
            close();
          }
        }
        vue.onMounted(() => {
          startTimer();
          visible.value = true;
        });
        vue.watch(() => props.repeatNum, () => {
          clearTimer();
          startTimer();
        });
        useEventListener(document, "keydown", keydown);
        useResizeObserver(messageRef, () => {
          height.value = messageRef.value.getBoundingClientRect().height;
        });
        expose({
          visible,
          bottom,
          close
        });
        return (_ctx, _cache) => {
          return vue.openBlock(), vue.createBlock(vue.Transition, {
            name: vue.unref(ns).b("fade"),
            onBeforeLeave: _ctx.onClose,
            onAfterLeave: _cache[0] || (_cache[0] = ($event) => _ctx.$emit("destroy")),
            persisted: ""
          }, {
            default: vue.withCtx(() => [
              vue.withDirectives(vue.createElementVNode("div", {
                id: _ctx.id,
                ref_key: "messageRef",
                ref: messageRef,
                class: vue.normalizeClass([
                  vue.unref(ns).b(),
                  { [vue.unref(ns).m(_ctx.type)]: _ctx.type && !_ctx.icon },
                  vue.unref(ns).is("center", _ctx.center),
                  vue.unref(ns).is("closable", _ctx.showClose),
                  _ctx.customClass
                ]),
                style: vue.normalizeStyle(vue.unref(customStyle)),
                role: "alert",
                onMouseenter: clearTimer,
                onMouseleave: startTimer
              }, [
                _ctx.repeatNum > 1 ? (vue.openBlock(), vue.createBlock(vue.unref(ElBadge), {
                  key: 0,
                  value: _ctx.repeatNum,
                  type: vue.unref(badgeType),
                  class: vue.normalizeClass(vue.unref(ns).e("badge"))
                }, null, 8, ["value", "type", "class"])) : vue.createCommentVNode("v-if", true),
                vue.unref(iconComponent) ? (vue.openBlock(), vue.createBlock(vue.unref(ElIcon), {
                  key: 1,
                  class: vue.normalizeClass([vue.unref(ns).e("icon"), vue.unref(typeClass)])
                }, {
                  default: vue.withCtx(() => [
                    (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(vue.unref(iconComponent))))
                  ]),
                  _: 1
                }, 8, ["class"])) : vue.createCommentVNode("v-if", true),
                vue.renderSlot(_ctx.$slots, "default", {}, () => [
                  !_ctx.dangerouslyUseHTMLString ? (vue.openBlock(), vue.createElementBlock("p", {
                    key: 0,
                    class: vue.normalizeClass(vue.unref(ns).e("content"))
                  }, vue.toDisplayString(_ctx.message), 3)) : (vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: 1 }, [
                    vue.createCommentVNode(" Caution here, message could've been compromised, never use user's input as message "),
                    vue.createElementVNode("p", {
                      class: vue.normalizeClass(vue.unref(ns).e("content")),
                      innerHTML: _ctx.message
                    }, null, 10, _hoisted_2$2)
                  ], 2112))
                ]),
                _ctx.showClose ? (vue.openBlock(), vue.createBlock(vue.unref(ElIcon), {
                  key: 2,
                  class: vue.normalizeClass(vue.unref(ns).e("closeBtn")),
                  onClick: vue.withModifiers(close, ["stop"])
                }, {
                  default: vue.withCtx(() => [
                    vue.createVNode(vue.unref(Close))
                  ]),
                  _: 1
                }, 8, ["class", "onClick"])) : vue.createCommentVNode("v-if", true)
              ], 46, _hoisted_1$2), [
                [vue.vShow, visible.value]
              ])
            ]),
            _: 3
          }, 8, ["name", "onBeforeLeave"]);
        };
      }
    });
    var MessageConstructor = /* @__PURE__ */ _export_sfc(_sfc_main$2, [["__file", "message.vue"]]);
  
    let seed$1 = 1;
    const normalizeOptions = (params) => {
      const options = !params || isString(params) || vue.isVNode(params) || isFunction(params) ? { message: params } : params;
      const normalized = {
        ...messageDefaults,
        ...options
      };
      if (!normalized.appendTo) {
        normalized.appendTo = document.body;
      } else if (isString(normalized.appendTo)) {
        let appendTo = document.querySelector(normalized.appendTo);
        if (!isElement$1(appendTo)) {
          appendTo = document.body;
        }
        normalized.appendTo = appendTo;
      }
      return normalized;
    };
    const closeMessage = (instance) => {
      const idx = instances.indexOf(instance);
      if (idx === -1)
        return;
      instances.splice(idx, 1);
      const { handler } = instance;
      handler.close();
    };
    const createMessage = ({ appendTo, ...options }, context) => {
      const { nextZIndex } = useZIndex();
      const id = `message_${seed$1++}`;
      const userOnClose = options.onClose;
      const container = document.createElement("div");
      const props = {
        ...options,
        zIndex: nextZIndex() + options.zIndex,
        id,
        onClose: () => {
          userOnClose == null ? void 0 : userOnClose();
          closeMessage(instance);
        },
        onDestroy: () => {
          vue.render(null, container);
        }
      };
      const vnode = vue.createVNode(MessageConstructor, props, isFunction(props.message) || vue.isVNode(props.message) ? {
        default: isFunction(props.message) ? props.message : () => props.message
      } : null);
      vnode.appContext = context || message._context;
      vue.render(vnode, container);
      appendTo.appendChild(container.firstElementChild);
      const vm = vnode.component;
      const handler = {
        close: () => {
          vm.exposed.visible.value = false;
        }
      };
      const instance = {
        id,
        vnode,
        vm,
        handler,
        props: vnode.component.props
      };
      return instance;
    };
    const message = (options = {}, context) => {
      if (!isClient)
        return { close: () => void 0 };
      if (isNumber(messageConfig.max) && instances.length >= messageConfig.max) {
        return { close: () => void 0 };
      }
      const normalized = normalizeOptions(options);
      if (normalized.grouping && instances.length) {
        const instance2 = instances.find(({ vnode: vm }) => {
          var _a;
          return ((_a = vm.props) == null ? void 0 : _a.message) === normalized.message;
        });
        if (instance2) {
          instance2.props.repeatNum += 1;
          instance2.props.type = normalized.type;
          return instance2.handler;
        }
      }
      const instance = createMessage(normalized, context);
      instances.push(instance);
      return instance.handler;
    };
    messageTypes.forEach((type) => {
      message[type] = (options = {}, appContext) => {
        const normalized = normalizeOptions(options);
        return message({ ...normalized, type }, appContext);
      };
    });
    function closeAll$1(type) {
      for (const instance of instances) {
        if (!type || type === instance.props.type) {
          instance.handler.close();
        }
      }
    }
    message.closeAll = closeAll$1;
    message._context = null;
    var Message = message;
  
    const ElMessage = withInstallFunction(Message, "$message");
  
    const _sfc_main$1 = vue.defineComponent({
      name: "ElMessageBox",
      directives: {
        TrapFocus
      },
      components: {
        ElButton,
        ElFocusTrap,
        ElInput,
        ElOverlay,
        ElIcon,
        ...TypeComponents
      },
      inheritAttrs: false,
      props: {
        buttonSize: {
          type: String,
          validator: isValidComponentSize
        },
        modal: {
          type: Boolean,
          default: true
        },
        lockScroll: {
          type: Boolean,
          default: true
        },
        showClose: {
          type: Boolean,
          default: true
        },
        closeOnClickModal: {
          type: Boolean,
          default: true
        },
        closeOnPressEscape: {
          type: Boolean,
          default: true
        },
        closeOnHashChange: {
          type: Boolean,
          default: true
        },
        center: Boolean,
        draggable: Boolean,
        roundButton: {
          default: false,
          type: Boolean
        },
        container: {
          type: String,
          default: "body"
        },
        boxType: {
          type: String,
          default: ""
        }
      },
      emits: ["vanish", "action"],
      setup(props, { emit }) {
        const { t } = useLocale();
        const ns = useNamespace("message-box");
        const visible = vue.ref(false);
        const { nextZIndex } = useZIndex();
        const state = vue.reactive({
          autofocus: true,
          beforeClose: null,
          callback: null,
          cancelButtonText: "",
          cancelButtonClass: "",
          confirmButtonText: "",
          confirmButtonClass: "",
          customClass: "",
          customStyle: {},
          dangerouslyUseHTMLString: false,
          distinguishCancelAndClose: false,
          icon: "",
          inputPattern: null,
          inputPlaceholder: "",
          inputType: "text",
          inputValue: null,
          inputValidator: null,
          inputErrorMessage: "",
          message: null,
          modalFade: true,
          modalClass: "",
          showCancelButton: false,
          showConfirmButton: true,
          type: "",
          title: void 0,
          showInput: false,
          action: "",
          confirmButtonLoading: false,
          cancelButtonLoading: false,
          confirmButtonDisabled: false,
          editorErrorMessage: "",
          validateError: false,
          zIndex: nextZIndex()
        });
        const typeClass = vue.computed(() => {
          const type = state.type;
          return { [ns.bm("icon", type)]: type && TypeComponentsMap[type] };
        });
        const contentId = useId();
        const inputId = useId();
        const btnSize = useSize(vue.computed(() => props.buttonSize), { prop: true, form: true, formItem: true });
        const iconComponent = vue.computed(() => state.icon || TypeComponentsMap[state.type] || "");
        const hasMessage = vue.computed(() => !!state.message);
        const rootRef = vue.ref();
        const headerRef = vue.ref();
        const focusStartRef = vue.ref();
        const inputRef = vue.ref();
        const confirmRef = vue.ref();
        const confirmButtonClasses = vue.computed(() => state.confirmButtonClass);
        vue.watch(() => state.inputValue, async (val) => {
          await vue.nextTick();
          if (props.boxType === "prompt" && val !== null) {
            validate();
          }
        }, { immediate: true });
        vue.watch(() => visible.value, (val) => {
          var _a, _b;
          if (val) {
            if (props.boxType !== "prompt") {
              if (state.autofocus) {
                focusStartRef.value = (_b = (_a = confirmRef.value) == null ? void 0 : _a.$el) != null ? _b : rootRef.value;
              } else {
                focusStartRef.value = rootRef.value;
              }
            }
            state.zIndex = nextZIndex();
          }
          if (props.boxType !== "prompt")
            return;
          if (val) {
            vue.nextTick().then(() => {
              var _a2;
              if (inputRef.value && inputRef.value.$el) {
                if (state.autofocus) {
                  focusStartRef.value = (_a2 = getInputElement()) != null ? _a2 : rootRef.value;
                } else {
                  focusStartRef.value = rootRef.value;
                }
              }
            });
          } else {
            state.editorErrorMessage = "";
            state.validateError = false;
          }
        });
        const draggable = vue.computed(() => props.draggable);
        useDraggable(rootRef, headerRef, draggable);
        vue.onMounted(async () => {
          await vue.nextTick();
          if (props.closeOnHashChange) {
            window.addEventListener("hashchange", doClose);
          }
        });
        vue.onBeforeUnmount(() => {
          if (props.closeOnHashChange) {
            window.removeEventListener("hashchange", doClose);
          }
        });
        function doClose() {
          if (!visible.value)
            return;
          visible.value = false;
          vue.nextTick(() => {
            if (state.action)
              emit("action", state.action);
          });
        }
        const handleWrapperClick = () => {
          if (props.closeOnClickModal) {
            handleAction(state.distinguishCancelAndClose ? "close" : "cancel");
          }
        };
        const overlayEvent = useSameTarget(handleWrapperClick);
        const handleInputEnter = (e) => {
          if (state.inputType !== "textarea") {
            e.preventDefault();
            return handleAction("confirm");
          }
        };
        const handleAction = (action) => {
          var _a;
          if (props.boxType === "prompt" && action === "confirm" && !validate()) {
            return;
          }
          state.action = action;
          if (state.beforeClose) {
            (_a = state.beforeClose) == null ? void 0 : _a.call(state, action, state, doClose);
          } else {
            doClose();
          }
        };
        const validate = () => {
          if (props.boxType === "prompt") {
            const inputPattern = state.inputPattern;
            if (inputPattern && !inputPattern.test(state.inputValue || "")) {
              state.editorErrorMessage = state.inputErrorMessage || t("el.messagebox.error");
              state.validateError = true;
              return false;
            }
            const inputValidator = state.inputValidator;
            if (typeof inputValidator === "function") {
              const validateResult = inputValidator(state.inputValue);
              if (validateResult === false) {
                state.editorErrorMessage = state.inputErrorMessage || t("el.messagebox.error");
                state.validateError = true;
                return false;
              }
              if (typeof validateResult === "string") {
                state.editorErrorMessage = validateResult;
                state.validateError = true;
                return false;
              }
            }
          }
          state.editorErrorMessage = "";
          state.validateError = false;
          return true;
        };
        const getInputElement = () => {
          const inputRefs = inputRef.value.$refs;
          return inputRefs.input || inputRefs.textarea;
        };
        const handleClose = () => {
          handleAction("close");
        };
        const onCloseRequested = () => {
          if (props.closeOnPressEscape) {
            handleClose();
          }
        };
        if (props.lockScroll) {
          useLockscreen(visible);
        }
        useRestoreActive(visible);
        return {
          ...vue.toRefs(state),
          ns,
          overlayEvent,
          visible,
          hasMessage,
          typeClass,
          contentId,
          inputId,
          btnSize,
          iconComponent,
          confirmButtonClasses,
          rootRef,
          focusStartRef,
          headerRef,
          inputRef,
          confirmRef,
          doClose,
          handleClose,
          onCloseRequested,
          handleWrapperClick,
          handleInputEnter,
          handleAction,
          t
        };
      }
    });
    const _hoisted_1$1 = ["aria-label", "aria-describedby"];
    const _hoisted_2$1 = ["aria-label"];
    const _hoisted_3$1 = ["id"];
    function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
      const _component_el_icon = vue.resolveComponent("el-icon");
      const _component_close = vue.resolveComponent("close");
      const _component_el_input = vue.resolveComponent("el-input");
      const _component_el_button = vue.resolveComponent("el-button");
      const _component_el_focus_trap = vue.resolveComponent("el-focus-trap");
      const _component_el_overlay = vue.resolveComponent("el-overlay");
      return vue.openBlock(), vue.createBlock(vue.Transition, {
        name: "fade-in-linear",
        onAfterLeave: _cache[11] || (_cache[11] = ($event) => _ctx.$emit("vanish")),
        persisted: ""
      }, {
        default: vue.withCtx(() => [
          vue.withDirectives(vue.createVNode(_component_el_overlay, {
            "z-index": _ctx.zIndex,
            "overlay-class": [_ctx.ns.is("message-box"), _ctx.modalClass],
            mask: _ctx.modal
          }, {
            default: vue.withCtx(() => [
              vue.createElementVNode("div", {
                role: "dialog",
                "aria-label": _ctx.title,
                "aria-modal": "true",
                "aria-describedby": !_ctx.showInput ? _ctx.contentId : void 0,
                class: vue.normalizeClass(`${_ctx.ns.namespace.value}-overlay-message-box`),
                onClick: _cache[8] || (_cache[8] = (...args) => _ctx.overlayEvent.onClick && _ctx.overlayEvent.onClick(...args)),
                onMousedown: _cache[9] || (_cache[9] = (...args) => _ctx.overlayEvent.onMousedown && _ctx.overlayEvent.onMousedown(...args)),
                onMouseup: _cache[10] || (_cache[10] = (...args) => _ctx.overlayEvent.onMouseup && _ctx.overlayEvent.onMouseup(...args))
              }, [
                vue.createVNode(_component_el_focus_trap, {
                  loop: "",
                  trapped: _ctx.visible,
                  "focus-trap-el": _ctx.rootRef,
                  "focus-start-el": _ctx.focusStartRef,
                  onReleaseRequested: _ctx.onCloseRequested
                }, {
                  default: vue.withCtx(() => [
                    vue.createElementVNode("div", {
                      ref: "rootRef",
                      class: vue.normalizeClass([
                        _ctx.ns.b(),
                        _ctx.customClass,
                        _ctx.ns.is("draggable", _ctx.draggable),
                        { [_ctx.ns.m("center")]: _ctx.center }
                      ]),
                      style: vue.normalizeStyle(_ctx.customStyle),
                      tabindex: "-1",
                      onClick: _cache[7] || (_cache[7] = vue.withModifiers(() => {
                      }, ["stop"]))
                    }, [
                      _ctx.title !== null && _ctx.title !== void 0 ? (vue.openBlock(), vue.createElementBlock("div", {
                        key: 0,
                        ref: "headerRef",
                        class: vue.normalizeClass(_ctx.ns.e("header"))
                      }, [
                        vue.createElementVNode("div", {
                          class: vue.normalizeClass(_ctx.ns.e("title"))
                        }, [
                          _ctx.iconComponent && _ctx.center ? (vue.openBlock(), vue.createBlock(_component_el_icon, {
                            key: 0,
                            class: vue.normalizeClass([_ctx.ns.e("status"), _ctx.typeClass])
                          }, {
                            default: vue.withCtx(() => [
                              (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(_ctx.iconComponent)))
                            ]),
                            _: 1
                          }, 8, ["class"])) : vue.createCommentVNode("v-if", true),
                          vue.createElementVNode("span", null, vue.toDisplayString(_ctx.title), 1)
                        ], 2),
                        _ctx.showClose ? (vue.openBlock(), vue.createElementBlock("button", {
                          key: 0,
                          type: "button",
                          class: vue.normalizeClass(_ctx.ns.e("headerbtn")),
                          "aria-label": _ctx.t("el.messagebox.close"),
                          onClick: _cache[0] || (_cache[0] = ($event) => _ctx.handleAction(_ctx.distinguishCancelAndClose ? "close" : "cancel")),
                          onKeydown: _cache[1] || (_cache[1] = vue.withKeys(vue.withModifiers(($event) => _ctx.handleAction(_ctx.distinguishCancelAndClose ? "close" : "cancel"), ["prevent"]), ["enter"]))
                        }, [
                          vue.createVNode(_component_el_icon, {
                            class: vue.normalizeClass(_ctx.ns.e("close"))
                          }, {
                            default: vue.withCtx(() => [
                              vue.createVNode(_component_close)
                            ]),
                            _: 1
                          }, 8, ["class"])
                        ], 42, _hoisted_2$1)) : vue.createCommentVNode("v-if", true)
                      ], 2)) : vue.createCommentVNode("v-if", true),
                      vue.createElementVNode("div", {
                        id: _ctx.contentId,
                        class: vue.normalizeClass(_ctx.ns.e("content"))
                      }, [
                        vue.createElementVNode("div", {
                          class: vue.normalizeClass(_ctx.ns.e("container"))
                        }, [
                          _ctx.iconComponent && !_ctx.center && _ctx.hasMessage ? (vue.openBlock(), vue.createBlock(_component_el_icon, {
                            key: 0,
                            class: vue.normalizeClass([_ctx.ns.e("status"), _ctx.typeClass])
                          }, {
                            default: vue.withCtx(() => [
                              (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(_ctx.iconComponent)))
                            ]),
                            _: 1
                          }, 8, ["class"])) : vue.createCommentVNode("v-if", true),
                          _ctx.hasMessage ? (vue.openBlock(), vue.createElementBlock("div", {
                            key: 1,
                            class: vue.normalizeClass(_ctx.ns.e("message"))
                          }, [
                            vue.renderSlot(_ctx.$slots, "default", {}, () => [
                              !_ctx.dangerouslyUseHTMLString ? (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(_ctx.showInput ? "label" : "p"), {
                                key: 0,
                                for: _ctx.showInput ? _ctx.inputId : void 0
                              }, {
                                default: vue.withCtx(() => [
                                  vue.createTextVNode(vue.toDisplayString(!_ctx.dangerouslyUseHTMLString ? _ctx.message : ""), 1)
                                ]),
                                _: 1
                              }, 8, ["for"])) : (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(_ctx.showInput ? "label" : "p"), {
                                key: 1,
                                for: _ctx.showInput ? _ctx.inputId : void 0,
                                innerHTML: _ctx.message
                              }, null, 8, ["for", "innerHTML"]))
                            ])
                          ], 2)) : vue.createCommentVNode("v-if", true)
                        ], 2),
                        vue.withDirectives(vue.createElementVNode("div", {
                          class: vue.normalizeClass(_ctx.ns.e("input"))
                        }, [
                          vue.createVNode(_component_el_input, {
                            id: _ctx.inputId,
                            ref: "inputRef",
                            modelValue: _ctx.inputValue,
                            "onUpdate:modelValue": _cache[2] || (_cache[2] = ($event) => _ctx.inputValue = $event),
                            type: _ctx.inputType,
                            placeholder: _ctx.inputPlaceholder,
                            "aria-invalid": _ctx.validateError,
                            class: vue.normalizeClass({ invalid: _ctx.validateError }),
                            onKeydown: vue.withKeys(_ctx.handleInputEnter, ["enter"])
                          }, null, 8, ["id", "modelValue", "type", "placeholder", "aria-invalid", "class", "onKeydown"]),
                          vue.createElementVNode("div", {
                            class: vue.normalizeClass(_ctx.ns.e("errormsg")),
                            style: vue.normalizeStyle({
                              visibility: !!_ctx.editorErrorMessage ? "visible" : "hidden"
                            })
                          }, vue.toDisplayString(_ctx.editorErrorMessage), 7)
                        ], 2), [
                          [vue.vShow, _ctx.showInput]
                        ])
                      ], 10, _hoisted_3$1),
                      vue.createElementVNode("div", {
                        class: vue.normalizeClass(_ctx.ns.e("btns"))
                      }, [
                        _ctx.showCancelButton ? (vue.openBlock(), vue.createBlock(_component_el_button, {
                          key: 0,
                          loading: _ctx.cancelButtonLoading,
                          class: vue.normalizeClass([_ctx.cancelButtonClass]),
                          round: _ctx.roundButton,
                          size: _ctx.btnSize,
                          onClick: _cache[3] || (_cache[3] = ($event) => _ctx.handleAction("cancel")),
                          onKeydown: _cache[4] || (_cache[4] = vue.withKeys(vue.withModifiers(($event) => _ctx.handleAction("cancel"), ["prevent"]), ["enter"]))
                        }, {
                          default: vue.withCtx(() => [
                            vue.createTextVNode(vue.toDisplayString(_ctx.cancelButtonText || _ctx.t("el.messagebox.cancel")), 1)
                          ]),
                          _: 1
                        }, 8, ["loading", "class", "round", "size"])) : vue.createCommentVNode("v-if", true),
                        vue.withDirectives(vue.createVNode(_component_el_button, {
                          ref: "confirmRef",
                          type: "primary",
                          loading: _ctx.confirmButtonLoading,
                          class: vue.normalizeClass([_ctx.confirmButtonClasses]),
                          round: _ctx.roundButton,
                          disabled: _ctx.confirmButtonDisabled,
                          size: _ctx.btnSize,
                          onClick: _cache[5] || (_cache[5] = ($event) => _ctx.handleAction("confirm")),
                          onKeydown: _cache[6] || (_cache[6] = vue.withKeys(vue.withModifiers(($event) => _ctx.handleAction("confirm"), ["prevent"]), ["enter"]))
                        }, {
                          default: vue.withCtx(() => [
                            vue.createTextVNode(vue.toDisplayString(_ctx.confirmButtonText || _ctx.t("el.messagebox.confirm")), 1)
                          ]),
                          _: 1
                        }, 8, ["loading", "class", "round", "disabled", "size"]), [
                          [vue.vShow, _ctx.showConfirmButton]
                        ])
                      ], 2)
                    ], 6)
                  ]),
                  _: 3
                }, 8, ["trapped", "focus-trap-el", "focus-start-el", "onReleaseRequested"])
              ], 42, _hoisted_1$1)
            ]),
            _: 3
          }, 8, ["z-index", "overlay-class", "mask"]), [
            [vue.vShow, _ctx.visible]
          ])
        ]),
        _: 3
      });
    }
    var MessageBoxConstructor = /* @__PURE__ */ _export_sfc(_sfc_main$1, [["render", _sfc_render], ["__file", "index.vue"]]);
  
    const messageInstance = /* @__PURE__ */ new Map();
    const getAppendToElement = (props) => {
      let appendTo = document.body;
      if (props.appendTo) {
        if (isString(props.appendTo)) {
          appendTo = document.querySelector(props.appendTo);
        }
        if (isElement$1(props.appendTo)) {
          appendTo = props.appendTo;
        }
        if (!isElement$1(appendTo)) {
          appendTo = document.body;
        }
      }
      return appendTo;
    };
    const initInstance = (props, container, appContext = null) => {
      const vnode = vue.createVNode(MessageBoxConstructor, props, isFunction(props.message) || vue.isVNode(props.message) ? {
        default: isFunction(props.message) ? props.message : () => props.message
      } : null);
      vnode.appContext = appContext;
      vue.render(vnode, container);
      getAppendToElement(props).appendChild(container.firstElementChild);
      return vnode.component;
    };
    const genContainer = () => {
      return document.createElement("div");
    };
    const showMessage = (options, appContext) => {
      const container = genContainer();
      options.onVanish = () => {
        vue.render(null, container);
        messageInstance.delete(vm);
      };
      options.onAction = (action) => {
        const currentMsg = messageInstance.get(vm);
        let resolve;
        if (options.showInput) {
          resolve = { value: vm.inputValue, action };
        } else {
          resolve = action;
        }
        if (options.callback) {
          options.callback(resolve, instance.proxy);
        } else {
          if (action === "cancel" || action === "close") {
            if (options.distinguishCancelAndClose && action !== "cancel") {
              currentMsg.reject("close");
            } else {
              currentMsg.reject("cancel");
            }
          } else {
            currentMsg.resolve(resolve);
          }
        }
      };
      const instance = initInstance(options, container, appContext);
      const vm = instance.proxy;
      for (const prop in options) {
        if (hasOwn(options, prop) && !hasOwn(vm.$props, prop)) {
          vm[prop] = options[prop];
        }
      }
      vm.visible = true;
      return vm;
    };
    function MessageBox(options, appContext = null) {
      if (!isClient)
        return Promise.reject();
      let callback;
      if (isString(options) || vue.isVNode(options)) {
        options = {
          message: options
        };
      } else {
        callback = options.callback;
      }
      return new Promise((resolve, reject) => {
        const vm = showMessage(options, appContext != null ? appContext : MessageBox._context);
        messageInstance.set(vm, {
          options,
          callback,
          resolve,
          reject
        });
      });
    }
    const MESSAGE_BOX_VARIANTS = ["alert", "confirm", "prompt"];
    const MESSAGE_BOX_DEFAULT_OPTS = {
      alert: { closeOnPressEscape: false, closeOnClickModal: false },
      confirm: { showCancelButton: true },
      prompt: { showCancelButton: true, showInput: true }
    };
    MESSAGE_BOX_VARIANTS.forEach((boxType) => {
      MessageBox[boxType] = messageBoxFactory(boxType);
    });
    function messageBoxFactory(boxType) {
      return (message, title, options, appContext) => {
        let titleOrOpts = "";
        if (isObject$1(title)) {
          options = title;
          titleOrOpts = "";
        } else if (isUndefined(title)) {
          titleOrOpts = "";
        } else {
          titleOrOpts = title;
        }
        return MessageBox(Object.assign({
          title: titleOrOpts,
          message,
          type: "",
          ...MESSAGE_BOX_DEFAULT_OPTS[boxType]
        }, options, {
          boxType
        }), appContext);
      };
    }
    MessageBox.close = () => {
      messageInstance.forEach((_, vm) => {
        vm.doClose();
      });
      messageInstance.clear();
    };
    MessageBox._context = null;
  
    const _MessageBox = MessageBox;
    _MessageBox.install = (app) => {
      _MessageBox._context = app._context;
      app.config.globalProperties.$msgbox = _MessageBox;
      app.config.globalProperties.$messageBox = _MessageBox;
      app.config.globalProperties.$alert = _MessageBox.alert;
      app.config.globalProperties.$confirm = _MessageBox.confirm;
      app.config.globalProperties.$prompt = _MessageBox.prompt;
    };
    const ElMessageBox = _MessageBox;
  
    const notificationTypes = [
      "success",
      "info",
      "warning",
      "error"
    ];
    const notificationProps = buildProps({
      customClass: {
        type: String,
        default: ""
      },
      dangerouslyUseHTMLString: {
        type: Boolean,
        default: false
      },
      duration: {
        type: Number,
        default: 4500
      },
      icon: {
        type: iconPropType
      },
      id: {
        type: String,
        default: ""
      },
      message: {
        type: definePropType([String, Object]),
        default: ""
      },
      offset: {
        type: Number,
        default: 0
      },
      onClick: {
        type: definePropType(Function),
        default: () => void 0
      },
      onClose: {
        type: definePropType(Function),
        required: true
      },
      position: {
        type: String,
        values: ["top-right", "top-left", "bottom-right", "bottom-left"],
        default: "top-right"
      },
      showClose: {
        type: Boolean,
        default: true
      },
      title: {
        type: String,
        default: ""
      },
      type: {
        type: String,
        values: [...notificationTypes, ""],
        default: ""
      },
      zIndex: {
        type: Number,
        default: 0
      }
    });
    const notificationEmits = {
      destroy: () => true
    };
  
    const _hoisted_1 = ["id"];
    const _hoisted_2 = ["textContent"];
    const _hoisted_3 = { key: 0 };
    const _hoisted_4 = ["innerHTML"];
    const __default__ = vue.defineComponent({
      name: "ElNotification"
    });
    const _sfc_main = /* @__PURE__ */ vue.defineComponent({
      ...__default__,
      props: notificationProps,
      emits: notificationEmits,
      setup(__props, { expose }) {
        const props = __props;
        const ns = useNamespace("notification");
        const { Close } = CloseComponents;
        const visible = vue.ref(false);
        let timer = void 0;
        const typeClass = vue.computed(() => {
          const type = props.type;
          return type && TypeComponentsMap[props.type] ? ns.m(type) : "";
        });
        const iconComponent = vue.computed(() => {
          if (!props.type)
            return props.icon;
          return TypeComponentsMap[props.type] || props.icon;
        });
        const horizontalClass = vue.computed(() => props.position.endsWith("right") ? "right" : "left");
        const verticalProperty = vue.computed(() => props.position.startsWith("top") ? "top" : "bottom");
        const positionStyle = vue.computed(() => {
          return {
            [verticalProperty.value]: `${props.offset}px`,
            zIndex: props.zIndex
          };
        });
        function startTimer() {
          if (props.duration > 0) {
            ({ stop: timer } = useTimeoutFn(() => {
              if (visible.value)
                close();
            }, props.duration));
          }
        }
        function clearTimer() {
          timer == null ? void 0 : timer();
        }
        function close() {
          visible.value = false;
        }
        function onKeydown({ code }) {
          if (code === EVENT_CODE.delete || code === EVENT_CODE.backspace) {
            clearTimer();
          } else if (code === EVENT_CODE.esc) {
            if (visible.value) {
              close();
            }
          } else {
            startTimer();
          }
        }
        vue.onMounted(() => {
          startTimer();
          visible.value = true;
        });
        useEventListener(document, "keydown", onKeydown);
        expose({
          visible,
          close
        });
        return (_ctx, _cache) => {
          return vue.openBlock(), vue.createBlock(vue.Transition, {
            name: vue.unref(ns).b("fade"),
            onBeforeLeave: _ctx.onClose,
            onAfterLeave: _cache[1] || (_cache[1] = ($event) => _ctx.$emit("destroy")),
            persisted: ""
          }, {
            default: vue.withCtx(() => [
              vue.withDirectives(vue.createElementVNode("div", {
                id: _ctx.id,
                class: vue.normalizeClass([vue.unref(ns).b(), _ctx.customClass, vue.unref(horizontalClass)]),
                style: vue.normalizeStyle(vue.unref(positionStyle)),
                role: "alert",
                onMouseenter: clearTimer,
                onMouseleave: startTimer,
                onClick: _cache[0] || (_cache[0] = (...args) => _ctx.onClick && _ctx.onClick(...args))
              }, [
                vue.unref(iconComponent) ? (vue.openBlock(), vue.createBlock(vue.unref(ElIcon), {
                  key: 0,
                  class: vue.normalizeClass([vue.unref(ns).e("icon"), vue.unref(typeClass)])
                }, {
                  default: vue.withCtx(() => [
                    (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(vue.unref(iconComponent))))
                  ]),
                  _: 1
                }, 8, ["class"])) : vue.createCommentVNode("v-if", true),
                vue.createElementVNode("div", {
                  class: vue.normalizeClass(vue.unref(ns).e("group"))
                }, [
                  vue.createElementVNode("h2", {
                    class: vue.normalizeClass(vue.unref(ns).e("title")),
                    textContent: vue.toDisplayString(_ctx.title)
                  }, null, 10, _hoisted_2),
                  vue.withDirectives(vue.createElementVNode("div", {
                    class: vue.normalizeClass(vue.unref(ns).e("content")),
                    style: vue.normalizeStyle(!!_ctx.title ? void 0 : { margin: 0 })
                  }, [
                    vue.renderSlot(_ctx.$slots, "default", {}, () => [
                      !_ctx.dangerouslyUseHTMLString ? (vue.openBlock(), vue.createElementBlock("p", _hoisted_3, vue.toDisplayString(_ctx.message), 1)) : (vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: 1 }, [
                        vue.createCommentVNode(" Caution here, message could've been compromised, never use user's input as message "),
                        vue.createElementVNode("p", { innerHTML: _ctx.message }, null, 8, _hoisted_4)
                      ], 2112))
                    ])
                  ], 6), [
                    [vue.vShow, _ctx.message]
                  ]),
                  _ctx.showClose ? (vue.openBlock(), vue.createBlock(vue.unref(ElIcon), {
                    key: 0,
                    class: vue.normalizeClass(vue.unref(ns).e("closeBtn")),
                    onClick: vue.withModifiers(close, ["stop"])
                  }, {
                    default: vue.withCtx(() => [
                      vue.createVNode(vue.unref(Close))
                    ]),
                    _: 1
                  }, 8, ["class", "onClick"])) : vue.createCommentVNode("v-if", true)
                ], 2)
              ], 46, _hoisted_1), [
                [vue.vShow, visible.value]
              ])
            ]),
            _: 3
          }, 8, ["name", "onBeforeLeave"]);
        };
      }
    });
    var NotificationConstructor = /* @__PURE__ */ _export_sfc(_sfc_main, [["__file", "notification.vue"]]);
  
    const notifications = {
      "top-left": [],
      "top-right": [],
      "bottom-left": [],
      "bottom-right": []
    };
    const GAP_SIZE = 16;
    let seed = 1;
    const notify = function(options = {}, context = null) {
      if (!isClient)
        return { close: () => void 0 };
      if (typeof options === "string" || vue.isVNode(options)) {
        options = { message: options };
      }
      const position = options.position || "top-right";
      let verticalOffset = options.offset || 0;
      notifications[position].forEach(({ vm: vm2 }) => {
        var _a;
        verticalOffset += (((_a = vm2.el) == null ? void 0 : _a.offsetHeight) || 0) + GAP_SIZE;
      });
      verticalOffset += GAP_SIZE;
      const { nextZIndex } = useZIndex();
      const id = `notification_${seed++}`;
      const userOnClose = options.onClose;
      const props = {
        ...options,
        zIndex: nextZIndex(),
        offset: verticalOffset,
        id,
        onClose: () => {
          close(id, position, userOnClose);
        }
      };
      let appendTo = document.body;
      if (isElement$1(options.appendTo)) {
        appendTo = options.appendTo;
      } else if (isString(options.appendTo)) {
        appendTo = document.querySelector(options.appendTo);
      }
      if (!isElement$1(appendTo)) {
        appendTo = document.body;
      }
      const container = document.createElement("div");
      const vm = vue.createVNode(NotificationConstructor, props, vue.isVNode(props.message) ? {
        default: () => props.message
      } : null);
      vm.appContext = context != null ? context : notify._context;
      vm.props.onDestroy = () => {
        vue.render(null, container);
      };
      vue.render(vm, container);
      notifications[position].push({ vm });
      appendTo.appendChild(container.firstElementChild);
      return {
        close: () => {
          vm.component.exposed.visible.value = false;
        }
      };
    };
    notificationTypes.forEach((type) => {
      notify[type] = (options = {}) => {
        if (typeof options === "string" || vue.isVNode(options)) {
          options = {
            message: options
          };
        }
        return notify({
          ...options,
          type
        });
      };
    });
    function close(id, position, userOnClose) {
      const orientedNotifications = notifications[position];
      const idx = orientedNotifications.findIndex(({ vm: vm2 }) => {
        var _a;
        return ((_a = vm2.component) == null ? void 0 : _a.props.id) === id;
      });
      if (idx === -1)
        return;
      const { vm } = orientedNotifications[idx];
      if (!vm)
        return;
      userOnClose == null ? void 0 : userOnClose(vm);
      const removedHeight = vm.el.offsetHeight;
      const verticalPos = position.split("-")[0];
      orientedNotifications.splice(idx, 1);
      const len = orientedNotifications.length;
      if (len < 1)
        return;
      for (let i = idx; i < len; i++) {
        const { el, component } = orientedNotifications[i].vm;
        const pos = Number.parseInt(el.style[verticalPos], 10) - removedHeight - GAP_SIZE;
        component.props.offset = pos;
      }
    }
    function closeAll() {
      for (const orientedNotifications of Object.values(notifications)) {
        orientedNotifications.forEach(({ vm }) => {
          vm.component.exposed.visible.value = false;
        });
      }
    }
    notify.closeAll = closeAll;
    notify._context = null;
    var Notify = notify;
  
    const ElNotification = withInstallFunction(Notify, "$notify");
  
    var Plugins = [
      ElInfiniteScroll,
      ElLoading,
      ElMessage,
      ElMessageBox,
      ElNotification,
      ElPopoverDirective
    ];
  
    var installer = makeInstaller([...Components, ...Plugins]);
  
    const install = installer.install;
    const version = installer.version;
  
    exports.BAR_MAP = BAR_MAP;
    exports.CASCADER_PANEL_INJECTION_KEY = CASCADER_PANEL_INJECTION_KEY;
    exports.CHANGE_EVENT = CHANGE_EVENT;
    exports.ClickOutside = ClickOutside;
    exports.CommonPicker = CommonPicker;
    exports.CommonProps = CommonProps;
    exports.DEFAULT_FORMATS_DATE = DEFAULT_FORMATS_DATE;
    exports.DEFAULT_FORMATS_DATEPICKER = DEFAULT_FORMATS_DATEPICKER;
    exports.DEFAULT_FORMATS_TIME = DEFAULT_FORMATS_TIME;
    exports.DROPDOWN_COLLECTION_INJECTION_KEY = COLLECTION_INJECTION_KEY;
    exports.DROPDOWN_COLLECTION_ITEM_INJECTION_KEY = COLLECTION_ITEM_INJECTION_KEY;
    exports.DROPDOWN_INJECTION_KEY = DROPDOWN_INJECTION_KEY;
    exports.DefaultProps = DefaultProps;
    exports.DynamicSizeGrid = DynamicSizeGrid$1;
    exports.DynamicSizeList = DynamicSizeList$1;
    exports.EVENT_CODE = EVENT_CODE;
    exports.Effect = Effect;
    exports.ElAffix = ElAffix;
    exports.ElAlert = ElAlert;
    exports.ElAside = ElAside;
    exports.ElAutoResizer = ElAutoResizer;
    exports.ElAutocomplete = ElAutocomplete;
    exports.ElAvatar = ElAvatar;
    exports.ElBacktop = ElBacktop;
    exports.ElBadge = ElBadge;
    exports.ElBreadcrumb = ElBreadcrumb;
    exports.ElBreadcrumbItem = ElBreadcrumbItem;
    exports.ElButton = ElButton;
    exports.ElButtonGroup = ElButtonGroup$1;
    exports.ElCalendar = ElCalendar;
    exports.ElCard = ElCard;
    exports.ElCarousel = ElCarousel;
    exports.ElCarouselItem = ElCarouselItem;
    exports.ElCascader = ElCascader;
    exports.ElCascaderPanel = ElCascaderPanel;
    exports.ElCheckTag = ElCheckTag;
    exports.ElCheckbox = ElCheckbox;
    exports.ElCheckboxButton = ElCheckboxButton;
    exports.ElCheckboxGroup = ElCheckboxGroup$1;
    exports.ElCol = ElCol;
    exports.ElCollapse = ElCollapse;
    exports.ElCollapseItem = ElCollapseItem;
    exports.ElCollapseTransition = ElCollapseTransition;
    exports.ElCollection = ElCollection;
    exports.ElCollectionItem = ElCollectionItem;
    exports.ElColorPicker = ElColorPicker;
    exports.ElConfigProvider = ElConfigProvider;
    exports.ElContainer = ElContainer;
    exports.ElDatePicker = ElDatePicker;
    exports.ElDescriptions = ElDescriptions;
    exports.ElDescriptionsItem = ElDescriptionsItem;
    exports.ElDialog = ElDialog;
    exports.ElDivider = ElDivider;
    exports.ElDrawer = ElDrawer;
    exports.ElDropdown = ElDropdown;
    exports.ElDropdownItem = ElDropdownItem;
    exports.ElDropdownMenu = ElDropdownMenu;
    exports.ElEmpty = ElEmpty;
    exports.ElFooter = ElFooter;
    exports.ElForm = ElForm;
    exports.ElFormItem = ElFormItem;
    exports.ElHeader = ElHeader;
    exports.ElIcon = ElIcon;
    exports.ElImage = ElImage;
    exports.ElImageViewer = ElImageViewer;
    exports.ElInfiniteScroll = ElInfiniteScroll;
    exports.ElInput = ElInput;
    exports.ElInputNumber = ElInputNumber;
    exports.ElLink = ElLink;
    exports.ElLoading = ElLoading;
    exports.ElLoadingDirective = vLoading;
    exports.ElLoadingService = Loading;
    exports.ElMain = ElMain;
    exports.ElMenu = ElMenu;
    exports.ElMenuItem = ElMenuItem;
    exports.ElMenuItemGroup = ElMenuItemGroup;
    exports.ElMessage = ElMessage;
    exports.ElMessageBox = ElMessageBox;
    exports.ElNotification = ElNotification;
    exports.ElOption = ElOption;
    exports.ElOptionGroup = ElOptionGroup;
    exports.ElOverlay = ElOverlay;
    exports.ElPageHeader = ElPageHeader;
    exports.ElPagination = ElPagination;
    exports.ElPopconfirm = ElPopconfirm;
    exports.ElPopover = ElPopover;
    exports.ElPopoverDirective = ElPopoverDirective;
    exports.ElPopper = ElPopper;
    exports.ElPopperArrow = ElPopperArrow;
    exports.ElPopperContent = ElPopperContent;
    exports.ElPopperTrigger = ElPopperTrigger;
    exports.ElProgress = ElProgress;
    exports.ElRadio = ElRadio;
    exports.ElRadioButton = ElRadioButton;
    exports.ElRadioGroup = ElRadioGroup;
    exports.ElRate = ElRate;
    exports.ElResult = ElResult;
    exports.ElRow = ElRow;
    exports.ElScrollbar = ElScrollbar;
    exports.ElSelect = ElSelect;
    exports.ElSelectV2 = ElSelectV2;
    exports.ElSkeleton = ElSkeleton;
    exports.ElSkeletonItem = ElSkeletonItem;
    exports.ElSlider = ElSlider;
    exports.ElSpace = ElSpace;
    exports.ElStep = ElStep;
    exports.ElSteps = ElSteps;
    exports.ElSubMenu = ElSubMenu;
    exports.ElSwitch = ElSwitch;
    exports.ElTabPane = ElTabPane;
    exports.ElTable = ElTable;
    exports.ElTableColumn = ElTableColumn;
    exports.ElTableV2 = ElTableV2;
    exports.ElTabs = ElTabs;
    exports.ElTag = ElTag;
    exports.ElTimePicker = ElTimePicker;
    exports.ElTimeSelect = ElTimeSelect;
    exports.ElTimeline = ElTimeline;
    exports.ElTimelineItem = ElTimelineItem;
    exports.ElTooltip = ElTooltip;
    exports.ElTransfer = ElTransfer;
    exports.ElTree = ElTree;
    exports.ElTreeSelect = ElTreeSelect;
    exports.ElTreeV2 = ElTreeV2;
    exports.ElUpload = ElUpload;
    exports.FIRST_KEYS = FIRST_KEYS;
    exports.FIRST_LAST_KEYS = FIRST_LAST_KEYS;
    exports.FORWARD_REF_INJECTION_KEY = FORWARD_REF_INJECTION_KEY;
    exports.FixedSizeGrid = FixedSizeGrid$1;
    exports.FixedSizeList = FixedSizeList$1;
    exports.GAP = GAP;
    exports.ID_INJECTION_KEY = ID_INJECTION_KEY;
    exports.INPUT_EVENT = INPUT_EVENT;
    exports.INSTALLED_KEY = INSTALLED_KEY;
    exports.IconComponentMap = IconComponentMap;
    exports.IconMap = IconMap;
    exports.LAST_KEYS = LAST_KEYS;
    exports.LEFT_CHECK_CHANGE_EVENT = LEFT_CHECK_CHANGE_EVENT;
    exports.Mousewheel = Mousewheel;
    exports.POPPER_CONTAINER_ID = POPPER_CONTAINER_ID;
    exports.POPPER_CONTAINER_SELECTOR = POPPER_CONTAINER_SELECTOR;
    exports.POPPER_CONTENT_INJECTION_KEY = POPPER_CONTENT_INJECTION_KEY;
    exports.POPPER_INJECTION_KEY = POPPER_INJECTION_KEY;
    exports.RIGHT_CHECK_CHANGE_EVENT = RIGHT_CHECK_CHANGE_EVENT;
    exports.ROOT_PICKER_INJECTION_KEY = ROOT_PICKER_INJECTION_KEY;
    exports.RowAlign = RowAlign;
    exports.RowJustify = RowJustify;
    exports.TOOLTIP_INJECTION_KEY = TOOLTIP_INJECTION_KEY;
    exports.TOOLTIP_V2_OPEN = TOOLTIP_V2_OPEN;
    exports.TableV2 = TableV2$1;
    exports.TableV2Alignment = Alignment;
    exports.TableV2FixedDir = FixedDir;
    exports.TableV2Placeholder = placeholderSign;
    exports.TableV2SortOrder = SortOrder;
    exports.TimePickPanel = TimePickPanel;
    exports.TrapFocus = TrapFocus;
    exports.UPDATE_MODEL_EVENT = UPDATE_MODEL_EVENT;
    exports.WEEK_DAYS = WEEK_DAYS;
    exports.affixEmits = affixEmits;
    exports.affixProps = affixProps;
    exports.alertEffects = alertEffects;
    exports.alertEmits = alertEmits;
    exports.alertProps = alertProps;
    exports.arrowMiddleware = arrowMiddleware;
    exports.autoResizerProps = autoResizerProps;
    exports.autocompleteEmits = autocompleteEmits;
    exports.autocompleteProps = autocompleteProps;
    exports.avatarEmits = avatarEmits;
    exports.avatarProps = avatarProps;
    exports.backtopEmits = backtopEmits;
    exports.backtopProps = backtopProps;
    exports.badgeProps = badgeProps;
    exports.breadcrumbItemProps = breadcrumbItemProps;
    exports.breadcrumbKey = breadcrumbKey;
    exports.breadcrumbProps = breadcrumbProps;
    exports.buildLocaleContext = buildLocaleContext;
    exports.buildTimeList = buildTimeList;
    exports.buildTranslator = buildTranslator;
    exports.buttonEmits = buttonEmits;
    exports.buttonGroupContextKey = buttonGroupContextKey;
    exports.buttonNativeTypes = buttonNativeTypes;
    exports.buttonProps = buttonProps;
    exports.buttonTypes = buttonTypes;
    exports.calendarEmits = calendarEmits;
    exports.calendarProps = calendarProps;
    exports.cardProps = cardProps;
    exports.carouselContextKey = carouselContextKey;
    exports.carouselEmits = carouselEmits;
    exports.carouselItemProps = carouselItemProps;
    exports.carouselProps = carouselProps;
    exports.checkTagEmits = checkTagEmits;
    exports.checkTagProps = checkTagProps;
    exports.checkboxEmits = checkboxEmits;
    exports.checkboxGroupContextKey = checkboxGroupContextKey;
    exports.checkboxGroupEmits = checkboxGroupEmits;
    exports.checkboxGroupProps = checkboxGroupProps;
    exports.checkboxProps = checkboxProps;
    exports.colProps = colProps;
    exports.collapseContextKey = collapseContextKey;
    exports.collapseEmits = collapseEmits;
    exports.collapseItemProps = collapseItemProps;
    exports.collapseProps = collapseProps;
    exports.colorPickerContextKey = colorPickerContextKey;
    exports.colorPickerEmits = colorPickerEmits;
    exports.colorPickerProps = colorPickerProps;
    exports.componentSizeMap = componentSizeMap;
    exports.componentSizes = componentSizes;
    exports.configProviderContextKey = configProviderContextKey;
    exports.configProviderProps = configProviderProps;
    exports.createModelToggleComposable = createModelToggleComposable;
    exports.dateEquals = dateEquals;
    exports.datePickTypes = datePickTypes;
    exports.dayjs = dayjs;
    exports["default"] = installer;
    exports.defaultNamespace = defaultNamespace;
    exports.descriptionProps = descriptionProps;
    exports.dialogEmits = dialogEmits;
    exports.dialogInjectionKey = dialogInjectionKey;
    exports.dialogProps = dialogProps;
    exports.dividerProps = dividerProps;
    exports.drawerEmits = drawerEmits;
    exports.drawerProps = drawerProps;
    exports.dropdownItemProps = dropdownItemProps;
    exports.dropdownMenuProps = dropdownMenuProps;
    exports.dropdownProps = dropdownProps;
    exports.elPaginationKey = elPaginationKey;
    exports.emitChangeFn = emitChangeFn;
    exports.emptyProps = emptyProps;
    exports.extractDateFormat = extractDateFormat;
    exports.extractTimeFormat = extractTimeFormat;
    exports.formContextKey = formContextKey;
    exports.formEmits = formEmits;
    exports.formItemContextKey = formItemContextKey;
    exports.formItemProps = formItemProps;
    exports.formItemValidateStates = formItemValidateStates;
    exports.formProps = formProps;
    exports.formatter = formatter;
    exports.genFileId = genFileId;
    exports.getPositionDataWithUnit = getPositionDataWithUnit;
    exports.iconProps = iconProps;
    exports.imageEmits = imageEmits;
    exports.imageProps = imageProps;
    exports.imageViewerEmits = imageViewerEmits;
    exports.imageViewerProps = imageViewerProps;
    exports.inputEmits = inputEmits;
    exports.inputNumberEmits = inputNumberEmits;
    exports.inputNumberProps = inputNumberProps;
    exports.inputProps = inputProps;
    exports.install = install;
    exports.linkEmits = linkEmits;
    exports.linkProps = linkProps;
    exports.makeInstaller = makeInstaller;
    exports.makeList = makeList;
    exports.menuEmits = menuEmits;
    exports.menuItemEmits = menuItemEmits;
    exports.menuItemGroupProps = menuItemGroupProps;
    exports.menuItemProps = menuItemProps;
    exports.menuProps = menuProps;
    exports.messageConfig = messageConfig;
    exports.messageDefaults = messageDefaults;
    exports.messageEmits = messageEmits;
    exports.messageProps = messageProps;
    exports.messageTypes = messageTypes;
    exports.notificationEmits = notificationEmits;
    exports.notificationProps = notificationProps;
    exports.notificationTypes = notificationTypes;
    exports.overlayEmits = overlayEmits;
    exports.overlayProps = overlayProps;
    exports.pageHeaderEmits = pageHeaderEmits;
    exports.pageHeaderProps = pageHeaderProps;
    exports.paginationEmits = paginationEmits;
    exports.paginationProps = paginationProps;
    exports.parseDate = parseDate;
    exports.popconfirmProps = popconfirmProps;
    exports.popoverEmits = popoverEmits;
    exports.popoverProps = popoverProps;
    exports.popperArrowProps = popperArrowProps;
    exports.popperContentEmits = popperContentEmits;
    exports.popperContentProps = popperContentProps;
    exports.popperCoreConfigProps = popperCoreConfigProps;
    exports.popperProps = popperProps;
    exports.popperTriggerProps = popperTriggerProps;
    exports.progressProps = progressProps;
    exports.provideGlobalConfig = provideGlobalConfig;
    exports.radioButtonProps = radioButtonProps;
    exports.radioEmits = radioEmits;
    exports.radioGroupEmits = radioGroupEmits;
    exports.radioGroupKey = radioGroupKey;
    exports.radioGroupProps = radioGroupProps;
    exports.radioProps = radioProps;
    exports.radioPropsBase = radioPropsBase;
    exports.rangeArr = rangeArr;
    exports.rateEmits = rateEmits;
    exports.rateProps = rateProps;
    exports.renderThumbStyle = renderThumbStyle$1;
    exports.resultProps = resultProps;
    exports.roleTypes = roleTypes;
    exports.rowContextKey = rowContextKey;
    exports.rowProps = rowProps;
    exports.scrollbarContextKey = scrollbarContextKey;
    exports.scrollbarEmits = scrollbarEmits;
    exports.scrollbarProps = scrollbarProps;
    exports.selectGroupKey = selectGroupKey;
    exports.selectKey = selectKey;
    exports.selectV2InjectionKey = selectV2InjectionKey;
    exports.skeletonItemProps = skeletonItemProps;
    exports.skeletonProps = skeletonProps;
    exports.sliderContextKey = sliderContextKey;
    exports.sliderEmits = sliderEmits;
    exports.sliderProps = sliderProps;
    exports.spaceProps = spaceProps;
    exports.stepProps = stepProps;
    exports.stepsEmits = stepsEmits;
    exports.stepsProps = stepsProps;
    exports.subMenuProps = subMenuProps;
    exports.switchEmits = switchEmits;
    exports.switchProps = switchProps;
    exports.tabBarProps = tabBarProps;
    exports.tabNavEmits = tabNavEmits;
    exports.tabNavProps = tabNavProps;
    exports.tabPaneProps = tabPaneProps;
    exports.tableV2Props = tableV2Props;
    exports.tableV2RowProps = tableV2RowProps;
    exports.tabsEmits = tabsEmits;
    exports.tabsProps = tabsProps;
    exports.tabsRootContextKey = tabsRootContextKey;
    exports.tagEmits = tagEmits;
    exports.tagProps = tagProps;
    exports.thumbProps = thumbProps;
    exports.timePickerDefaultProps = timePickerDefaultProps;
    exports.timeUnits = timeUnits;
    exports.timelineItemProps = timelineItemProps;
    exports.tooltipEmits = tooltipEmits;
    exports.tooltipV2ContentKey = tooltipV2ContentKey;
    exports.tooltipV2RootKey = tooltipV2RootKey;
    exports.transferCheckedChangeFn = transferCheckedChangeFn;
    exports.transferEmits = transferEmits;
    exports.transferProps = transferProps;
    exports.translate = translate;
    exports.uploadBaseProps = uploadBaseProps;
    exports.uploadContentProps = uploadContentProps;
    exports.uploadContextKey = uploadContextKey;
    exports.uploadDraggerEmits = uploadDraggerEmits;
    exports.uploadDraggerProps = uploadDraggerProps;
    exports.uploadListEmits = uploadListEmits;
    exports.uploadListProps = uploadListProps;
    exports.uploadListTypes = uploadListTypes;
    exports.uploadProps = uploadProps;
    exports.useAttrs = useAttrs;
    exports.useCascaderConfig = useCascaderConfig;
    exports.useCursor = useCursor;
    exports.useDelayedRender = useDelayedRender;
    exports.useDelayedToggle = useDelayedToggle;
    exports.useDelayedToggleProps = useDelayedToggleProps;
    exports.useDeprecated = useDeprecated;
    exports.useDialog = useDialog;
    exports.useDisabled = useDisabled;
    exports.useDraggable = useDraggable;
    exports.useEscapeKeydown = useEscapeKeydown;
    exports.useFloating = useFloating;
    exports.useFloatingProps = useFloatingProps;
    exports.useFocus = useFocus;
    exports.useFormItem = useFormItem;
    exports.useFormItemInputId = useFormItemInputId;
    exports.useForwardRef = useForwardRef;
    exports.useForwardRefDirective = useForwardRefDirective;
    exports.useGlobalConfig = useGlobalConfig;
    exports.useId = useId;
    exports.useLocale = useLocale;
    exports.useLockscreen = useLockscreen;
    exports.useModal = useModal;
    exports.useModelToggle = useModelToggle;
    exports.useModelToggleEmits = useModelToggleEmits;
    exports.useModelToggleProps = useModelToggleProps;
    exports.useNamespace = useNamespace;
    exports.useOrderedChildren = useOrderedChildren;
    exports.usePopperArrowProps = usePopperArrowProps;
    exports.usePopperContainer = usePopperContainer;
    exports.usePopperContentEmits = usePopperContentEmits;
    exports.usePopperContentProps = usePopperContentProps;
    exports.usePopperCoreConfigProps = usePopperCoreConfigProps;
    exports.usePopperProps = usePopperProps;
    exports.usePopperTriggerProps = usePopperTriggerProps;
    exports.usePreventGlobal = usePreventGlobal;
    exports.useProp = useProp;
    exports.useRestoreActive = useRestoreActive;
    exports.useSameTarget = useSameTarget;
    exports.useSize = useSize;
    exports.useSizeProp = useSizeProp;
    exports.useSpace = useSpace;
    exports.useTeleport = useTeleport;
    exports.useThrottleRender = useThrottleRender;
    exports.useTimeout = useTimeout;
    exports.useTooltipContentProps = useTooltipContentProps;
    exports.useTooltipModelToggle = useTooltipModelToggle;
    exports.useTooltipModelToggleEmits = useTooltipModelToggleEmits;
    exports.useTooltipModelToggleProps = useTooltipModelToggleProps;
    exports.useTooltipProps = useTooltipProps;
    exports.useTooltipTriggerProps = useTooltipTriggerProps;
    exports.useTransitionFallthrough = useTransitionFallthrough;
    exports.useTransitionFallthroughEmits = useTransitionFallthroughEmits;
    exports.useZIndex = useZIndex;
    exports.vLoading = vLoading;
    exports.vRepeatClick = vRepeatClick;
    exports.valueEquals = valueEquals;
    exports.version = version;
    exports.virtualizedGridProps = virtualizedGridProps;
    exports.virtualizedListProps = virtualizedListProps;
    exports.virtualizedProps = virtualizedProps;
    exports.virtualizedScrollbarProps = virtualizedScrollbarProps;
  
    Object.defineProperty(exports, '__esModule', { value: true });
  
  }));