element-plus 1.2.0-beta.4 → 1.2.0-beta.5

package/dist/index.full.js

@@ -1,4 +1,4 @@
-/*! Element Plus v1.2.0-beta.4 */
+/*! Element Plus v1.2.0-beta.5 */
 
 (function (global, factory) {
   typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('vue')) :
@@ -60,7 +60,7 @@
 
   const DEFAULT_EXCLUDE_KEYS = ["class", "style"];
   const LISTENER_PREFIX = /^on[A-Z]/;
-  var useAttrs = (params = {}) => {
+  const useAttrs = (params = {}) => {
     const { excludeListeners = false, excludeKeys = [] } = params;
     const allExcludeKeys = excludeKeys.concat(DEFAULT_EXCLUDE_KEYS);
     const instance = vue.getCurrentInstance();
@@ -73,7 +73,31 @@
     });
   };
 
-  var isServer = typeof window === "undefined";
+  const useFocus = (el) => {
+    return {
+      focus: () => {
+        var _a, _b;
+        (_b = (_a = el.value) == null ? void 0 : _a.focus) == null ? void 0 : _b.call(_a);
+      }
+    };
+  };
+
+  const elFormKey = Symbol("elForm");
+  const elFormItemKey = Symbol("elFormItem");
+
+  const buttonGroupContextKey = Symbol("buttonGroupContextKey");
+
+  const elBreadcrumbKey = Symbol("elBreadcrumbKey");
+
+  const elPaginationKey = Symbol("elPaginationKey");
+
+  const configProviderContextKey = Symbol();
+
+  const radioGroupKey = Symbol("radioGroupKey");
+
+  const tabsRootContextKey = Symbol("tabsRootContextKey");
+
+  const scrollbarContextKey = Symbol("scrollbarContextKey");
 
   /**
    * Make a map and return a function for checking if a key
@@ -85,7 +109,7 @@
   const NOOP = () => { };
   const hasOwnProperty$c = Object.prototype.hasOwnProperty;
   const hasOwn = (val, key) => hasOwnProperty$c.call(val, key);
-  const isArray$6 = Array.isArray;
+  const isArray$9 = Array.isArray;
   const isFunction$3 = (val) => typeof val === 'function';
   const isString$1 = (val) => typeof val === 'string';
   const isObject$a = (val) => val !== null && typeof val === 'object';
@@ -117,6 +141,44 @@
    */
   const capitalize = cacheStringFunction((str) => str.charAt(0).toUpperCase() + str.slice(1));
 
+  const wrapperKey = Symbol();
+  const propKey = Symbol();
+  function buildProp(option, key) {
+    if (!isObject$a(option) || !!option[propKey])
+      return option;
+    const { values, required, default: defaultValue, type, validator } = option;
+    const _validator = values || validator ? (val) => {
+      let valid = false;
+      let allowedValues = [];
+      if (values) {
+        allowedValues = [...values, 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;
+    return {
+      type: typeof type === "object" && Object.getOwnPropertySymbols(type).includes(wrapperKey) ? type[wrapperKey] : type,
+      required: !!required,
+      default: defaultValue,
+      validator: _validator,
+      [propKey]: true
+    };
+  }
+  const buildProps = (props) => fromPairs_1(Object.entries(props).map(([key, option]) => [
+    key,
+    buildProp(option, key)
+  ]));
+  const definePropType = (val) => ({ [wrapperKey]: val });
+  const keyOf = (arr) => Object.keys(arr);
+  const mutable = (val) => val;
+  const componentSize = ["large", "medium", "small", "mini"];
+
   /**
    * Removes all key-value entries from the list cache.
    *
@@ -413,11 +475,11 @@
   var root$8 = _root;
 
   /** Built-in value references. */
-  var Symbol$6 = root$8.Symbol;
+  var Symbol$7 = root$8.Symbol;
 
-  var _Symbol = Symbol$6;
+  var _Symbol = Symbol$7;
 
-  var Symbol$5 = _Symbol;
+  var Symbol$6 = _Symbol;
 
   /** Used for built-in method references. */
   var objectProto$e = Object.prototype;
@@ -433,7 +495,7 @@
   var nativeObjectToString$1 = objectProto$e.toString;
 
   /** Built-in value references. */
-  var symToStringTag$1 = Symbol$5 ? Symbol$5.toStringTag : undefined;
+  var symToStringTag$1 = Symbol$6 ? Symbol$6.toStringTag : undefined;
 
   /**
    * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.
@@ -488,7 +550,7 @@
 
   var _objectToString = objectToString$1;
 
-  var Symbol$4 = _Symbol,
+  var Symbol$5 = _Symbol,
       getRawTag = _getRawTag,
       objectToString = _objectToString;
 
@@ -497,7 +559,7 @@
       undefinedTag = '[object Undefined]';
 
   /** Built-in value references. */
-  var symToStringTag = Symbol$4 ? Symbol$4.toStringTag : undefined;
+  var symToStringTag = Symbol$5 ? Symbol$5.toStringTag : undefined;
 
   /**
    * The base implementation of `getTag` without fallbacks for buggy environments.
@@ -1354,7 +1416,7 @@
 
   var _setToArray = setToArray$3;
 
-  var Symbol$3 = _Symbol,
+  var Symbol$4 = _Symbol,
       Uint8Array$1 = _Uint8Array,
       eq$1 = eq_1,
       equalArrays$1 = _equalArrays,
@@ -1380,8 +1442,8 @@
       dataViewTag$4 = '[object DataView]';
 
   /** Used to convert symbols to primitives and strings. */
-  var symbolProto$1 = Symbol$3 ? Symbol$3.prototype : undefined,
-      symbolValueOf$1 = symbolProto$1 ? symbolProto$1.valueOf : undefined;
+  var symbolProto$2 = Symbol$4 ? Symbol$4.prototype : undefined,
+      symbolValueOf$1 = symbolProto$2 ? symbolProto$2.valueOf : undefined;
 
   /**
    * A specialized version of `baseIsEqualDeep` for comparing objects of
@@ -1513,12 +1575,12 @@
    * // => false
    */
 
-  var isArray$5 = Array.isArray;
+  var isArray$8 = Array.isArray;
 
-  var isArray_1 = isArray$5;
+  var isArray_1 = isArray$8;
 
   var arrayPush$2 = _arrayPush,
-      isArray$4 = isArray_1;
+      isArray$7 = isArray_1;
 
   /**
    * The base implementation of `getAllKeys` and `getAllKeysIn` which uses
@@ -1533,7 +1595,7 @@
    */
   function baseGetAllKeys$2(object, keysFunc, symbolsFunc) {
     var result = keysFunc(object);
-    return isArray$4(object) ? result : arrayPush$2(result, symbolsFunc(object));
+    return isArray$7(object) ? result : arrayPush$2(result, symbolsFunc(object));
   }
 
   var _baseGetAllKeys = baseGetAllKeys$2;
@@ -1999,7 +2061,7 @@
 
   var baseTimes = _baseTimes,
       isArguments$1 = isArguments_1,
-      isArray$3 = isArray_1,
+      isArray$6 = isArray_1,
       isBuffer$2 = isBuffer$3.exports,
       isIndex = _isIndex,
       isTypedArray$1 = isTypedArray_1;
@@ -2019,7 +2081,7 @@
    * @returns {Array} Returns the array of property names.
    */
   function arrayLikeKeys$2(value, inherited) {
-    var isArr = isArray$3(value),
+    var isArr = isArray$6(value),
         isArg = !isArr && isArguments$1(value),
         isBuff = !isArr && !isArg && isBuffer$2(value),
         isType = !isArr && !isArg && !isBuff && isTypedArray$1(value),
@@ -2398,7 +2460,7 @@
       equalByTag = _equalByTag,
       equalObjects = _equalObjects,
       getTag$3 = _getTag,
-      isArray$2 = isArray_1,
+      isArray$5 = isArray_1,
       isBuffer$1 = isBuffer$3.exports,
       isTypedArray = isTypedArray_1;
 
@@ -2431,8 +2493,8 @@
    * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.
    */
   function baseIsEqualDeep$1(object, other, bitmask, customizer, equalFunc, stack) {
-    var objIsArr = isArray$2(object),
-        othIsArr = isArray$2(other),
+    var objIsArr = isArray$5(object),
+        othIsArr = isArray$5(other),
         objTag = objIsArr ? arrayTag$1 : getTag$3(object),
         othTag = othIsArr ? arrayTag$1 : getTag$3(other);
 
@@ -2506,6 +2568,8 @@
 
   var _baseIsEqual = baseIsEqual$1;
 
+  var isServer = typeof window === "undefined";
+
   const SCOPE$1 = "Util";
   const getValueByPath = (obj, paths = "") => {
     let ret = obj;
@@ -2597,7 +2661,7 @@
     return {};
   }
   function isEmpty(val) {
-    if (!val && val !== 0 || isArray$6(val) && !val.length || isObject$a(val) && !Object.keys(val).length)
+    if (!val && val !== 0 || isArray$9(val) && !val.length || isObject$a(val) && !Object.keys(val).length)
       return true;
     return false;
   }
@@ -2624,6 +2688,607 @@
     };
   };
 
+  const sizes = ["", ...componentSize];
+  const useFormItemProps = buildProps({
+    size: {
+      type: String,
+      values: sizes,
+      default: ""
+    },
+    disabled: Boolean
+  });
+  const useFormItem = ({ size, disabled } = {}) => {
+    var _a;
+    const vm = vue.getCurrentInstance();
+    const $ELEMENT = useGlobalConfig$1();
+    const props = (_a = vm.proxy) == null ? void 0 : _a.$props;
+    const form = vue.inject(elFormKey, void 0);
+    const formItem = vue.inject(elFormItemKey, void 0);
+    return {
+      size: vue.computed(() => {
+        return props.size || vue.unref(size) || (formItem == null ? void 0 : formItem.size) || (form == null ? void 0 : form.size) || $ELEMENT.size || "";
+      }),
+      disabled: vue.computed(() => {
+        return props.disabled === true || vue.unref(disabled) || (form == null ? void 0 : form.disabled) || false;
+      }),
+      form,
+      formItem
+    };
+  };
+
+  const defaultConfig = {
+    button: {
+      autoInsertSpace: false
+    }
+  };
+  const useGlobalConfig = () => vue.inject(configProviderContextKey, defaultConfig);
+
+  var baseGetTag = _baseGetTag,
+      isObjectLike$3 = isObjectLike_1;
+
+  /** `Object#toString` result references. */
+  var symbolTag$2 = '[object Symbol]';
+
+  /**
+   * Checks if `value` is classified as a `Symbol` primitive or object.
+   *
+   * @static
+   * @memberOf _
+   * @since 4.0.0
+   * @category Lang
+   * @param {*} value The value to check.
+   * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.
+   * @example
+   *
+   * _.isSymbol(Symbol.iterator);
+   * // => true
+   *
+   * _.isSymbol('abc');
+   * // => false
+   */
+  function isSymbol$4(value) {
+    return typeof value == 'symbol' ||
+      (isObjectLike$3(value) && baseGetTag(value) == symbolTag$2);
+  }
+
+  var isSymbol_1 = isSymbol$4;
+
+  var isArray$4 = isArray_1,
+      isSymbol$3 = isSymbol_1;
+
+  /** Used to match property names within property paths. */
+  var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/,
+      reIsPlainProp = /^\w*$/;
+
+  /**
+   * Checks if `value` is a property name and not a property path.
+   *
+   * @private
+   * @param {*} value The value to check.
+   * @param {Object} [object] The object to query keys on.
+   * @returns {boolean} Returns `true` if `value` is a property name, else `false`.
+   */
+  function isKey$1(value, object) {
+    if (isArray$4(value)) {
+      return false;
+    }
+    var type = typeof value;
+    if (type == 'number' || type == 'symbol' || type == 'boolean' ||
+        value == null || isSymbol$3(value)) {
+      return true;
+    }
+    return reIsPlainProp.test(value) || !reIsDeepProp.test(value) ||
+      (object != null && value in Object(object));
+  }
+
+  var _isKey = isKey$1;
+
+  var MapCache = _MapCache;
+
+  /** Error message constants. */
+  var FUNC_ERROR_TEXT$2 = 'Expected a function';
+
+  /**
+   * Creates a function that memoizes the result of `func`. If `resolver` is
+   * provided, it determines the cache key for storing the result based on the
+   * arguments provided to the memoized function. By default, the first argument
+   * provided to the memoized function is used as the map cache key. The `func`
+   * is invoked with the `this` binding of the memoized function.
+   *
+   * **Note:** The cache is exposed as the `cache` property on the memoized
+   * function. Its creation may be customized by replacing the `_.memoize.Cache`
+   * constructor with one whose instances implement the
+   * [`Map`](http://ecma-international.org/ecma-262/7.0/#sec-properties-of-the-map-prototype-object)
+   * method interface of `clear`, `delete`, `get`, `has`, and `set`.
+   *
+   * @static
+   * @memberOf _
+   * @since 0.1.0
+   * @category Function
+   * @param {Function} func The function to have its output memoized.
+   * @param {Function} [resolver] The function to resolve the cache key.
+   * @returns {Function} Returns the new memoized function.
+   * @example
+   *
+   * var object = { 'a': 1, 'b': 2 };
+   * var other = { 'c': 3, 'd': 4 };
+   *
+   * var values = _.memoize(_.values);
+   * values(object);
+   * // => [1, 2]
+   *
+   * values(other);
+   * // => [3, 4]
+   *
+   * object.a = 2;
+   * values(object);
+   * // => [1, 2]
+   *
+   * // Modify the result cache.
+   * values.cache.set(object, ['a', 'b']);
+   * values(object);
+   * // => ['a', 'b']
+   *
+   * // Replace `_.memoize.Cache`.
+   * _.memoize.Cache = WeakMap;
+   */
+  function memoize$1(func, resolver) {
+    if (typeof func != 'function' || (resolver != null && typeof resolver != 'function')) {
+      throw new TypeError(FUNC_ERROR_TEXT$2);
+    }
+    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$1.Cache || MapCache);
+    return memoized;
+  }
+
+  // Expose `MapCache`.
+  memoize$1.Cache = MapCache;
+
+  var memoize_1 = memoize$1;
+
+  var memoize = memoize_1;
+
+  /** Used as the maximum memoize cache size. */
+  var MAX_MEMOIZE_SIZE = 500;
+
+  /**
+   * A specialized version of `_.memoize` which clears the memoized function's
+   * cache when it exceeds `MAX_MEMOIZE_SIZE`.
+   *
+   * @private
+   * @param {Function} func The function to have its output memoized.
+   * @returns {Function} Returns the new memoized function.
+   */
+  function memoizeCapped$1(func) {
+    var result = memoize(func, function(key) {
+      if (cache.size === MAX_MEMOIZE_SIZE) {
+        cache.clear();
+      }
+      return key;
+    });
+
+    var cache = result.cache;
+    return result;
+  }
+
+  var _memoizeCapped = memoizeCapped$1;
+
+  var memoizeCapped = _memoizeCapped;
+
+  /** Used to match property names within property paths. */
+  var rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g;
+
+  /** Used to match backslashes in property paths. */
+  var reEscapeChar = /\\(\\)?/g;
+
+  /**
+   * Converts `string` to a property path array.
+   *
+   * @private
+   * @param {string} string The string to convert.
+   * @returns {Array} Returns the property path array.
+   */
+  var stringToPath$1 = 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;
+  });
+
+  var _stringToPath = stringToPath$1;
+
+  /**
+   * A specialized version of `_.map` for arrays without support for iteratee
+   * shorthands.
+   *
+   * @private
+   * @param {Array} [array] The array to iterate over.
+   * @param {Function} iteratee The function invoked per iteration.
+   * @returns {Array} Returns the new mapped array.
+   */
+
+  function arrayMap$1(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 _arrayMap = arrayMap$1;
+
+  var Symbol$3 = _Symbol,
+      arrayMap = _arrayMap,
+      isArray$3 = isArray_1,
+      isSymbol$2 = isSymbol_1;
+
+  /** Used as references for various `Number` constants. */
+  var INFINITY$2 = 1 / 0;
+
+  /** Used to convert symbols to primitives and strings. */
+  var symbolProto$1 = Symbol$3 ? Symbol$3.prototype : undefined,
+      symbolToString = symbolProto$1 ? symbolProto$1.toString : undefined;
+
+  /**
+   * The base implementation of `_.toString` which doesn't convert nullish
+   * values to empty strings.
+   *
+   * @private
+   * @param {*} value The value to process.
+   * @returns {string} Returns the string.
+   */
+  function baseToString$1(value) {
+    // Exit early for strings to avoid a performance hit in some environments.
+    if (typeof value == 'string') {
+      return value;
+    }
+    if (isArray$3(value)) {
+      // Recursively convert values (susceptible to call stack limits).
+      return arrayMap(value, baseToString$1) + '';
+    }
+    if (isSymbol$2(value)) {
+      return symbolToString ? symbolToString.call(value) : '';
+    }
+    var result = (value + '');
+    return (result == '0' && (1 / value) == -INFINITY$2) ? '-0' : result;
+  }
+
+  var _baseToString = baseToString$1;
+
+  var baseToString = _baseToString;
+
+  /**
+   * Converts `value` to a string. An empty string is returned for `null`
+   * and `undefined` values. The sign of `-0` is preserved.
+   *
+   * @static
+   * @memberOf _
+   * @since 4.0.0
+   * @category Lang
+   * @param {*} value The value to convert.
+   * @returns {string} Returns the converted string.
+   * @example
+   *
+   * _.toString(null);
+   * // => ''
+   *
+   * _.toString(-0);
+   * // => '-0'
+   *
+   * _.toString([1, 2, 3]);
+   * // => '1,2,3'
+   */
+  function toString$1(value) {
+    return value == null ? '' : baseToString(value);
+  }
+
+  var toString_1 = toString$1;
+
+  var isArray$2 = isArray_1,
+      isKey = _isKey,
+      stringToPath = _stringToPath,
+      toString = toString_1;
+
+  /**
+   * Casts `value` to a path array if it's not one.
+   *
+   * @private
+   * @param {*} value The value to inspect.
+   * @param {Object} [object] The object to query keys on.
+   * @returns {Array} Returns the cast property path array.
+   */
+  function castPath$1(value, object) {
+    if (isArray$2(value)) {
+      return value;
+    }
+    return isKey(value, object) ? [value] : stringToPath(toString(value));
+  }
+
+  var _castPath = castPath$1;
+
+  var isSymbol$1 = isSymbol_1;
+
+  /** Used as references for various `Number` constants. */
+  var INFINITY$1 = 1 / 0;
+
+  /**
+   * Converts `value` to a string key if it's not a string or symbol.
+   *
+   * @private
+   * @param {*} value The value to inspect.
+   * @returns {string|symbol} Returns the key.
+   */
+  function toKey$1(value) {
+    if (typeof value == 'string' || isSymbol$1(value)) {
+      return value;
+    }
+    var result = (value + '');
+    return (result == '0' && (1 / value) == -INFINITY$1) ? '-0' : result;
+  }
+
+  var _toKey = toKey$1;
+
+  var castPath = _castPath,
+      toKey = _toKey;
+
+  /**
+   * The base implementation of `_.get` without support for default values.
+   *
+   * @private
+   * @param {Object} object The object to query.
+   * @param {Array|string} path The path of the property to get.
+   * @returns {*} Returns the resolved value.
+   */
+  function baseGet$1(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 : undefined;
+  }
+
+  var _baseGet = baseGet$1;
+
+  var baseGet = _baseGet;
+
+  /**
+   * Gets the value at `path` of `object`. If the resolved value is
+   * `undefined`, the `defaultValue` is returned in its place.
+   *
+   * @static
+   * @memberOf _
+   * @since 3.7.0
+   * @category Object
+   * @param {Object} object The object to query.
+   * @param {Array|string} path The path of the property to get.
+   * @param {*} [defaultValue] The value returned for `undefined` resolved values.
+   * @returns {*} Returns the resolved value.
+   * @example
+   *
+   * var object = { 'a': [{ 'b': { 'c': 3 } }] };
+   *
+   * _.get(object, 'a[0].b.c');
+   * // => 3
+   *
+   * _.get(object, ['a', '0', 'b', 'c']);
+   * // => 3
+   *
+   * _.get(object, 'a.b.c', 'default');
+   * // => 'default'
+   */
+  function get(object, path, defaultValue) {
+    var result = object == null ? undefined : baseGet(object, path);
+    return result === undefined ? defaultValue : result;
+  }
+
+  var get_1 = get;
+
+  var English = {
+    name: "en",
+    el: {
+      colorpicker: {
+        confirm: "OK",
+        clear: "Clear"
+      },
+      datepicker: {
+        now: "Now",
+        today: "Today",
+        cancel: "Cancel",
+        clear: "Clear",
+        confirm: "OK",
+        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"
+        },
+        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"
+        }
+      },
+      select: {
+        loading: "Loading",
+        noMatch: "No matching data",
+        noData: "No data",
+        placeholder: "Select"
+      },
+      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"
+      },
+      messagebox: {
+        title: "Message",
+        confirm: "OK",
+        cancel: "Cancel",
+        error: "Illegal input"
+      },
+      upload: {
+        deleteTip: "press delete to remove",
+        delete: "Delete",
+        preview: "Preview",
+        continue: "Continue"
+      },
+      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 useLocaleProps = buildProps({
+    locale: {
+      type: definePropType(Object)
+    }
+  });
+  const localeContextKey = Symbol("localeContextKey");
+  let localeContextCache;
+  const provideLocale = () => {
+    const vm = vue.getCurrentInstance();
+    const props = vm.props;
+    const locale = vue.computed(() => props.locale || English);
+    const lang = vue.computed(() => locale.value.name);
+    const t = buildTranslator(locale);
+    const provides = {
+      locale,
+      lang,
+      t
+    };
+    localeContextCache = provides;
+    vue.provide(localeContextKey, provides);
+  };
+  const buildTranslator = (locale) => (path) => translate(path, vue.unref(locale));
+  const translate = (path, locale) => get_1(locale, path, "");
+  const localeProviderMaker = (locale = English) => {
+    const lang = vue.ref(locale.name);
+    const localeRef = vue.ref(locale);
+    return {
+      lang,
+      locale: localeRef,
+      t: buildTranslator(localeRef)
+    };
+  };
+  const useLocale = () => {
+    return vue.inject(localeContextKey, localeContextCache || localeProviderMaker(English));
+  };
+
+  let scrollBarWidth;
+  function scrollbarWidth() {
+    var _a;
+    if (isServer)
+      return 0;
+    if (scrollBarWidth !== void 0)
+      return scrollBarWidth;
+    const outer = document.createElement("div");
+    outer.className = "el-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;
+  }
+
   const trimArr = function(s) {
     return (s || "").split(" ").filter((item) => !!item.trim());
   };
@@ -2777,56 +3442,14 @@
     };
   };
 
-  var index = (el, events) => {
-    vue.watch(el, (val) => {
-      if (val) {
-        events.forEach(({ name, handler }) => {
-          on(el.value, name, handler);
-        });
-      } else {
-        events.forEach(({ name, handler }) => {
-          off(el.value, name, handler);
-        });
-      }
-    });
-  };
-
-  let scrollBarWidth;
-  function scrollbarWidth() {
-    var _a;
-    if (isServer)
-      return 0;
-    if (scrollBarWidth !== void 0)
-      return scrollBarWidth;
-    const outer = document.createElement("div");
-    outer.className = "el-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;
-  }
-
-  var useLockScreen = (trigger) => {
+  const useLockscreen = (trigger) => {
     if (!vue.isRef(trigger)) {
-      throwError("[useLockScreen]", "You need to pass a ref param to this function");
+      throwError("[useLockscreen]", "You need to pass a ref param to this function");
     }
     let scrollBarWidth = 0;
     let withoutHiddenClass = false;
     let bodyPaddingRight = "0";
     let computedBodyPaddingRight = 0;
-    vue.onUnmounted(() => {
-      cleanup();
-    });
     const cleanup = () => {
       removeClass(document.body, "el-popup-parent--hidden");
       if (withoutHiddenClass) {
@@ -2834,41 +3457,267 @@
       }
     };
     vue.watch(trigger, (val) => {
-      if (val) {
-        withoutHiddenClass = !hasClass(document.body, "el-popup-parent--hidden");
-        if (withoutHiddenClass) {
-          bodyPaddingRight = document.body.style.paddingRight;
-          computedBodyPaddingRight = parseInt(getStyle(document.body, "paddingRight"), 10);
-        }
-        scrollBarWidth = scrollbarWidth();
-        const bodyHasOverflow = document.documentElement.clientHeight < document.body.scrollHeight;
-        const bodyOverflowY = getStyle(document.body, "overflowY");
-        if (scrollBarWidth > 0 && (bodyHasOverflow || bodyOverflowY === "scroll") && withoutHiddenClass) {
-          document.body.style.paddingRight = `${computedBodyPaddingRight + scrollBarWidth}px`;
-        }
-        addClass(document.body, "el-popup-parent--hidden");
-      } else {
+      if (!val) {
         cleanup();
+        return;
       }
+      withoutHiddenClass = !hasClass(document.body, "el-popup-parent--hidden");
+      if (withoutHiddenClass) {
+        bodyPaddingRight = document.body.style.paddingRight;
+        computedBodyPaddingRight = parseInt(getStyle(document.body, "paddingRight"), 10);
+      }
+      scrollBarWidth = scrollbarWidth();
+      const bodyHasOverflow = document.documentElement.clientHeight < document.body.scrollHeight;
+      const bodyOverflowY = getStyle(document.body, "overflowY");
+      if (scrollBarWidth > 0 && (bodyHasOverflow || bodyOverflowY === "scroll") && withoutHiddenClass) {
+        document.body.style.paddingRight = `${computedBodyPaddingRight + scrollBarWidth}px`;
+      }
+      addClass(document.body, "el-popup-parent--hidden");
     });
+    vue.onScopeDispose(() => cleanup());
   };
 
-  var 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();
-        }
+  function tryOnScopeDispose(fn) {
+    if (vue.getCurrentScope()) {
+      vue.onScopeDispose(fn);
+      return true;
+    }
+    return false;
+  }
+
+  const isClient = typeof window !== "undefined";
+  const isString = (val) => typeof val === "string";
+  const noop$2 = () => {
+  };
+
+  function createFilterWrapper(filter, fn) {
+    function wrapper(...args) {
+      filter(() => fn.apply(this, args), { fn, thisArg: this, args });
+    }
+    return wrapper;
+  }
+  function throttleFilter(ms, trailing = true, leading = true) {
+    let lastExec = 0;
+    let timer;
+    let preventLeading = !leading;
+    const clear = () => {
+      if (timer) {
+        clearTimeout(timer);
+        timer = void 0;
+      }
+    };
+    const filter = (invoke) => {
+      const duration = vue.unref(ms);
+      const elapsed = Date.now() - lastExec;
+      clear();
+      if (duration <= 0) {
+        lastExec = Date.now();
+        return invoke();
       }
+      if (elapsed > duration) {
+        lastExec = Date.now();
+        if (preventLeading)
+          preventLeading = false;
+        else
+          invoke();
+      } else if (trailing) {
+        timer = setTimeout(() => {
+          lastExec = Date.now();
+          if (!leading)
+            preventLeading = true;
+          clear();
+          invoke();
+        }, duration);
+      }
+      if (!leading && !timer)
+        timer = setTimeout(() => preventLeading = true, duration);
+    };
+    return filter;
+  }
+
+  function eagerComputed(fn) {
+    const result = vue.shallowRef();
+    vue.watchSyncEffect(() => {
+      result.value = fn();
     });
+    return vue.readonly(result);
+  }
+
+  function useThrottleFn(fn, ms = 200, trailing = true, leading = true) {
+    return createFilterWrapper(throttleFilter(ms, trailing, leading), 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);
+      }, vue.unref(interval));
+    }
+    if (immediate) {
+      isPending.value = true;
+      if (isClient)
+        start();
+    }
+    tryOnScopeDispose(stop);
+    return {
+      isPending,
+      start,
+      stop
+    };
+  }
+
+  function unrefElement(elRef) {
+    var _a;
+    const plain = vue.unref(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(args[0])) {
+      [event, listener, options] = args;
+      target = defaultWindow;
+    } else {
+      [target, event, listener, options] = args;
+    }
+    if (!target)
+      return noop$2;
+    let cleanup = noop$2;
+    const stopWatch = vue.watch(() => vue.unref(target), (el) => {
+      cleanup();
+      if (!el)
+        return;
+      el.addEventListener(event, listener, options);
+      cleanup = () => {
+        el.removeEventListener(event, listener, options);
+        cleanup = noop$2;
+      };
+    }, { immediate: true, flush: "post" });
+    const stop = () => {
+      stopWatch();
+      cleanup();
+    };
+    tryOnScopeDispose(stop);
+    return stop;
+  }
+
+  function useCssVar(prop, target, { window = defaultWindow } = {}) {
+    const variable = vue.ref("");
+    const elRef = vue.computed(() => {
+      var _a;
+      return unrefElement(target) || ((_a = window == null ? void 0 : window.document) == null ? void 0 : _a.documentElement);
+    });
+    vue.watch(elRef, (el) => {
+      if (el && window)
+        variable.value = window.getComputedStyle(el).getPropertyValue(prop);
+    }, { immediate: true });
+    vue.watch(variable, (val) => {
+      var _a;
+      if ((_a = elRef.value) == null ? void 0 : _a.style)
+        elRef.value.style.setProperty(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$9 = Object.getOwnPropertySymbols;
+  var __hasOwnProp$9 = Object.prototype.hasOwnProperty;
+  var __propIsEnum$9 = Object.prototype.propertyIsEnumerable;
+  var __objRest$2 = (source, exclude) => {
+    var target = {};
+    for (var prop in source)
+      if (__hasOwnProp$9.call(source, prop) && exclude.indexOf(prop) < 0)
+        target[prop] = source[prop];
+    if (source != null && __getOwnPropSymbols$9)
+      for (var prop of __getOwnPropSymbols$9(source)) {
+        if (exclude.indexOf(prop) < 0 && __propIsEnum$9.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 = window && "ResizeObserver" in window;
+    const cleanup = () => {
+      if (observer) {
+        observer.disconnect();
+        observer = void 0;
+      }
+    };
+    const stopWatch = vue.watch(() => unrefElement(target), (el) => {
+      cleanup();
+      if (isSupported && window && el) {
+        observer = new window.ResizeObserver(callback);
+        observer.observe(el, observerOptions);
+      }
+    }, { immediate: true, flush: "post" });
+    const stop = () => {
+      cleanup();
+      stopWatch();
+    };
+    tryOnScopeDispose(stop);
+    return {
+      isSupported,
+      stop
+    };
+  }
+
+  var SwipeDirection;
+  (function(SwipeDirection2) {
+    SwipeDirection2["UP"] = "UP";
+    SwipeDirection2["RIGHT"] = "RIGHT";
+    SwipeDirection2["DOWN"] = "DOWN";
+    SwipeDirection2["LEFT"] = "LEFT";
+    SwipeDirection2["NONE"] = "NONE";
+  })(SwipeDirection || (SwipeDirection = {}));
+
+  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;
+  }
 
   const EVENT_CODE = {
     tab: "Tab",
@@ -2954,8 +3803,8 @@
       topModal.handleClose();
     }
   };
-  var useModal = (instance, visibleRef) => {
-    vue.watch(() => visibleRef.value, (val) => {
+  const useModal = (instance, visibleRef) => {
+    vue.watch(visibleRef, (val) => {
       if (val) {
         modalStack.push(instance);
       } else {
@@ -2963,150 +3812,20 @@
       }
     });
   };
-  if (!isServer) {
-    on(document, "keydown", closeModal);
-  }
-
-  const useMigrating = function() {
-    vue.onMounted(() => {
-      vue.getCurrentInstance();
-      return;
-    });
-    const getMigratingConfig = function() {
-      return {
-        props: {},
-        events: {}
-      };
-    };
-    return {
-      getMigratingConfig
-    };
-  };
-
-  var useFocus = (el) => {
-    return {
-      focus: () => {
-        var _a, _b;
-        (_b = (_a = el.value) == null ? void 0 : _a.focus) == null ? void 0 : _b.call(_a);
-      }
-    };
-  };
-
-  function 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;
-  }
-
-  var usePreventGlobal = (indicator, evt, cb) => {
-    const prevent = (e) => {
-      if (cb(e)) {
-        e.stopImmediatePropagation();
-      }
-    };
-    vue.watch(() => indicator.value, (val) => {
-      if (val) {
-        on(document, evt, prevent, true);
-      } else {
-        off(document, evt, prevent, true);
-      }
-    }, { immediate: true });
-  };
-
-  let target = isServer ? void 0 : document.body;
-  function createGlobalNode(id) {
-    const el = document.createElement("div");
-    if (id !== void 0) {
-      el.id = id;
-    }
-    target.appendChild(el);
-    return el;
-  }
-  function removeGlobalNode(el) {
-    el.remove();
-  }
-
-  var useTeleport = (contentRenderer, appendToBody) => {
-    const isTeleportVisible = vue.ref(false);
-    if (isServer) {
-      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
-    };
-  };
-
-  function useTimeout() {
-    let timeoutHandle;
-    vue.onBeforeUnmount(() => {
-      clearTimeout(timeoutHandle);
-    });
-    return {
-      registerTimeout: (fn, delay) => {
-        clearTimeout(timeoutHandle);
-        timeoutHandle = setTimeout(fn, delay);
-      },
-      cancelTimeout: () => {
-        clearTimeout(timeoutHandle);
-      }
-    };
-  }
+  if (isClient)
+    useEventListener(document, "keydown", closeModal);
 
   const UPDATE_MODEL_EVENT = "update:modelValue";
   const CHANGE_EVENT = "change";
   const INPUT_EVENT = "input";
 
-  const useModelToggleProps = {
+  const useModelToggleProps = buildProps({
     modelValue: {
-      type: Boolean,
+      type: definePropType(Boolean),
       default: null
     },
     "onUpdate:modelValue": Function
-  };
+  });
   const useModelToggleEmits = [UPDATE_MODEL_EVENT];
   const useModelToggle = ({
     indicator,
@@ -3115,7 +3834,9 @@
     onShow,
     onHide
   }) => {
-    const { appContext, props, proxy, emit } = vue.getCurrentInstance();
+    const instance = vue.getCurrentInstance();
+    const props = instance.props;
+    const { emit } = instance;
     const hasUpdateHandler = vue.computed(() => isFunction$3(props["onUpdate:modelValue"]));
     const isModelBindingAbsent = vue.computed(() => props.modelValue === null);
     const doShow = () => {
@@ -3181,9 +3902,9 @@
       }
     };
     vue.watch(() => props.modelValue, onChange);
-    if (shouldHideWhenRouteChanges && appContext.config.globalProperties.$route !== void 0) {
+    if (shouldHideWhenRouteChanges && instance.appContext.config.globalProperties.$route !== void 0) {
       vue.watch(() => ({
-        ...proxy.$route
+        ...instance.proxy.$route
       }), () => {
         if (shouldHideWhenRouteChanges.value && indicator.value) {
           hide();
@@ -5378,6 +6099,69 @@
     });
   }
 
+  let target = isServer ? void 0 : document.body;
+  function createGlobalNode(id) {
+    const el = document.createElement("div");
+    if (id !== void 0) {
+      el.id = id;
+    }
+    target.appendChild(el);
+    return el;
+  }
+  function removeGlobalNode(el) {
+    el.remove();
+  }
+
+  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
+    };
+  };
+
+  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";
@@ -5518,7 +6302,7 @@
       return events;
     };
     return vue.computed(() => {
-      if (isArray$6(props.trigger)) {
+      if (isArray$9(props.trigger)) {
         return Object.values(props.trigger).reduce((pre, t) => {
           return {
             ...pre,
@@ -5768,323 +6552,38 @@
     };
   };
 
-  const VAR_PREFIX = "--el-";
-  const setVars = (target, val) => {
-    Object.keys(val).forEach((key) => {
-      if (key.startsWith(VAR_PREFIX)) {
-        target == null ? void 0 : target.style.setProperty(key, val[key]);
+  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 {
-        target == null ? void 0 : target.style.setProperty(VAR_PREFIX + key, val[key]);
+        stop == null ? void 0 : stop();
       }
-    });
-  };
-  const themeVarsKey = "themeVars";
-  function useCssVar$1(vars, target) {
-    let stopWatchCssVar = null;
-    const elRef = vue.computed(() => {
-      var _a;
-      return vue.unref(target) || ((_a = window == null ? void 0 : window.document) == null ? void 0 : _a.documentElement);
-    });
-    const themeVars = useThemeVars();
-    const customVars = { ...themeVars, ...vue.unref(vars) };
-    vue.provide(themeVarsKey, vue.ref(customVars));
-    vue.onMounted(() => {
-      vue.isRef(vars) ? stopWatchCssVar = vue.watch(vars, (val) => {
-        setVars(elRef.value, {
-          ...vue.unref(themeVars),
-          ...val
-        });
-      }, {
-        immediate: true,
-        deep: true
-      }) : setVars(elRef.value, {
-        ...vue.unref(themeVars),
-        ...vars
-      });
-    });
-    vue.onUnmounted(() => stopWatchCssVar && stopWatchCssVar());
-  }
-  const useThemeVars = () => {
-    const themeVars = vue.inject(themeVarsKey, {});
-    return themeVars;
+    }, { immediate: true });
   };
 
-  var English = {
-    name: "en",
-    el: {
-      colorpicker: {
-        confirm: "OK",
-        clear: "Clear"
-      },
-      datepicker: {
-        now: "Now",
-        today: "Today",
-        cancel: "Cancel",
-        clear: "Clear",
-        confirm: "OK",
-        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"
-        },
-        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"
+  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();
         }
-      },
-      select: {
-        loading: "Loading",
-        noMatch: "No matching data",
-        noData: "No data",
-        placeholder: "Select"
-      },
-      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"
-      },
-      messagebox: {
-        title: "Message",
-        confirm: "OK",
-        cancel: "Cancel",
-        error: "Illegal input"
-      },
-      upload: {
-        deleteTip: "press delete to remove",
-        delete: "Delete",
-        preview: "Preview",
-        continue: "Continue"
-      },
-      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 wrapperKey = Symbol();
-  const propKey = Symbol();
-  function buildProp(option, key) {
-    if (!isObject$a(option) || !!option[propKey])
-      return option;
-    const { values, required, default: defaultValue, type, validator } = option;
-    const _validator = values || validator ? (val) => {
-      let valid = false;
-      let allowedValues = [];
-      if (values) {
-        allowedValues = [...values, 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;
-    return {
-      type: typeof type === "object" && Object.getOwnPropertySymbols(type).includes(wrapperKey) ? type[wrapperKey] : type,
-      required: !!required,
-      default: defaultValue,
-      validator: _validator,
-      [propKey]: true
-    };
-  }
-  const buildProps = (props) => fromPairs_1(Object.entries(props).map(([key, option]) => [
-    key,
-    buildProp(option, key)
-  ]));
-  const definePropType = (val) => ({ [wrapperKey]: val });
-  const keyOf = (arr) => Object.keys(arr);
-  const mutable = (val) => val;
-  const componentSize = ["large", "medium", "small", "mini"];
-
-  const useLocaleProps = {
-    locale: buildProp({
-      type: definePropType(Object)
-    })
-  };
-  const LocaleInjectionKey = "ElLocaleInjection";
-  let localeObjCache;
-  function translate(path, option, current) {
-    const paths = path.split(".");
-    let value;
-    for (let i = 0, j = paths.length; i < j; i++) {
-      const property = paths[i];
-      value = current[property];
-      if (i === j - 1)
-        return template(value, option);
-      if (!value)
-        return "";
-      current = value;
-    }
-  }
-  const useLocale = () => {
-    const vm = vue.getCurrentInstance();
-    const props = vm.props;
-    const locale = vue.computed(() => props.locale || English);
-    const lang = vue.computed(() => locale.value.name);
-    const _translator = (...args) => {
-      const [path, option] = args;
-      return translate(path, option, locale.value);
-    };
-    const t = (...args) => {
-      return _translator(...args);
-    };
-    const provides = {
-      locale,
-      lang,
-      t
-    };
-    localeObjCache = provides;
-    vue.provide(LocaleInjectionKey, provides);
-  };
-  function template(str, option) {
-    if (!str || !option)
-      return str;
-    return str.replace(/\{(\w+)\}/g, (_, key) => {
-      return option[key];
-    });
-  }
-  const localeProviderMaker = (locale = English) => {
-    const lang = vue.ref(locale.name);
-    const localeRef = vue.ref(locale);
-    return {
-      lang,
-      locale: localeRef,
-      t: (...args) => {
-        const [path, option] = args;
-        return translate(path, option, localeRef.value);
-      }
-    };
-  };
-  const useLocaleInject = () => {
-    return vue.inject(LocaleInjectionKey, localeObjCache || {
-      lang: vue.ref(English.name),
-      locale: vue.ref(English),
-      t: (...args) => {
-        const [path, option] = args;
-        return translate(path, option, English);
       }
     });
   };
 
-  const elFormKey = Symbol("elForm");
-  const elFormItemKey = Symbol("elFormItem");
-
-  const buttonGroupContextKey = Symbol("buttonGroupContextKey");
-
-  const elBreadcrumbKey = Symbol("elBreadcrumbKey");
-
-  const elPaginationKey = Symbol("elPaginationKey");
-
-  const configProviderContextKey = Symbol();
-
-  const radioGroupKey = Symbol("radioGroupKey");
-
-  const tabsRootContextKey = Symbol("tabsRootContextKey");
-
-  const scrollbarContextKey = Symbol("scrollbarContextKey");
-
-  const sizes = ["", "large", "medium", "small", "mini"];
-  const useFormItemProps = buildProps({
-    size: {
-      type: String,
-      values: sizes,
-      default: ""
-    },
-    disabled: Boolean
-  });
-  const useFormItem = ({ size, disabled }) => {
-    var _a;
-    const vm = vue.getCurrentInstance();
-    const $ELEMENT = useGlobalConfig$1();
-    const props = (_a = vm.proxy) == null ? void 0 : _a.$props;
-    const form = vue.inject(elFormKey, void 0);
-    const formItem = vue.inject(elFormItemKey, void 0);
-    return {
-      size: vue.computed(() => {
-        return props.size || vue.unref(size) || (formItem == null ? void 0 : formItem.size) || (form == null ? void 0 : form.size) || $ELEMENT.size || "";
-      }),
-      disabled: vue.computed(() => {
-        return props.disabled === true || vue.unref(disabled) || (form == null ? void 0 : form.disabled) || false;
-      }),
-      form,
-      formItem
-    };
-  };
-
   const useSameTarget = (handleClick) => {
     if (!handleClick) {
       return { onClick: NOOP, onMousedown: NOOP, onMouseup: NOOP };
@@ -6106,16 +6605,31 @@
     return { onClick, onMousedown, onMouseup };
   };
 
-  const defaultConfig = {
-    button: {
-      autoInsertSpace: false
-    }
-  };
-  const useGlobalConfig = () => {
-    return vue.inject(configProviderContextKey, defaultConfig);
+  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;
   };
 
-  const version$1 = "1.2.0-beta.4";
+  const version$1 = "1.2.0-beta.5";
 
   const makeInstaller = (components = []) => {
     const apps = [];
@@ -6133,7 +6647,7 @@
       });
       if (option.locale) {
         const localeProvides = localeProviderMaker(opts.locale);
-        app.provide(LocaleInjectionKey, localeProvides);
+        app.provide(localeContextKey, localeProvides);
       }
       app.config.globalProperties.$ELEMENT = option;
       setConfig(option);
@@ -6169,248 +6683,6 @@
     return component;
   };
 
-  function tryOnScopeDispose(fn) {
-    if (vue.getCurrentScope()) {
-      vue.onScopeDispose(fn);
-      return true;
-    }
-    return false;
-  }
-
-  const isClient = typeof window !== "undefined";
-  const isString = (val) => typeof val === "string";
-  const noop$2 = () => {
-  };
-
-  function createFilterWrapper(filter, fn) {
-    function wrapper(...args) {
-      filter(() => fn.apply(this, args), { fn, thisArg: this, args });
-    }
-    return wrapper;
-  }
-  function throttleFilter(ms, trailing = true, leading = true) {
-    let lastExec = 0;
-    let timer;
-    let preventLeading = !leading;
-    const clear = () => {
-      if (timer) {
-        clearTimeout(timer);
-        timer = void 0;
-      }
-    };
-    const filter = (invoke) => {
-      const duration = vue.unref(ms);
-      const elapsed = Date.now() - lastExec;
-      clear();
-      if (duration <= 0) {
-        lastExec = Date.now();
-        return invoke();
-      }
-      if (elapsed > duration) {
-        lastExec = Date.now();
-        if (preventLeading)
-          preventLeading = false;
-        else
-          invoke();
-      } else if (trailing) {
-        timer = setTimeout(() => {
-          lastExec = Date.now();
-          if (!leading)
-            preventLeading = true;
-          clear();
-          invoke();
-        }, duration);
-      }
-      if (!leading && !timer)
-        timer = setTimeout(() => preventLeading = true, duration);
-    };
-    return filter;
-  }
-
-  function eagerComputed(fn) {
-    const result = vue.shallowRef();
-    vue.watchSyncEffect(() => {
-      result.value = fn();
-    });
-    return vue.readonly(result);
-  }
-
-  function useThrottleFn(fn, ms = 200, trailing = true, leading = true) {
-    return createFilterWrapper(throttleFilter(ms, trailing, leading), 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);
-      }, vue.unref(interval));
-    }
-    if (immediate) {
-      isPending.value = true;
-      if (isClient)
-        start();
-    }
-    tryOnScopeDispose(stop);
-    return {
-      isPending,
-      start,
-      stop
-    };
-  }
-
-  function unrefElement(elRef) {
-    var _a;
-    const plain = vue.unref(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(args[0])) {
-      [event, listener, options] = args;
-      target = defaultWindow;
-    } else {
-      [target, event, listener, options] = args;
-    }
-    if (!target)
-      return noop$2;
-    let cleanup = noop$2;
-    const stopWatch = vue.watch(() => vue.unref(target), (el) => {
-      cleanup();
-      if (!el)
-        return;
-      el.addEventListener(event, listener, options);
-      cleanup = () => {
-        el.removeEventListener(event, listener, options);
-        cleanup = noop$2;
-      };
-    }, { immediate: true, flush: "post" });
-    const stop = () => {
-      stopWatch();
-      cleanup();
-    };
-    tryOnScopeDispose(stop);
-    return stop;
-  }
-
-  function useCssVar(prop, target, { window = defaultWindow } = {}) {
-    const variable = vue.ref("");
-    const elRef = vue.computed(() => {
-      var _a;
-      return unrefElement(target) || ((_a = window == null ? void 0 : window.document) == null ? void 0 : _a.documentElement);
-    });
-    vue.watch(elRef, (el) => {
-      if (el && window)
-        variable.value = window.getComputedStyle(el).getPropertyValue(prop);
-    }, { immediate: true });
-    vue.watch(variable, (val) => {
-      var _a;
-      if ((_a = elRef.value) == null ? void 0 : _a.style)
-        elRef.value.style.setProperty(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$9 = Object.getOwnPropertySymbols;
-  var __hasOwnProp$9 = Object.prototype.hasOwnProperty;
-  var __propIsEnum$9 = Object.prototype.propertyIsEnumerable;
-  var __objRest$2 = (source, exclude) => {
-    var target = {};
-    for (var prop in source)
-      if (__hasOwnProp$9.call(source, prop) && exclude.indexOf(prop) < 0)
-        target[prop] = source[prop];
-    if (source != null && __getOwnPropSymbols$9)
-      for (var prop of __getOwnPropSymbols$9(source)) {
-        if (exclude.indexOf(prop) < 0 && __propIsEnum$9.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 = window && "ResizeObserver" in window;
-    const cleanup = () => {
-      if (observer) {
-        observer.disconnect();
-        observer = void 0;
-      }
-    };
-    const stopWatch = vue.watch(() => unrefElement(target), (el) => {
-      cleanup();
-      if (isSupported && window && el) {
-        observer = new window.ResizeObserver(callback);
-        observer.observe(el, observerOptions);
-      }
-    }, { immediate: true, flush: "post" });
-    const stop = () => {
-      cleanup();
-      stopWatch();
-    };
-    tryOnScopeDispose(stop);
-    return {
-      isSupported,
-      stop
-    };
-  }
-
-  var SwipeDirection;
-  (function(SwipeDirection2) {
-    SwipeDirection2["UP"] = "UP";
-    SwipeDirection2["RIGHT"] = "RIGHT";
-    SwipeDirection2["DOWN"] = "DOWN";
-    SwipeDirection2["LEFT"] = "LEFT";
-    SwipeDirection2["NONE"] = "NONE";
-  })(SwipeDirection || (SwipeDirection = {}));
-
-  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;
-  }
-
   const affixProps = buildProps({
     zIndex: {
       type: definePropType([Number, String]),
@@ -7716,36 +7988,6 @@
 
   var _baseTrim = baseTrim$1;
 
-  var baseGetTag = _baseGetTag,
-      isObjectLike$3 = isObjectLike_1;
-
-  /** `Object#toString` result references. */
-  var symbolTag$2 = '[object Symbol]';
-
-  /**
-   * Checks if `value` is classified as a `Symbol` primitive or object.
-   *
-   * @static
-   * @memberOf _
-   * @since 4.0.0
-   * @category Lang
-   * @param {*} value The value to check.
-   * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.
-   * @example
-   *
-   * _.isSymbol(Symbol.iterator);
-   * // => true
-   *
-   * _.isSymbol('abc');
-   * // => false
-   */
-  function isSymbol$1(value) {
-    return typeof value == 'symbol' ||
-      (isObjectLike$3(value) && baseGetTag(value) == symbolTag$2);
-  }
-
-  var isSymbol_1 = isSymbol$1;
-
   var baseTrim = _baseTrim,
       isObject$6 = isObject_1,
       isSymbol = isSymbol_1;
@@ -7816,7 +8058,7 @@
       toNumber = toNumber_1;
 
   /** Error message constants. */
-  var FUNC_ERROR_TEXT$2 = 'Expected a function';
+  var FUNC_ERROR_TEXT$1 = 'Expected a function';
 
   /* Built-in method references for those with the same name as other `lodash` methods. */
   var nativeMax$1 = Math.max,
@@ -7889,7 +8131,7 @@
         trailing = true;
 
     if (typeof func != 'function') {
-      throw new TypeError(FUNC_ERROR_TEXT$2);
+      throw new TypeError(FUNC_ERROR_TEXT$1);
     }
     wait = toNumber(wait) || 0;
     if (isObject$5(options)) {
@@ -8855,7 +9097,7 @@
           stopResizeObserver == null ? void 0 : stopResizeObserver();
           stopResizeListener == null ? void 0 : stopResizeListener();
         } else {
-          ({ stop: stopResizeObserver } = useResizeObserver(resize$.value, update));
+          ({ stop: stopResizeObserver } = useResizeObserver(resize$, update));
           stopResizeListener = useEventListener("resize", update);
         }
       }, { immediate: true });
@@ -9049,7 +9291,7 @@
     },
     effect: {
       type: String,
-      default: "dark"
+      default: "dark" /* DARK */
     },
     enterable: {
       type: Boolean,
@@ -9291,7 +9533,7 @@
           events[event] = popperEventsHandler;
         });
       };
-      if (isArray$6(props.trigger)) {
+      if (isArray$9(props.trigger)) {
         Object.values(props.trigger).forEach(mapEvents);
       } else {
         mapEvents(props.trigger);
@@ -9589,7 +9831,7 @@
         return `el-autocomplete-${generateId()}`;
       });
       const suggestionVisible = vue.computed(() => {
-        const isValidData = isArray$6(suggestions.value) && suggestions.value.length > 0;
+        const isValidData = isArray$9(suggestions.value) && suggestions.value.length > 0;
         return (isValidData || loading.value) && activated.value;
       });
       const suggestionLoading = vue.computed(() => {
@@ -9622,7 +9864,7 @@
           if (suggestionDisabled.value) {
             return;
           }
-          if (isArray$6(suggestionsArg)) {
+          if (isArray$9(suggestionsArg)) {
             suggestions.value = suggestionsArg;
             highlightedIndex.value = props.highlightFirstItem ? 0 : -1;
           } else {
@@ -10778,7 +11020,7 @@
     emits: ["update:modelValue", "change", "focus", "blur", "calendar-change"],
     setup(props, ctx) {
       const ELEMENT = useGlobalConfig$1();
-      const { lang } = useLocaleInject();
+      const { lang } = useLocale();
       const elForm = vue.inject(elFormKey, {});
       const elFormItem = vue.inject(elFormItemKey, {});
       const elPopperOptions = vue.inject("ElPopperOptions", {});
@@ -11705,7 +11947,7 @@
     },
     emits: ["pick", "select-range", "set-picker-option"],
     setup(props, ctx) {
-      const { t, lang } = useLocaleInject();
+      const { t, lang } = useLocale();
       const selectionRange = vue.ref([0, 2]);
       const oldValue = useOldValue(props);
       const transitionName = vue.computed(() => {
@@ -12497,7 +12739,7 @@
     },
     emits: ["pick", "select-range", "set-picker-option"],
     setup(props, ctx) {
-      const { t, lang } = useLocaleInject();
+      const { t, lang } = useLocale();
       const minDate = vue.computed(() => props.parsedValue[0]);
       const maxDate = vue.computed(() => props.parsedValue[1]);
       const oldValue = useOldValue(props);
@@ -12871,7 +13113,7 @@
     },
     emits: ["pick"],
     setup(props, ctx) {
-      const { lang } = useLocaleInject();
+      const { lang } = useLocale();
       const WEEK_DAYS = vue.ref(dayjs().locale(lang.value).localeData().weekdaysShort());
       const now = dayjs().locale(lang.value);
       const firstDayOfWeek = now.$locale().weekStart || 0;
@@ -13048,7 +13290,7 @@
     },
     emits: ["input", "update:modelValue"],
     setup(props, ctx) {
-      const { t, lang } = useLocaleInject();
+      const { t, lang } = useLocale();
       const selectedDay = vue.ref(null);
       const now = dayjs().locale(lang.value);
       const prevMonthDayjs = vue.computed(() => {
@@ -13332,7 +13574,7 @@
       isObject$4 = isObject_1;
 
   /** Error message constants. */
-  var FUNC_ERROR_TEXT$1 = 'Expected a function';
+  var FUNC_ERROR_TEXT = 'Expected a function';
 
   /**
    * Creates a throttled function that only invokes `func` at most once per
@@ -13383,7 +13625,7 @@
         trailing = true;
 
     if (typeof func != 'function') {
-      throw new TypeError(FUNC_ERROR_TEXT$1);
+      throw new TypeError(FUNC_ERROR_TEXT);
     }
     if (isObject$4(options)) {
       leading = 'leading' in options ? !!options.leading : leading;
@@ -13769,7 +14011,6 @@
     },
     setup(props) {
       const instance = vue.getCurrentInstance();
-      instance.uid;
       const data = vue.reactive({
         hover: false,
         translate: 0,
@@ -14953,7 +15194,7 @@
     },
     setup(props) {
       const instance = vue.getCurrentInstance();
-      const { t } = useLocaleInject();
+      const { t } = useLocale();
       const id = generateId();
       let activeNode = null;
       let hoverTimer = null;
@@ -15302,7 +15543,7 @@
       let initialLoaded = true;
       let manualChecked = false;
       const config = useCascaderConfig(props);
-      const store = vue.ref(null);
+      let store = null;
       const menuList = vue.ref([]);
       const checkedValue = vue.ref(null);
       const menus = vue.ref([]);
@@ -15314,11 +15555,15 @@
         const { options } = props;
         const cfg = config.value;
         manualChecked = false;
-        store.value = new Store(options, cfg);
-        menus.value = [store.value.getNodes()];
+        store = new Store(options, cfg);
+        menus.value = [store.getNodes()];
         if (cfg.lazy && isEmpty(props.options)) {
           initialLoaded = false;
-          lazyLoad(void 0, () => {
+          lazyLoad(void 0, (list) => {
+            if (list) {
+              store = new Store(list, cfg);
+              menus.value = [store.getNodes()];
+            }
             initialLoaded = true;
             syncCheckedValue(false, true);
           });
@@ -15331,10 +15576,9 @@
         node = node || new Node$3({}, cfg, void 0, true);
         node.loading = true;
         const resolve = (dataList) => {
-          var _a;
           const _node = node;
           const parent = _node.root ? null : _node;
-          dataList && ((_a = store.value) == null ? void 0 : _a.appendNodes(dataList, parent));
+          dataList && (store == null ? void 0 : store.appendNodes(dataList, parent));
           _node.loading = false;
           _node.loaded = true;
           _node.childrenData = _node.childrenData || [];
@@ -15377,8 +15621,7 @@
         node && expandNode(node);
       };
       const getFlattedNodes = (leafOnly) => {
-        var _a;
-        return (_a = store.value) == null ? void 0 : _a.getFlattedNodes(leafOnly);
+        return store == null ? void 0 : store.getFlattedNodes(leafOnly);
       };
       const getCheckedNodes = (leafOnly) => {
         var _a;
@@ -15406,10 +15649,7 @@
           return;
         if (lazy && !loaded) {
           const values = deduplicate(arrayFlat(coerceTruthyValueToArray(modelValue)));
-          const nodes = values.map((val) => {
-            var _a;
-            return (_a = store.value) == null ? void 0 : _a.getNodeByValue(val);
-          }).filter((node) => !!node && !node.loaded && !node.loading);
+          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));
@@ -15419,20 +15659,16 @@
           }
         } else {
           const values = multiple ? coerceTruthyValueToArray(modelValue) : [modelValue];
-          const nodes = deduplicate(values.map((val) => {
-            var _a;
-            return (_a = store.value) == null ? void 0 : _a.getNodeByValue(val, leafOnly);
-          }));
+          const nodes = deduplicate(values.map((val) => store == null ? void 0 : store.getNodeByValue(val, leafOnly)));
           syncMenuState(nodes, false);
           checkedValue.value = modelValue;
         }
       };
       const syncMenuState = (newCheckedNodes, reserveExpandingState = true) => {
-        var _a;
         const { checkStrictly } = config.value;
         const oldNodes = checkedNodes.value;
         const newNodes = newCheckedNodes.filter((node) => !!node && (checkStrictly || node.isLeaf));
-        const oldExpandingNode = (_a = store.value) == null ? void 0 : _a.getSameNode(expandingNode.value);
+        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));
@@ -15759,7 +15995,7 @@
     setup(props, { emit }) {
       let inputInitialHeight = 0;
       let pressDeleteCount = 0;
-      const { t } = useLocaleInject();
+      const { t } = useLocale();
       const $ELEMENT = useGlobalConfig$1();
       const elForm = vue.inject(elFormKey, {});
       const elFormItem = vue.inject(elFormItemKey, {});
@@ -17443,7 +17679,7 @@
     emits: ["change", "active-change", UPDATE_MODEL_EVENT],
     setup(props, { emit }) {
       const ELEMENT = useGlobalConfig$1();
-      const { t } = useLocaleInject();
+      const { t } = useLocale();
       const elForm = vue.inject(elFormKey, {});
       const elFormItem = vue.inject(elFormItemKey, {});
       const hue = vue.ref(null);
@@ -17757,7 +17993,7 @@
     name: "ElConfigProvider",
     props: configProviderProps,
     setup(props, { slots }) {
-      useLocale();
+      provideLocale();
       vue.provide(configProviderContextKey, props);
       return () => {
         var _a;
@@ -18035,7 +18271,7 @@
     },
     emits: ["changerange", "pick", "select"],
     setup(props, ctx) {
-      const { t, lang } = useLocaleInject();
+      const { t, lang } = useLocale();
       const lastRow = vue.ref(null);
       const lastColumn = vue.ref(null);
       const tableRows = vue.ref([[], [], [], [], [], []]);
@@ -18358,7 +18594,7 @@
     },
     emits: ["changerange", "pick", "select"],
     setup(props, ctx) {
-      const { t, lang } = useLocaleInject();
+      const { t, lang } = useLocale();
       const months = vue.ref(props.date.locale("en").localeData().monthsShort().map((_) => _.toLowerCase()));
       const tableRows = vue.ref([[], [], []]);
       const lastRow = vue.ref(null);
@@ -18541,7 +18777,7 @@
     },
     emits: ["pick"],
     setup(props, ctx) {
-      const { lang } = useLocaleInject();
+      const { lang } = useLocale();
       const startYear = vue.computed(() => {
         return Math.floor(props.date.year() / 10) * 10;
       });
@@ -18689,7 +18925,7 @@
     },
     emits: ["pick", "set-picker-option"],
     setup(props, ctx) {
-      const { t, lang } = useLocaleInject();
+      const { t, lang } = useLocale();
       const pickerBase = vue.inject("EP_PICKER_BASE");
       const {
         shortcuts,
@@ -19293,7 +19529,7 @@
     },
     emits: ["pick", "set-picker-option", "calendar-change"],
     setup(props, ctx) {
-      const { t, lang } = useLocaleInject();
+      const { t, lang } = useLocale();
       const leftDate = vue.ref(dayjs().locale(lang.value));
       const rightDate = vue.ref(dayjs().locale(lang.value).add(1, "month"));
       const minDate = vue.ref(null);
@@ -20008,7 +20244,7 @@
     },
     emits: ["pick", "set-picker-option"],
     setup(props, ctx) {
-      const { t, lang } = useLocaleInject();
+      const { t, lang } = useLocale();
       const leftDate = vue.ref(dayjs().locale(lang.value));
       const rightDate = vue.ref(dayjs().locale(lang.value).add(1, "year"));
       const hasShortcuts = vue.computed(() => !!shortcuts.length);
@@ -20911,7 +21147,7 @@
       visible.value = false;
     }
     if (props.lockScroll) {
-      useLockScreen(visible);
+      useLockscreen(visible);
     }
     if (props.closeOnPressEscape) {
       useModal({
@@ -21957,7 +22193,7 @@
     },
     props: emptyProps,
     setup(props) {
-      const { t } = useLocaleInject();
+      const { t } = useLocale();
       const emptyDescription = vue.computed(() => props.description || t("el.table.emptyText"));
       const imageStyle = vue.computed(() => ({
         width: props.imageSize ? `${props.imageSize}px` : ""
@@ -23896,7 +24132,7 @@
     props: imageViewerProps,
     emits: imageViewerEmits,
     setup(props, { emit }) {
-      const { t } = useLocaleInject();
+      const { t } = useLocale();
       const wrapper = vue.ref();
       const img = vue.ref();
       const scopeEventListener = vue.effectScope();
@@ -24311,7 +24547,7 @@
     props: imageProps,
     emits: imageEmits,
     setup(props, { emit, attrs: rawAttrs }) {
-      const { t } = useLocaleInject();
+      const { t } = useLocale();
       const attrs = useAttrs();
       const hasLoadError = vue.ref(false);
       const loading = vue.ref(true);
@@ -25071,10 +25307,9 @@
           el.style.width = `${el.scrollWidth}px`;
           el.style.overflow = "hidden";
         },
-        onLeave(el, done) {
+        onLeave(el) {
           addClass(el, "horizontal-collapse-transition");
           el.style.width = `${el.dataset.scrollWidth}px`;
-          done();
         }
       };
       return {
@@ -26000,7 +26235,7 @@
     props: pageHeaderProps,
     emits: pageHeaderEmits,
     setup(_, { emit }) {
-      const { t } = useLocaleInject();
+      const { t } = useLocale();
       function handleClick() {
         emit("back");
       }
@@ -26373,7 +26608,7 @@
   script$K.__file = "packages/components/select/src/select-dropdown.vue";
 
   function useSelectStates(props) {
-    const { t } = useLocaleInject();
+    const { t } = useLocale();
     return vue.reactive({
       options: /* @__PURE__ */ new Map(),
       cachedOptions: /* @__PURE__ */ new Map(),
@@ -26403,7 +26638,7 @@
   }
   const useSelect$2 = (props, states, ctx) => {
     const ELEMENT = useGlobalConfig$1();
-    const { t } = useLocaleInject();
+    const { t } = useLocale();
     const reference = vue.ref(null);
     const input = vue.ref(null);
     const popper = vue.ref(null);
@@ -27107,7 +27342,7 @@
       "blur"
     ],
     setup(props, ctx) {
-      const { t } = useLocaleInject();
+      const { t } = useLocale();
       const states = useSelectStates(props);
       const {
         optionsArray,
@@ -27659,7 +27894,7 @@
     props: paginationSizesProps,
     emits: ["page-size-change"],
     setup(props, { emit }) {
-      const { t } = useLocaleInject();
+      const { t } = useLocale();
       const pagination = usePagination();
       const innerPageSize = vue.ref(props.pageSize);
       vue.watch(() => props.pageSizes, (newVal, oldVal) => {
@@ -27725,7 +27960,7 @@
       ElInput: ElInput$1
     },
     setup() {
-      const { t } = useLocaleInject();
+      const { t } = useLocale();
       const { pageCount, disabled, currentPage, changeEvent } = usePagination();
       const userInput = vue.ref();
       const innerValue = vue.computed(() => {
@@ -27783,7 +28018,7 @@
     name: "ElPaginationTotal",
     props: paginationTotalProps,
     setup() {
-      const { t } = useLocaleInject();
+      const { t } = useLocale();
       return {
         t
       };
@@ -28046,7 +28281,7 @@
     props: paginationProps,
     emits: paginationEmits,
     setup(props, { emit, slots }) {
-      const { t } = useLocaleInject();
+      const { t } = useLocale();
       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;
@@ -28272,7 +28507,7 @@
     props: popconfirmProps,
     emits: popconfirmEmits,
     setup(props, { emit }) {
-      const { t } = useLocaleInject();
+      const { t } = useLocale();
       const visible = vue.ref(false);
       const confirm = () => {
         visible.value = false;
@@ -28947,7 +29182,7 @@
         return result;
       });
       const valueDecimal = vue.computed(() => props.modelValue * 100 - Math.floor(props.modelValue) * 100);
-      const colorMap = vue.computed(() => isArray$6(props.colors) ? {
+      const colorMap = vue.computed(() => isArray$9(props.colors) ? {
         [props.lowThreshold]: props.colors[0],
         [props.highThreshold]: { value: props.colors[1], excluded: true },
         [props.max]: props.colors[2]
@@ -28965,7 +29200,7 @@
           width
         };
       });
-      const componentMap = vue.computed(() => isArray$6(props.icons) ? {
+      const componentMap = vue.computed(() => isArray$9(props.icons) ? {
         [props.lowThreshold]: props.icons[0],
         [props.highThreshold]: {
           value: props.icons[1],
@@ -29296,80 +29531,6 @@
 
   const ElRow = withInstall(Row);
 
-  var MapCache = _MapCache;
-
-  /** Error message constants. */
-  var FUNC_ERROR_TEXT = 'Expected a function';
-
-  /**
-   * Creates a function that memoizes the result of `func`. If `resolver` is
-   * provided, it determines the cache key for storing the result based on the
-   * arguments provided to the memoized function. By default, the first argument
-   * provided to the memoized function is used as the map cache key. The `func`
-   * is invoked with the `this` binding of the memoized function.
-   *
-   * **Note:** The cache is exposed as the `cache` property on the memoized
-   * function. Its creation may be customized by replacing the `_.memoize.Cache`
-   * constructor with one whose instances implement the
-   * [`Map`](http://ecma-international.org/ecma-262/7.0/#sec-properties-of-the-map-prototype-object)
-   * method interface of `clear`, `delete`, `get`, `has`, and `set`.
-   *
-   * @static
-   * @memberOf _
-   * @since 0.1.0
-   * @category Function
-   * @param {Function} func The function to have its output memoized.
-   * @param {Function} [resolver] The function to resolve the cache key.
-   * @returns {Function} Returns the new memoized function.
-   * @example
-   *
-   * var object = { 'a': 1, 'b': 2 };
-   * var other = { 'c': 3, 'd': 4 };
-   *
-   * var values = _.memoize(_.values);
-   * values(object);
-   * // => [1, 2]
-   *
-   * values(other);
-   * // => [3, 4]
-   *
-   * object.a = 2;
-   * values(object);
-   * // => [1, 2]
-   *
-   * // Modify the result cache.
-   * values.cache.set(object, ['a', 'b']);
-   * values(object);
-   * // => ['a', 'b']
-   *
-   * // Replace `_.memoize.Cache`.
-   * _.memoize.Cache = WeakMap;
-   */
-  function memoize(func, resolver) {
-    if (typeof func != 'function' || (resolver != null && typeof resolver != 'function')) {
-      throw new TypeError(FUNC_ERROR_TEXT);
-    }
-    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;
-  }
-
-  // Expose `MapCache`.
-  memoize.Cache = MapCache;
-
-  var memoize_1 = memoize;
-
   var safeIsNaN = Number.isNaN ||
       function ponyfill(value) {
           return typeof value === 'number' && value !== value;
@@ -31496,7 +31657,7 @@
   const flattenOptions = (options) => {
     const flattened = [];
     options.map((option) => {
-      if (isArray$6(option.options)) {
+      if (isArray$9(option.options)) {
         flattened.push({
           label: option.label,
           isTitle: true,
@@ -31547,7 +31708,7 @@
     mini: 33
   };
   const useSelect = (props, emit) => {
-    const { t } = useLocaleInject();
+    const { t } = useLocale();
     const elForm = vue.inject(elFormKey, {});
     const elFormItem = vue.inject(elFormItemKey, {});
     const $ELEMENT = useGlobalConfig$1();
@@ -31628,7 +31789,7 @@
         return [];
       }
       return flattenOptions(props.options.concat(states.createdOptions).map((v) => {
-        if (isArray$6(v.options)) {
+        if (isArray$9(v.options)) {
           const filtered = v.options.filter(isValidOption);
           if (filtered.length > 0) {
             return {
@@ -31664,7 +31825,7 @@
       };
     });
     const shouldShowPlaceholder = vue.computed(() => {
-      if (isArray$6(props.modelValue)) {
+      if (isArray$9(props.modelValue)) {
         return props.modelValue.length === 0 && !states.displayInputValue;
       }
       return props.filterable ? states.displayInputValue.length === 0 : true;
@@ -31913,7 +32074,7 @@
     };
     const handleClear = () => {
       let emptyValue;
-      if (isArray$6(props.modelValue)) {
+      if (isArray$9(props.modelValue)) {
         emptyValue = [];
       } else {
         emptyValue = "";
@@ -33547,7 +33708,7 @@
       type: [String, Array, Number],
       values: componentSize,
       validator: (val) => {
-        return isNumber(val) || isArray$6(val) && val.length === 2 && val.every((i) => isNumber(i));
+        return isNumber(val) || isArray$9(val) && val.length === 2 && val.every((i) => isNumber(i));
       }
     }
   });
@@ -33562,11 +33723,11 @@
         const children = vue.renderSlot(slots, "default", { key: 0 }, () => []);
         if (((_a = children.children) != null ? _a : []).length === 0)
           return null;
-        if (isArray$6(children.children)) {
+        if (isArray$9(children.children)) {
           let extractedChildren = [];
           children.children.forEach((child, loopKey) => {
             if (isFragment(child)) {
-              if (isArray$6(child.children)) {
+              if (isArray$9(child.children)) {
                 child.children.forEach((nested, key) => {
                   extractedChildren.push(vue.createVNode(script$o, {
                     style: itemStyle.value,
@@ -35720,7 +35881,7 @@
     },
     setup(props) {
       const instance = vue.getCurrentInstance();
-      const { t } = useLocaleInject();
+      const { t } = useLocale();
       const parent = instance.parent;
       if (!parent.filterPanels.value[props.column.id]) {
         parent.filterPanels.value[props.column.id] = instance;
@@ -37564,7 +37725,7 @@
       "expand-change"
     ],
     setup(props) {
-      const { t } = useLocaleInject();
+      const { t } = useLocale();
       const table = vue.getCurrentInstance();
       const store = createStore(table, props);
       table.store = store;
@@ -39503,7 +39664,7 @@
     props: useCheckProps,
     emits: [CHECKED_CHANGE_EVENT],
     setup(props, { slots }) {
-      const { t } = useLocaleInject();
+      const { t } = useLocale();
       const panelState = vue.reactive({
         checked: [],
         allChecked: false,
@@ -39801,7 +39962,7 @@
       RIGHT_CHECK_CHANGE_EVENT
     ],
     setup(props, { emit, slots }) {
-      const { t } = useLocaleInject();
+      const { t } = useLocale();
       const elFormItem = vue.inject(elFormItemKey, {});
       const checkedState = vue.reactive({
         leftChecked: [],
@@ -41333,7 +41494,7 @@
       "node-drag-over"
     ],
     setup(props, ctx) {
-      const { t } = useLocaleInject();
+      const { t } = useLocale();
       const store = vue.ref(new TreeStore({
         key: props.nodeKey,
         data: props.data,
@@ -41598,10 +41759,10 @@
     props: {
       type: definePropType(Object),
       default: () => mutable({
-        children: "children",
-        label: "label",
-        disabled: "disabled",
-        value: "id"
+        children: "children" /* CHILDREN */,
+        label: "label" /* LABEL */,
+        disabled: "disabled" /* DISABLED */,
+        value: "id" /* KEY */
       })
     },
     highlightCurrent: {
@@ -42335,7 +42496,7 @@
         props,
         instance: vue.getCurrentInstance()
       });
-      const { t } = useLocaleInject();
+      const { t } = useLocale();
       const {
         flattenTree,
         isNotEmpty,
@@ -42553,7 +42714,7 @@
     },
     emits: ["remove"],
     setup(props, { emit }) {
-      const { t } = useLocaleInject();
+      const { t } = useLocale();
       const handleClick = (file) => {
         props.handlePreview(file);
       };
@@ -45181,7 +45342,7 @@
     },
     emits: ["vanish", "action"],
     setup(props, { emit }) {
-      const { t } = useLocaleInject();
+      const { t } = useLocale();
       const visible = vue.ref(false);
       const state = vue.reactive({
         beforeClose: null,
@@ -45225,7 +45386,7 @@
       const hasMessage = vue.computed(() => !!state.message);
       const inputRef = vue.ref(null);
       const confirmRef = vue.ref(null);
-      const confirmButtonClasses = vue.computed(() => `el-button--primary ${state.confirmButtonClass}`);
+      const confirmButtonClasses = vue.computed(() => state.confirmButtonClass);
       vue.watch(() => state.inputValue, async (val) => {
         await vue.nextTick();
         if (props.boxType === "prompt" && val !== null) {
@@ -45339,7 +45500,7 @@
         usePreventGlobal(visible, "keydown", (e) => e.code === EVENT_CODE.esc);
       }
       if (props.lockScroll) {
-        useLockScreen(visible);
+        useLockscreen(visible);
       }
       useRestoreActive(visible);
       return {
@@ -45493,6 +45654,8 @@
                 }, 8, ["loading", "class", "round", "size"])) : vue.createCommentVNode("v-if", true),
                 vue.withDirectives(vue.createVNode(_component_el_button, {
                   ref: "confirmRef",
+                  type: "primary",
+                  plain: "",
                   loading: _ctx.confirmButtonLoading,
                   class: vue.normalizeClass([_ctx.confirmButtonClasses]),
                   round: _ctx.roundButton,
@@ -46122,7 +46285,6 @@
   exports.IconComponentMap = IconComponentMap;
   exports.IconMap = IconMap;
   exports.LIGHT_EFFECT = LIGHT_EFFECT;
-  exports.LocaleInjectionKey = LocaleInjectionKey;
   exports.Mousewheel = Mousewheel;
   exports.RepeatClick = RepeatClick;
   exports.Resize = Resize;
@@ -46140,6 +46302,7 @@
   exports.barProps = barProps;
   exports.breadcrumbItemProps = breadcrumbItemProps;
   exports.breadcrumbProps = breadcrumbProps;
+  exports.buildTranslator = buildTranslator;
   exports.buttonEmits = buttonEmits;
   exports.buttonGroupContextKey = buttonGroupContextKey;
   exports.buttonNativeType = buttonNativeType;
@@ -46149,6 +46312,7 @@
   exports.cardProps = cardProps;
   exports.colProps = colProps;
   exports.configProviderContextKey = configProviderContextKey;
+  exports.configProviderProps = configProviderProps;
   exports["default"] = installer;
   exports.dialogEmits = dialogEmits;
   exports.dialogProps = dialogProps;
@@ -46172,6 +46336,7 @@
   exports.install = install;
   exports.linkEmits = linkEmits;
   exports.linkProps = linkProps;
+  exports.localeContextKey = localeContextKey;
   exports.localeProviderMaker = localeProviderMaker;
   exports.makeInstaller = makeInstaller$1;
   exports.menuEmits = menuEmits;
@@ -46194,6 +46359,7 @@
   exports.popconfirmEmits = popconfirmEmits;
   exports.popconfirmProps = popconfirmProps;
   exports.popperDefaultProps = popperDefaultProps;
+  exports.provideLocale = provideLocale;
   exports.radioButtonProps = radioButtonProps;
   exports.radioEmits = radioEmits;
   exports.radioGroupEmits = radioGroupEmits;
@@ -46228,22 +46394,18 @@
   exports.tabsRootContextKey = tabsRootContextKey;
   exports.tagEmits = tagEmits;
   exports.tagProps = tagProps;
-  exports.themeVarsKey = themeVarsKey;
   exports.timePickerDefaultProps = timePickerDefaultProps;
+  exports.translate = translate;
   exports.useAttrs = useAttrs;
   exports.useCascaderConfig = useCascaderConfig;
-  exports.useCssVar = useCssVar$1;
   exports.useDialog = useDialog;
-  exports.useEvents = index;
   exports.useFocus = useFocus;
   exports.useFormItem = useFormItem;
   exports.useFormItemProps = useFormItemProps;
   exports.useGlobalConfig = useGlobalConfig;
   exports.useLocale = useLocale;
-  exports.useLocaleInject = useLocaleInject;
   exports.useLocaleProps = useLocaleProps;
-  exports.useLockScreen = useLockScreen;
-  exports.useMigrating = useMigrating;
+  exports.useLockscreen = useLockscreen;
   exports.useModal = useModal;
   exports.useModelToggle = useModelToggle;
   exports.useModelToggleEmits = useModelToggleEmits;
@@ -46258,7 +46420,6 @@
   exports.useSameTarget = useSameTarget;
   exports.useSpace = useSpace;
   exports.useTeleport = useTeleport;
-  exports.useThemeVars = useThemeVars;
   exports.useThrottleRender = useThrottleRender;
   exports.useTimeout = useTimeout;
   exports.version = version;