easy-elplus 1.0.0

package/dist/index.full.js

@@ -0,0 +1,4431 @@
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('vue'), require('element-plus'), require('@element-plus/icons-vue')) :
+  typeof define === 'function' && define.amd ? define(['exports', 'vue', 'element-plus', '@element-plus/icons-vue'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.EasyElPlus = {}, global.Vue, global.ElementPlus, global.ElementPlusIconsVue));
+})(this, (function (exports, vue, elementPlus, iconsVue) { 'use strict';
+
+  /**
+  * @vue/shared v3.5.27
+  * (c) 2018-present Yuxi (Evan) You and Vue contributors
+  * @license MIT
+  **/
+
+
+  !!(process.env.NODE_ENV !== "production") ? Object.freeze({}) : {};
+  !!(process.env.NODE_ENV !== "production") ? Object.freeze([]) : [];
+  const isFunction$1 = (val) => typeof val === "function";
+  const isObject$1 = (val) => val !== null && typeof val === "object";
+
+  /**
+   * 给组件添加 install 方法，支持主组件 + 附加组件
+   * @param {Object} main 主组件
+   * @param {Object} [extra] 附加组件集合
+   */
+  const withInstall = (main, extra) => {
+    main.install = app => {
+      const components = [main, ...([])];
+
+      for (const comp of components) {
+        if (comp.name) {
+          app.component(comp.name, comp);
+        } else {
+          console.warn("Component missing name:", comp);
+        }
+      }
+    };
+
+    return main
+  };
+
+  /**
+   * 全局应用上下文管理
+   * 用于在非组件上下文中访问主应用的配置、插件和全局组件
+   */
+
+  let globalAppContext = null;
+
+  /**
+   * 设置全局应用上下文
+   * 应该在主应用初始化时调用（通常在 app.use() 中）
+   * @param {AppContext} context - Vue 应用上下文
+   */
+  function setGlobalAppContext(context) {
+    globalAppContext = context;
+  }
+
+  /**
+   * 获取全局应用上下文
+   * @returns {AppContext | null}
+   */
+  function getGlobalAppContext() {
+    return globalAppContext
+  }
+
+  const isUndefined = val => typeof val === "undefined";
+  const isNumber = val => typeof val === "number";
+  const isString = val => typeof val === "string";
+
+  /** Detect free variable `global` from Node.js. */
+  var freeGlobal = typeof global == 'object' && global && global.Object === Object && global;
+
+  /** Detect free variable `self`. */
+  var freeSelf = typeof self == 'object' && self && self.Object === Object && self;
+
+  /** Used as a reference to the global object. */
+  var root = freeGlobal || freeSelf || Function('return this')();
+
+  /** Built-in value references. */
+  var Symbol$1 = root.Symbol;
+
+  /** Used for built-in method references. */
+  var objectProto$c = Object.prototype;
+
+  /** Used to check objects for own properties. */
+  var hasOwnProperty$9 = objectProto$c.hasOwnProperty;
+
+  /**
+   * Used to resolve the
+   * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
+   * of values.
+   */
+  var nativeObjectToString$1 = objectProto$c.toString;
+
+  /** Built-in value references. */
+  var symToStringTag$1 = Symbol$1 ? Symbol$1.toStringTag : undefined;
+
+  /**
+   * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.
+   *
+   * @private
+   * @param {*} value The value to query.
+   * @returns {string} Returns the raw `toStringTag`.
+   */
+  function getRawTag(value) {
+    var isOwn = hasOwnProperty$9.call(value, symToStringTag$1),
+        tag = value[symToStringTag$1];
+
+    try {
+      value[symToStringTag$1] = undefined;
+      var unmasked = true;
+    } catch (e) {}
+
+    var result = nativeObjectToString$1.call(value);
+    if (unmasked) {
+      if (isOwn) {
+        value[symToStringTag$1] = tag;
+      } else {
+        delete value[symToStringTag$1];
+      }
+    }
+    return result;
+  }
+
+  /** Used for built-in method references. */
+  var objectProto$b = Object.prototype;
+
+  /**
+   * Used to resolve the
+   * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)
+   * of values.
+   */
+  var nativeObjectToString = objectProto$b.toString;
+
+  /**
+   * Converts `value` to a string using `Object.prototype.toString`.
+   *
+   * @private
+   * @param {*} value The value to convert.
+   * @returns {string} Returns the converted string.
+   */
+  function objectToString(value) {
+    return nativeObjectToString.call(value);
+  }
+
+  /** `Object#toString` result references. */
+  var nullTag = '[object Null]',
+      undefinedTag = '[object Undefined]';
+
+  /** Built-in value references. */
+  var symToStringTag = Symbol$1 ? Symbol$1.toStringTag : undefined;
+
+  /**
+   * The base implementation of `getTag` without fallbacks for buggy environments.
+   *
+   * @private
+   * @param {*} value The value to query.
+   * @returns {string} Returns the `toStringTag`.
+   */
+  function baseGetTag(value) {
+    if (value == null) {
+      return value === undefined ? undefinedTag : nullTag;
+    }
+    return (symToStringTag && symToStringTag in Object(value))
+      ? getRawTag(value)
+      : objectToString(value);
+  }
+
+  /**
+   * Checks if `value` is object-like. A value is object-like if it's not `null`
+   * and has a `typeof` result of "object".
+   *
+   * @static
+   * @memberOf _
+   * @since 4.0.0
+   * @category Lang
+   * @param {*} value The value to check.
+   * @returns {boolean} Returns `true` if `value` is object-like, else `false`.
+   * @example
+   *
+   * _.isObjectLike({});
+   * // => true
+   *
+   * _.isObjectLike([1, 2, 3]);
+   * // => true
+   *
+   * _.isObjectLike(_.noop);
+   * // => false
+   *
+   * _.isObjectLike(null);
+   * // => false
+   */
+  function isObjectLike(value) {
+    return value != null && typeof value == 'object';
+  }
+
+  /** `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(value) {
+    return typeof value == 'symbol' ||
+      (isObjectLike(value) && baseGetTag(value) == symbolTag$2);
+  }
+
+  /**
+   * 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(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;
+  }
+
+  /**
+   * Checks if `value` is classified as an `Array` object.
+   *
+   * @static
+   * @memberOf _
+   * @since 0.1.0
+   * @category Lang
+   * @param {*} value The value to check.
+   * @returns {boolean} Returns `true` if `value` is an array, else `false`.
+   * @example
+   *
+   * _.isArray([1, 2, 3]);
+   * // => true
+   *
+   * _.isArray(document.body.children);
+   * // => false
+   *
+   * _.isArray('abc');
+   * // => false
+   *
+   * _.isArray(_.noop);
+   * // => false
+   */
+  var isArray = Array.isArray;
+
+  /** Used to convert symbols to primitives and strings. */
+  var symbolProto$1 = Symbol$1 ? Symbol$1.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(value) {
+    // Exit early for strings to avoid a performance hit in some environments.
+    if (typeof value == 'string') {
+      return value;
+    }
+    if (isArray(value)) {
+      // Recursively convert values (susceptible to call stack limits).
+      return arrayMap(value, baseToString) + '';
+    }
+    if (isSymbol(value)) {
+      return symbolToString ? symbolToString.call(value) : '';
+    }
+    var result = (value + '');
+    return (result == '0' && (1 / value) == -Infinity) ? '-0' : result;
+  }
+
+  /**
+   * Checks if `value` is the
+   * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)
+   * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)
+   *
+   * @static
+   * @memberOf _
+   * @since 0.1.0
+   * @category Lang
+   * @param {*} value The value to check.
+   * @returns {boolean} Returns `true` if `value` is an object, else `false`.
+   * @example
+   *
+   * _.isObject({});
+   * // => true
+   *
+   * _.isObject([1, 2, 3]);
+   * // => true
+   *
+   * _.isObject(_.noop);
+   * // => true
+   *
+   * _.isObject(null);
+   * // => false
+   */
+  function isObject(value) {
+    var type = typeof value;
+    return value != null && (type == 'object' || type == 'function');
+  }
+
+  /**
+   * This method returns the first argument it receives.
+   *
+   * @static
+   * @since 0.1.0
+   * @memberOf _
+   * @category Util
+   * @param {*} value Any value.
+   * @returns {*} Returns `value`.
+   * @example
+   *
+   * var object = { 'a': 1 };
+   *
+   * console.log(_.identity(object) === object);
+   * // => true
+   */
+  function identity(value) {
+    return value;
+  }
+
+  /** `Object#toString` result references. */
+  var asyncTag = '[object AsyncFunction]',
+      funcTag$2 = '[object Function]',
+      genTag$1 = '[object GeneratorFunction]',
+      proxyTag = '[object Proxy]';
+
+  /**
+   * Checks if `value` is classified as a `Function` object.
+   *
+   * @static
+   * @memberOf _
+   * @since 0.1.0
+   * @category Lang
+   * @param {*} value The value to check.
+   * @returns {boolean} Returns `true` if `value` is a function, else `false`.
+   * @example
+   *
+   * _.isFunction(_);
+   * // => true
+   *
+   * _.isFunction(/abc/);
+   * // => false
+   */
+  function isFunction(value) {
+    if (!isObject(value)) {
+      return false;
+    }
+    // The use of `Object#toString` avoids issues with the `typeof` operator
+    // in Safari 9 which returns 'object' for typed arrays and other constructors.
+    var tag = baseGetTag(value);
+    return tag == funcTag$2 || tag == genTag$1 || tag == asyncTag || tag == proxyTag;
+  }
+
+  /** Used to detect overreaching core-js shims. */
+  var coreJsData = root['__core-js_shared__'];
+
+  /** Used to detect methods masquerading as native. */
+  var maskSrcKey = (function() {
+    var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || '');
+    return uid ? ('Symbol(src)_1.' + uid) : '';
+  }());
+
+  /**
+   * Checks if `func` has its source masked.
+   *
+   * @private
+   * @param {Function} func The function to check.
+   * @returns {boolean} Returns `true` if `func` is masked, else `false`.
+   */
+  function isMasked(func) {
+    return !!maskSrcKey && (maskSrcKey in func);
+  }
+
+  /** Used for built-in method references. */
+  var funcProto$2 = Function.prototype;
+
+  /** Used to resolve the decompiled source of functions. */
+  var funcToString$2 = funcProto$2.toString;
+
+  /**
+   * Converts `func` to its source code.
+   *
+   * @private
+   * @param {Function} func The function to convert.
+   * @returns {string} Returns the source code.
+   */
+  function toSource(func) {
+    if (func != null) {
+      try {
+        return funcToString$2.call(func);
+      } catch (e) {}
+      try {
+        return (func + '');
+      } catch (e) {}
+    }
+    return '';
+  }
+
+  /**
+   * Used to match `RegExp`
+   * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).
+   */
+  var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
+
+  /** Used to detect host constructors (Safari). */
+  var reIsHostCtor = /^\[object .+?Constructor\]$/;
+
+  /** Used for built-in method references. */
+  var funcProto$1 = Function.prototype,
+      objectProto$a = Object.prototype;
+
+  /** Used to resolve the decompiled source of functions. */
+  var funcToString$1 = funcProto$1.toString;
+
+  /** Used to check objects for own properties. */
+  var hasOwnProperty$8 = objectProto$a.hasOwnProperty;
+
+  /** Used to detect if a method is native. */
+  var reIsNative = RegExp('^' +
+    funcToString$1.call(hasOwnProperty$8).replace(reRegExpChar, '\\$&')
+    .replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$'
+  );
+
+  /**
+   * The base implementation of `_.isNative` without bad shim checks.
+   *
+   * @private
+   * @param {*} value The value to check.
+   * @returns {boolean} Returns `true` if `value` is a native function,
+   *  else `false`.
+   */
+  function baseIsNative(value) {
+    if (!isObject(value) || isMasked(value)) {
+      return false;
+    }
+    var pattern = isFunction(value) ? reIsNative : reIsHostCtor;
+    return pattern.test(toSource(value));
+  }
+
+  /**
+   * Gets the value at `key` of `object`.
+   *
+   * @private
+   * @param {Object} [object] The object to query.
+   * @param {string} key The key of the property to get.
+   * @returns {*} Returns the property value.
+   */
+  function getValue(object, key) {
+    return object == null ? undefined : object[key];
+  }
+
+  /**
+   * Gets the native function at `key` of `object`.
+   *
+   * @private
+   * @param {Object} object The object to query.
+   * @param {string} key The key of the method to get.
+   * @returns {*} Returns the function if it's native, else `undefined`.
+   */
+  function getNative(object, key) {
+    var value = getValue(object, key);
+    return baseIsNative(value) ? value : undefined;
+  }
+
+  /* Built-in method references that are verified to be native. */
+  var WeakMap = getNative(root, 'WeakMap');
+
+  /**
+   * A faster alternative to `Function#apply`, this function invokes `func`
+   * with the `this` binding of `thisArg` and the arguments of `args`.
+   *
+   * @private
+   * @param {Function} func The function to invoke.
+   * @param {*} thisArg The `this` binding of `func`.
+   * @param {Array} args The arguments to invoke `func` with.
+   * @returns {*} Returns the result of `func`.
+   */
+  function apply(func, thisArg, args) {
+    switch (args.length) {
+      case 0: return func.call(thisArg);
+      case 1: return func.call(thisArg, args[0]);
+      case 2: return func.call(thisArg, args[0], args[1]);
+      case 3: return func.call(thisArg, args[0], args[1], args[2]);
+    }
+    return func.apply(thisArg, args);
+  }
+
+  /** Used to detect hot functions by number of calls within a span of milliseconds. */
+  var HOT_COUNT = 800,
+      HOT_SPAN = 16;
+
+  /* Built-in method references for those with the same name as other `lodash` methods. */
+  var nativeNow = Date.now;
+
+  /**
+   * Creates a function that'll short out and invoke `identity` instead
+   * of `func` when it's called `HOT_COUNT` or more times in `HOT_SPAN`
+   * milliseconds.
+   *
+   * @private
+   * @param {Function} func The function to restrict.
+   * @returns {Function} Returns the new shortable function.
+   */
+  function shortOut(func) {
+    var count = 0,
+        lastCalled = 0;
+
+    return function() {
+      var stamp = nativeNow(),
+          remaining = HOT_SPAN - (stamp - lastCalled);
+
+      lastCalled = stamp;
+      if (remaining > 0) {
+        if (++count >= HOT_COUNT) {
+          return arguments[0];
+        }
+      } else {
+        count = 0;
+      }
+      return func.apply(undefined, arguments);
+    };
+  }
+
+  /**
+   * Creates a function that returns `value`.
+   *
+   * @static
+   * @memberOf _
+   * @since 2.4.0
+   * @category Util
+   * @param {*} value The value to return from the new function.
+   * @returns {Function} Returns the new constant function.
+   * @example
+   *
+   * var objects = _.times(2, _.constant({ 'a': 1 }));
+   *
+   * console.log(objects);
+   * // => [{ 'a': 1 }, { 'a': 1 }]
+   *
+   * console.log(objects[0] === objects[1]);
+   * // => true
+   */
+  function constant(value) {
+    return function() {
+      return value;
+    };
+  }
+
+  var defineProperty = (function() {
+    try {
+      var func = getNative(Object, 'defineProperty');
+      func({}, '', {});
+      return func;
+    } catch (e) {}
+  }());
+
+  /**
+   * The base implementation of `setToString` without support for hot loop shorting.
+   *
+   * @private
+   * @param {Function} func The function to modify.
+   * @param {Function} string The `toString` result.
+   * @returns {Function} Returns `func`.
+   */
+  var baseSetToString = !defineProperty ? identity : function(func, string) {
+    return defineProperty(func, 'toString', {
+      'configurable': true,
+      'enumerable': false,
+      'value': constant(string),
+      'writable': true
+    });
+  };
+
+  /**
+   * Sets the `toString` method of `func` to return `string`.
+   *
+   * @private
+   * @param {Function} func The function to modify.
+   * @param {Function} string The `toString` result.
+   * @returns {Function} Returns `func`.
+   */
+  var setToString = shortOut(baseSetToString);
+
+  /**
+   * A specialized version of `_.forEach` 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 `array`.
+   */
+  function arrayEach(array, iteratee) {
+    var index = -1,
+        length = array == null ? 0 : array.length;
+
+    while (++index < length) {
+      if (iteratee(array[index], index, array) === false) {
+        break;
+      }
+    }
+    return array;
+  }
+
+  /** Used as references for various `Number` constants. */
+  var MAX_SAFE_INTEGER$1 = 9007199254740991;
+
+  /** Used to detect unsigned integer values. */
+  var reIsUint = /^(?:0|[1-9]\d*)$/;
+
+  /**
+   * Checks if `value` is a valid array-like index.
+   *
+   * @private
+   * @param {*} value The value to check.
+   * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.
+   * @returns {boolean} Returns `true` if `value` is a valid index, else `false`.
+   */
+  function isIndex(value, length) {
+    var type = typeof value;
+    length = length == null ? MAX_SAFE_INTEGER$1 : length;
+
+    return !!length &&
+      (type == 'number' ||
+        (type != 'symbol' && reIsUint.test(value))) &&
+          (value > -1 && value % 1 == 0 && value < length);
+  }
+
+  /**
+   * The base implementation of `assignValue` and `assignMergeValue` without
+   * value checks.
+   *
+   * @private
+   * @param {Object} object The object to modify.
+   * @param {string} key The key of the property to assign.
+   * @param {*} value The value to assign.
+   */
+  function baseAssignValue(object, key, value) {
+    if (key == '__proto__' && defineProperty) {
+      defineProperty(object, key, {
+        'configurable': true,
+        'enumerable': true,
+        'value': value,
+        'writable': true
+      });
+    } else {
+      object[key] = value;
+    }
+  }
+
+  /**
+   * Performs a
+   * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
+   * comparison between two values to determine if they are equivalent.
+   *
+   * @static
+   * @memberOf _
+   * @since 4.0.0
+   * @category Lang
+   * @param {*} value The value to compare.
+   * @param {*} other The other value to compare.
+   * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
+   * @example
+   *
+   * var object = { 'a': 1 };
+   * var other = { 'a': 1 };
+   *
+   * _.eq(object, object);
+   * // => true
+   *
+   * _.eq(object, other);
+   * // => false
+   *
+   * _.eq('a', 'a');
+   * // => true
+   *
+   * _.eq('a', Object('a'));
+   * // => false
+   *
+   * _.eq(NaN, NaN);
+   * // => true
+   */
+  function eq(value, other) {
+    return value === other || (value !== value && other !== other);
+  }
+
+  /** Used for built-in method references. */
+  var objectProto$9 = Object.prototype;
+
+  /** Used to check objects for own properties. */
+  var hasOwnProperty$7 = objectProto$9.hasOwnProperty;
+
+  /**
+   * Assigns `value` to `key` of `object` if the existing value is not equivalent
+   * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
+   * for equality comparisons.
+   *
+   * @private
+   * @param {Object} object The object to modify.
+   * @param {string} key The key of the property to assign.
+   * @param {*} value The value to assign.
+   */
+  function assignValue(object, key, value) {
+    var objValue = object[key];
+    if (!(hasOwnProperty$7.call(object, key) && eq(objValue, value)) ||
+        (value === undefined && !(key in object))) {
+      baseAssignValue(object, key, value);
+    }
+  }
+
+  /**
+   * Copies properties of `source` to `object`.
+   *
+   * @private
+   * @param {Object} source The object to copy properties from.
+   * @param {Array} props The property identifiers to copy.
+   * @param {Object} [object={}] The object to copy properties to.
+   * @param {Function} [customizer] The function to customize copied values.
+   * @returns {Object} Returns `object`.
+   */
+  function copyObject(source, props, object, customizer) {
+    var isNew = !object;
+    object || (object = {});
+
+    var index = -1,
+        length = props.length;
+
+    while (++index < length) {
+      var key = props[index];
+
+      var newValue = undefined;
+
+      if (newValue === undefined) {
+        newValue = source[key];
+      }
+      if (isNew) {
+        baseAssignValue(object, key, newValue);
+      } else {
+        assignValue(object, key, newValue);
+      }
+    }
+    return object;
+  }
+
+  /* Built-in method references for those with the same name as other `lodash` methods. */
+  var nativeMax = Math.max;
+
+  /**
+   * A specialized version of `baseRest` which transforms the rest array.
+   *
+   * @private
+   * @param {Function} func The function to apply a rest parameter to.
+   * @param {number} [start=func.length-1] The start position of the rest parameter.
+   * @param {Function} transform The rest array transform.
+   * @returns {Function} Returns the new function.
+   */
+  function overRest(func, start, transform) {
+    start = nativeMax(start === undefined ? (func.length - 1) : start, 0);
+    return function() {
+      var args = arguments,
+          index = -1,
+          length = nativeMax(args.length - start, 0),
+          array = Array(length);
+
+      while (++index < length) {
+        array[index] = args[start + index];
+      }
+      index = -1;
+      var otherArgs = Array(start + 1);
+      while (++index < start) {
+        otherArgs[index] = args[index];
+      }
+      otherArgs[start] = transform(array);
+      return apply(func, this, otherArgs);
+    };
+  }
+
+  /** Used as references for various `Number` constants. */
+  var MAX_SAFE_INTEGER = 9007199254740991;
+
+  /**
+   * Checks if `value` is a valid array-like length.
+   *
+   * **Note:** This method is loosely based on
+   * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).
+   *
+   * @static
+   * @memberOf _
+   * @since 4.0.0
+   * @category Lang
+   * @param {*} value The value to check.
+   * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.
+   * @example
+   *
+   * _.isLength(3);
+   * // => true
+   *
+   * _.isLength(Number.MIN_VALUE);
+   * // => false
+   *
+   * _.isLength(Infinity);
+   * // => false
+   *
+   * _.isLength('3');
+   * // => false
+   */
+  function isLength(value) {
+    return typeof value == 'number' &&
+      value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;
+  }
+
+  /**
+   * Checks if `value` is array-like. A value is considered array-like if it's
+   * not a function and has a `value.length` that's an integer greater than or
+   * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.
+   *
+   * @static
+   * @memberOf _
+   * @since 4.0.0
+   * @category Lang
+   * @param {*} value The value to check.
+   * @returns {boolean} Returns `true` if `value` is array-like, else `false`.
+   * @example
+   *
+   * _.isArrayLike([1, 2, 3]);
+   * // => true
+   *
+   * _.isArrayLike(document.body.children);
+   * // => true
+   *
+   * _.isArrayLike('abc');
+   * // => true
+   *
+   * _.isArrayLike(_.noop);
+   * // => false
+   */
+  function isArrayLike(value) {
+    return value != null && isLength(value.length) && !isFunction(value);
+  }
+
+  /** Used for built-in method references. */
+  var objectProto$8 = Object.prototype;
+
+  /**
+   * Checks if `value` is likely a prototype object.
+   *
+   * @private
+   * @param {*} value The value to check.
+   * @returns {boolean} Returns `true` if `value` is a prototype, else `false`.
+   */
+  function isPrototype(value) {
+    var Ctor = value && value.constructor,
+        proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto$8;
+
+    return value === proto;
+  }
+
+  /**
+   * The base implementation of `_.times` without support for iteratee shorthands
+   * or max array length checks.
+   *
+   * @private
+   * @param {number} n The number of times to invoke `iteratee`.
+   * @param {Function} iteratee The function invoked per iteration.
+   * @returns {Array} Returns the array of results.
+   */
+  function baseTimes(n, iteratee) {
+    var index = -1,
+        result = Array(n);
+
+    while (++index < n) {
+      result[index] = iteratee(index);
+    }
+    return result;
+  }
+
+  /** `Object#toString` result references. */
+  var argsTag$2 = '[object Arguments]';
+
+  /**
+   * The base implementation of `_.isArguments`.
+   *
+   * @private
+   * @param {*} value The value to check.
+   * @returns {boolean} Returns `true` if `value` is an `arguments` object,
+   */
+  function baseIsArguments(value) {
+    return isObjectLike(value) && baseGetTag(value) == argsTag$2;
+  }
+
+  /** Used for built-in method references. */
+  var objectProto$7 = Object.prototype;
+
+  /** Used to check objects for own properties. */
+  var hasOwnProperty$6 = objectProto$7.hasOwnProperty;
+
+  /** Built-in value references. */
+  var propertyIsEnumerable$1 = objectProto$7.propertyIsEnumerable;
+
+  /**
+   * Checks if `value` is likely an `arguments` object.
+   *
+   * @static
+   * @memberOf _
+   * @since 0.1.0
+   * @category Lang
+   * @param {*} value The value to check.
+   * @returns {boolean} Returns `true` if `value` is an `arguments` object,
+   *  else `false`.
+   * @example
+   *
+   * _.isArguments(function() { return arguments; }());
+   * // => true
+   *
+   * _.isArguments([1, 2, 3]);
+   * // => false
+   */
+  var isArguments = baseIsArguments(function() { return arguments; }()) ? baseIsArguments : function(value) {
+    return isObjectLike(value) && hasOwnProperty$6.call(value, 'callee') &&
+      !propertyIsEnumerable$1.call(value, 'callee');
+  };
+
+  /**
+   * This method returns `false`.
+   *
+   * @static
+   * @memberOf _
+   * @since 4.13.0
+   * @category Util
+   * @returns {boolean} Returns `false`.
+   * @example
+   *
+   * _.times(2, _.stubFalse);
+   * // => [false, false]
+   */
+  function stubFalse() {
+    return false;
+  }
+
+  /** Detect free variable `exports`. */
+  var freeExports$2 = typeof exports == 'object' && exports && !exports.nodeType && exports;
+
+  /** Detect free variable `module`. */
+  var freeModule$2 = freeExports$2 && typeof module == 'object' && module && !module.nodeType && module;
+
+  /** Detect the popular CommonJS extension `module.exports`. */
+  var moduleExports$2 = freeModule$2 && freeModule$2.exports === freeExports$2;
+
+  /** Built-in value references. */
+  var Buffer$1 = moduleExports$2 ? root.Buffer : undefined;
+
+  /* Built-in method references for those with the same name as other `lodash` methods. */
+  var nativeIsBuffer = Buffer$1 ? Buffer$1.isBuffer : undefined;
+
+  /**
+   * Checks if `value` is a buffer.
+   *
+   * @static
+   * @memberOf _
+   * @since 4.3.0
+   * @category Lang
+   * @param {*} value The value to check.
+   * @returns {boolean} Returns `true` if `value` is a buffer, else `false`.
+   * @example
+   *
+   * _.isBuffer(new Buffer(2));
+   * // => true
+   *
+   * _.isBuffer(new Uint8Array(2));
+   * // => false
+   */
+  var isBuffer = nativeIsBuffer || stubFalse;
+
+  /** `Object#toString` result references. */
+  var argsTag$1 = '[object Arguments]',
+      arrayTag$1 = '[object Array]',
+      boolTag$2 = '[object Boolean]',
+      dateTag$2 = '[object Date]',
+      errorTag$1 = '[object Error]',
+      funcTag$1 = '[object Function]',
+      mapTag$4 = '[object Map]',
+      numberTag$2 = '[object Number]',
+      objectTag$3 = '[object Object]',
+      regexpTag$2 = '[object RegExp]',
+      setTag$4 = '[object Set]',
+      stringTag$2 = '[object String]',
+      weakMapTag$2 = '[object WeakMap]';
+
+  var arrayBufferTag$2 = '[object ArrayBuffer]',
+      dataViewTag$3 = '[object DataView]',
+      float32Tag$2 = '[object Float32Array]',
+      float64Tag$2 = '[object Float64Array]',
+      int8Tag$2 = '[object Int8Array]',
+      int16Tag$2 = '[object Int16Array]',
+      int32Tag$2 = '[object Int32Array]',
+      uint8Tag$2 = '[object Uint8Array]',
+      uint8ClampedTag$2 = '[object Uint8ClampedArray]',
+      uint16Tag$2 = '[object Uint16Array]',
+      uint32Tag$2 = '[object Uint32Array]';
+
+  /** Used to identify `toStringTag` values of typed arrays. */
+  var typedArrayTags = {};
+  typedArrayTags[float32Tag$2] = typedArrayTags[float64Tag$2] =
+  typedArrayTags[int8Tag$2] = typedArrayTags[int16Tag$2] =
+  typedArrayTags[int32Tag$2] = typedArrayTags[uint8Tag$2] =
+  typedArrayTags[uint8ClampedTag$2] = typedArrayTags[uint16Tag$2] =
+  typedArrayTags[uint32Tag$2] = true;
+  typedArrayTags[argsTag$1] = typedArrayTags[arrayTag$1] =
+  typedArrayTags[arrayBufferTag$2] = typedArrayTags[boolTag$2] =
+  typedArrayTags[dataViewTag$3] = typedArrayTags[dateTag$2] =
+  typedArrayTags[errorTag$1] = typedArrayTags[funcTag$1] =
+  typedArrayTags[mapTag$4] = typedArrayTags[numberTag$2] =
+  typedArrayTags[objectTag$3] = typedArrayTags[regexpTag$2] =
+  typedArrayTags[setTag$4] = typedArrayTags[stringTag$2] =
+  typedArrayTags[weakMapTag$2] = false;
+
+  /**
+   * The base implementation of `_.isTypedArray` without Node.js optimizations.
+   *
+   * @private
+   * @param {*} value The value to check.
+   * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.
+   */
+  function baseIsTypedArray(value) {
+    return isObjectLike(value) &&
+      isLength(value.length) && !!typedArrayTags[baseGetTag(value)];
+  }
+
+  /**
+   * The base implementation of `_.unary` without support for storing metadata.
+   *
+   * @private
+   * @param {Function} func The function to cap arguments for.
+   * @returns {Function} Returns the new capped function.
+   */
+  function baseUnary(func) {
+    return function(value) {
+      return func(value);
+    };
+  }
+
+  /** Detect free variable `exports`. */
+  var freeExports$1 = typeof exports == 'object' && exports && !exports.nodeType && exports;
+
+  /** Detect free variable `module`. */
+  var freeModule$1 = freeExports$1 && typeof module == 'object' && module && !module.nodeType && module;
+
+  /** Detect the popular CommonJS extension `module.exports`. */
+  var moduleExports$1 = freeModule$1 && freeModule$1.exports === freeExports$1;
+
+  /** Detect free variable `process` from Node.js. */
+  var freeProcess = moduleExports$1 && freeGlobal.process;
+
+  /** Used to access faster Node.js helpers. */
+  var nodeUtil = (function() {
+    try {
+      // Use `util.types` for Node.js 10+.
+      var types = freeModule$1 && freeModule$1.require && freeModule$1.require('util').types;
+
+      if (types) {
+        return types;
+      }
+
+      // Legacy `process.binding('util')` for Node.js < 10.
+      return freeProcess && freeProcess.binding && freeProcess.binding('util');
+    } catch (e) {}
+  }());
+
+  /* Node.js helper references. */
+  var nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;
+
+  /**
+   * Checks if `value` is classified as a typed array.
+   *
+   * @static
+   * @memberOf _
+   * @since 3.0.0
+   * @category Lang
+   * @param {*} value The value to check.
+   * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.
+   * @example
+   *
+   * _.isTypedArray(new Uint8Array);
+   * // => true
+   *
+   * _.isTypedArray([]);
+   * // => false
+   */
+  var isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;
+
+  /**
+   * Creates an array of the enumerable property names of the array-like `value`.
+   *
+   * @private
+   * @param {*} value The value to query.
+   * @param {boolean} inherited Specify returning inherited property names.
+   * @returns {Array} Returns the array of property names.
+   */
+  function arrayLikeKeys(value, inherited) {
+    var isArr = isArray(value),
+        isArg = !isArr && isArguments(value),
+        isBuff = !isArr && !isArg && isBuffer(value),
+        isType = !isArr && !isArg && !isBuff && isTypedArray(value),
+        skipIndexes = isArr || isArg || isBuff || isType,
+        result = skipIndexes ? baseTimes(value.length, String) : [],
+        length = result.length;
+
+    for (var key in value) {
+      if (!(skipIndexes && (
+             // Safari 9 has enumerable `arguments.length` in strict mode.
+             key == 'length' ||
+             // Node.js 0.10 has enumerable non-index properties on buffers.
+             (isBuff && (key == 'offset' || key == 'parent')) ||
+             // PhantomJS 2 has enumerable non-index properties on typed arrays.
+             (isType && (key == 'buffer' || key == 'byteLength' || key == 'byteOffset')) ||
+             // Skip index properties.
+             isIndex(key, length)
+          ))) {
+        result.push(key);
+      }
+    }
+    return result;
+  }
+
+  /**
+   * Creates a unary function that invokes `func` with its argument transformed.
+   *
+   * @private
+   * @param {Function} func The function to wrap.
+   * @param {Function} transform The argument transform.
+   * @returns {Function} Returns the new function.
+   */
+  function overArg(func, transform) {
+    return function(arg) {
+      return func(transform(arg));
+    };
+  }
+
+  /**
+   * This function is like
+   * [`Object.keys`](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)
+   * except that it includes inherited enumerable properties.
+   *
+   * @private
+   * @param {Object} object The object to query.
+   * @returns {Array} Returns the array of property names.
+   */
+  function nativeKeysIn(object) {
+    var result = [];
+    if (object != null) {
+      for (var key in Object(object)) {
+        result.push(key);
+      }
+    }
+    return result;
+  }
+
+  /** Used for built-in method references. */
+  var objectProto$6 = Object.prototype;
+
+  /** Used to check objects for own properties. */
+  var hasOwnProperty$5 = objectProto$6.hasOwnProperty;
+
+  /**
+   * The base implementation of `_.keysIn` which doesn't treat sparse arrays as dense.
+   *
+   * @private
+   * @param {Object} object The object to query.
+   * @returns {Array} Returns the array of property names.
+   */
+  function baseKeysIn(object) {
+    if (!isObject(object)) {
+      return nativeKeysIn(object);
+    }
+    var isProto = isPrototype(object),
+        result = [];
+
+    for (var key in object) {
+      if (!(key == 'constructor' && (isProto || !hasOwnProperty$5.call(object, key)))) {
+        result.push(key);
+      }
+    }
+    return result;
+  }
+
+  /**
+   * Creates an array of the own and inherited enumerable property names of `object`.
+   *
+   * **Note:** Non-object values are coerced to objects.
+   *
+   * @static
+   * @memberOf _
+   * @since 3.0.0
+   * @category Object
+   * @param {Object} object The object to query.
+   * @returns {Array} Returns the array of property names.
+   * @example
+   *
+   * function Foo() {
+   *   this.a = 1;
+   *   this.b = 2;
+   * }
+   *
+   * Foo.prototype.c = 3;
+   *
+   * _.keysIn(new Foo);
+   * // => ['a', 'b', 'c'] (iteration order is not guaranteed)
+   */
+  function keysIn(object) {
+    return isArrayLike(object) ? arrayLikeKeys(object) : baseKeysIn(object);
+  }
+
+  /** 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(value, object) {
+    if (isArray(value)) {
+      return false;
+    }
+    var type = typeof value;
+    if (type == 'number' || type == 'symbol' || type == 'boolean' ||
+        value == null || isSymbol(value)) {
+      return true;
+    }
+    return reIsPlainProp.test(value) || !reIsDeepProp.test(value) ||
+      (object != null && value in Object(object));
+  }
+
+  /* Built-in method references that are verified to be native. */
+  var nativeCreate = getNative(Object, 'create');
+
+  /**
+   * Removes all key-value entries from the hash.
+   *
+   * @private
+   * @name clear
+   * @memberOf Hash
+   */
+  function hashClear() {
+    this.__data__ = nativeCreate ? nativeCreate(null) : {};
+    this.size = 0;
+  }
+
+  /**
+   * Removes `key` and its value from the hash.
+   *
+   * @private
+   * @name delete
+   * @memberOf Hash
+   * @param {Object} hash The hash to modify.
+   * @param {string} key The key of the value to remove.
+   * @returns {boolean} Returns `true` if the entry was removed, else `false`.
+   */
+  function hashDelete(key) {
+    var result = this.has(key) && delete this.__data__[key];
+    this.size -= result ? 1 : 0;
+    return result;
+  }
+
+  /** Used to stand-in for `undefined` hash values. */
+  var HASH_UNDEFINED$1 = '__lodash_hash_undefined__';
+
+  /** Used for built-in method references. */
+  var objectProto$5 = Object.prototype;
+
+  /** Used to check objects for own properties. */
+  var hasOwnProperty$4 = objectProto$5.hasOwnProperty;
+
+  /**
+   * Gets the hash value for `key`.
+   *
+   * @private
+   * @name get
+   * @memberOf Hash
+   * @param {string} key The key of the value to get.
+   * @returns {*} Returns the entry value.
+   */
+  function hashGet(key) {
+    var data = this.__data__;
+    if (nativeCreate) {
+      var result = data[key];
+      return result === HASH_UNDEFINED$1 ? undefined : result;
+    }
+    return hasOwnProperty$4.call(data, key) ? data[key] : undefined;
+  }
+
+  /** Used for built-in method references. */
+  var objectProto$4 = Object.prototype;
+
+  /** Used to check objects for own properties. */
+  var hasOwnProperty$3 = objectProto$4.hasOwnProperty;
+
+  /**
+   * Checks if a hash value for `key` exists.
+   *
+   * @private
+   * @name has
+   * @memberOf Hash
+   * @param {string} key The key of the entry to check.
+   * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
+   */
+  function hashHas(key) {
+    var data = this.__data__;
+    return nativeCreate ? (data[key] !== undefined) : hasOwnProperty$3.call(data, key);
+  }
+
+  /** Used to stand-in for `undefined` hash values. */
+  var HASH_UNDEFINED = '__lodash_hash_undefined__';
+
+  /**
+   * Sets the hash `key` to `value`.
+   *
+   * @private
+   * @name set
+   * @memberOf Hash
+   * @param {string} key The key of the value to set.
+   * @param {*} value The value to set.
+   * @returns {Object} Returns the hash instance.
+   */
+  function hashSet(key, value) {
+    var data = this.__data__;
+    this.size += this.has(key) ? 0 : 1;
+    data[key] = (nativeCreate && value === undefined) ? HASH_UNDEFINED : value;
+    return this;
+  }
+
+  /**
+   * Creates a hash object.
+   *
+   * @private
+   * @constructor
+   * @param {Array} [entries] The key-value pairs to cache.
+   */
+  function Hash(entries) {
+    var index = -1,
+        length = entries == null ? 0 : entries.length;
+
+    this.clear();
+    while (++index < length) {
+      var entry = entries[index];
+      this.set(entry[0], entry[1]);
+    }
+  }
+
+  // Add methods to `Hash`.
+  Hash.prototype.clear = hashClear;
+  Hash.prototype['delete'] = hashDelete;
+  Hash.prototype.get = hashGet;
+  Hash.prototype.has = hashHas;
+  Hash.prototype.set = hashSet;
+
+  /**
+   * Removes all key-value entries from the list cache.
+   *
+   * @private
+   * @name clear
+   * @memberOf ListCache
+   */
+  function listCacheClear() {
+    this.__data__ = [];
+    this.size = 0;
+  }
+
+  /**
+   * Gets the index at which the `key` is found in `array` of key-value pairs.
+   *
+   * @private
+   * @param {Array} array The array to inspect.
+   * @param {*} key The key to search for.
+   * @returns {number} Returns the index of the matched value, else `-1`.
+   */
+  function assocIndexOf(array, key) {
+    var length = array.length;
+    while (length--) {
+      if (eq(array[length][0], key)) {
+        return length;
+      }
+    }
+    return -1;
+  }
+
+  /** Used for built-in method references. */
+  var arrayProto = Array.prototype;
+
+  /** Built-in value references. */
+  var splice = arrayProto.splice;
+
+  /**
+   * Removes `key` and its value from the list cache.
+   *
+   * @private
+   * @name delete
+   * @memberOf ListCache
+   * @param {string} key The key of the value to remove.
+   * @returns {boolean} Returns `true` if the entry was removed, else `false`.
+   */
+  function listCacheDelete(key) {
+    var data = this.__data__,
+        index = assocIndexOf(data, key);
+
+    if (index < 0) {
+      return false;
+    }
+    var lastIndex = data.length - 1;
+    if (index == lastIndex) {
+      data.pop();
+    } else {
+      splice.call(data, index, 1);
+    }
+    --this.size;
+    return true;
+  }
+
+  /**
+   * Gets the list cache value for `key`.
+   *
+   * @private
+   * @name get
+   * @memberOf ListCache
+   * @param {string} key The key of the value to get.
+   * @returns {*} Returns the entry value.
+   */
+  function listCacheGet(key) {
+    var data = this.__data__,
+        index = assocIndexOf(data, key);
+
+    return index < 0 ? undefined : data[index][1];
+  }
+
+  /**
+   * Checks if a list cache value for `key` exists.
+   *
+   * @private
+   * @name has
+   * @memberOf ListCache
+   * @param {string} key The key of the entry to check.
+   * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
+   */
+  function listCacheHas(key) {
+    return assocIndexOf(this.__data__, key) > -1;
+  }
+
+  /**
+   * Sets the list cache `key` to `value`.
+   *
+   * @private
+   * @name set
+   * @memberOf ListCache
+   * @param {string} key The key of the value to set.
+   * @param {*} value The value to set.
+   * @returns {Object} Returns the list cache instance.
+   */
+  function listCacheSet(key, value) {
+    var data = this.__data__,
+        index = assocIndexOf(data, key);
+
+    if (index < 0) {
+      ++this.size;
+      data.push([key, value]);
+    } else {
+      data[index][1] = value;
+    }
+    return this;
+  }
+
+  /**
+   * Creates an list cache object.
+   *
+   * @private
+   * @constructor
+   * @param {Array} [entries] The key-value pairs to cache.
+   */
+  function ListCache(entries) {
+    var index = -1,
+        length = entries == null ? 0 : entries.length;
+
+    this.clear();
+    while (++index < length) {
+      var entry = entries[index];
+      this.set(entry[0], entry[1]);
+    }
+  }
+
+  // Add methods to `ListCache`.
+  ListCache.prototype.clear = listCacheClear;
+  ListCache.prototype['delete'] = listCacheDelete;
+  ListCache.prototype.get = listCacheGet;
+  ListCache.prototype.has = listCacheHas;
+  ListCache.prototype.set = listCacheSet;
+
+  /* Built-in method references that are verified to be native. */
+  var Map = getNative(root, 'Map');
+
+  /**
+   * Removes all key-value entries from the map.
+   *
+   * @private
+   * @name clear
+   * @memberOf MapCache
+   */
+  function mapCacheClear() {
+    this.size = 0;
+    this.__data__ = {
+      'hash': new Hash,
+      'map': new (Map || ListCache),
+      'string': new Hash
+    };
+  }
+
+  /**
+   * Checks if `value` is suitable for use as unique object key.
+   *
+   * @private
+   * @param {*} value The value to check.
+   * @returns {boolean} Returns `true` if `value` is suitable, else `false`.
+   */
+  function isKeyable(value) {
+    var type = typeof value;
+    return (type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean')
+      ? (value !== '__proto__')
+      : (value === null);
+  }
+
+  /**
+   * Gets the data for `map`.
+   *
+   * @private
+   * @param {Object} map The map to query.
+   * @param {string} key The reference key.
+   * @returns {*} Returns the map data.
+   */
+  function getMapData(map, key) {
+    var data = map.__data__;
+    return isKeyable(key)
+      ? data[typeof key == 'string' ? 'string' : 'hash']
+      : data.map;
+  }
+
+  /**
+   * Removes `key` and its value from the map.
+   *
+   * @private
+   * @name delete
+   * @memberOf MapCache
+   * @param {string} key The key of the value to remove.
+   * @returns {boolean} Returns `true` if the entry was removed, else `false`.
+   */
+  function mapCacheDelete(key) {
+    var result = getMapData(this, key)['delete'](key);
+    this.size -= result ? 1 : 0;
+    return result;
+  }
+
+  /**
+   * Gets the map value for `key`.
+   *
+   * @private
+   * @name get
+   * @memberOf MapCache
+   * @param {string} key The key of the value to get.
+   * @returns {*} Returns the entry value.
+   */
+  function mapCacheGet(key) {
+    return getMapData(this, key).get(key);
+  }
+
+  /**
+   * Checks if a map value for `key` exists.
+   *
+   * @private
+   * @name has
+   * @memberOf MapCache
+   * @param {string} key The key of the entry to check.
+   * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
+   */
+  function mapCacheHas(key) {
+    return getMapData(this, key).has(key);
+  }
+
+  /**
+   * Sets the map `key` to `value`.
+   *
+   * @private
+   * @name set
+   * @memberOf MapCache
+   * @param {string} key The key of the value to set.
+   * @param {*} value The value to set.
+   * @returns {Object} Returns the map cache instance.
+   */
+  function mapCacheSet(key, value) {
+    var data = getMapData(this, key),
+        size = data.size;
+
+    data.set(key, value);
+    this.size += data.size == size ? 0 : 1;
+    return this;
+  }
+
+  /**
+   * Creates a map cache object to store key-value pairs.
+   *
+   * @private
+   * @constructor
+   * @param {Array} [entries] The key-value pairs to cache.
+   */
+  function MapCache(entries) {
+    var index = -1,
+        length = entries == null ? 0 : entries.length;
+
+    this.clear();
+    while (++index < length) {
+      var entry = entries[index];
+      this.set(entry[0], entry[1]);
+    }
+  }
+
+  // Add methods to `MapCache`.
+  MapCache.prototype.clear = mapCacheClear;
+  MapCache.prototype['delete'] = mapCacheDelete;
+  MapCache.prototype.get = mapCacheGet;
+  MapCache.prototype.has = mapCacheHas;
+  MapCache.prototype.set = mapCacheSet;
+
+  /** 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;
+
+  /** 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(func) {
+    var result = memoize(func, function(key) {
+      if (cache.size === MAX_MEMOIZE_SIZE) {
+        cache.clear();
+      }
+      return key;
+    });
+
+    var cache = result.cache;
+    return result;
+  }
+
+  /** 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 = 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;
+  });
+
+  /**
+   * 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(value) {
+    return value == null ? '' : baseToString(value);
+  }
+
+  /**
+   * 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(value, object) {
+    if (isArray(value)) {
+      return value;
+    }
+    return isKey(value, object) ? [value] : stringToPath(toString(value));
+  }
+
+  /**
+   * 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(value) {
+    if (typeof value == 'string' || isSymbol(value)) {
+      return value;
+    }
+    var result = (value + '');
+    return (result == '0' && (1 / value) == -Infinity) ? '-0' : result;
+  }
+
+  /**
+   * 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(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;
+  }
+
+  /**
+   * Appends the elements of `values` to `array`.
+   *
+   * @private
+   * @param {Array} array The array to modify.
+   * @param {Array} values The values to append.
+   * @returns {Array} Returns `array`.
+   */
+  function arrayPush(array, values) {
+    var index = -1,
+        length = values.length,
+        offset = array.length;
+
+    while (++index < length) {
+      array[offset + index] = values[index];
+    }
+    return array;
+  }
+
+  /** Built-in value references. */
+  var spreadableSymbol = Symbol$1 ? Symbol$1.isConcatSpreadable : undefined;
+
+  /**
+   * Checks if `value` is a flattenable `arguments` object or array.
+   *
+   * @private
+   * @param {*} value The value to check.
+   * @returns {boolean} Returns `true` if `value` is flattenable, else `false`.
+   */
+  function isFlattenable(value) {
+    return isArray(value) || isArguments(value) ||
+      !!(spreadableSymbol && value && value[spreadableSymbol]);
+  }
+
+  /**
+   * The base implementation of `_.flatten` with support for restricting flattening.
+   *
+   * @private
+   * @param {Array} array The array to flatten.
+   * @param {number} depth The maximum recursion depth.
+   * @param {boolean} [predicate=isFlattenable] The function invoked per iteration.
+   * @param {boolean} [isStrict] Restrict to values that pass `predicate` checks.
+   * @param {Array} [result=[]] The initial result value.
+   * @returns {Array} Returns the new flattened array.
+   */
+  function baseFlatten(array, depth, predicate, isStrict, result) {
+    var index = -1,
+        length = array.length;
+
+    predicate || (predicate = isFlattenable);
+    result || (result = []);
+
+    while (++index < length) {
+      var value = array[index];
+      if (predicate(value)) {
+        {
+          arrayPush(result, value);
+        }
+      } else {
+        result[result.length] = value;
+      }
+    }
+    return result;
+  }
+
+  /**
+   * Flattens `array` a single level deep.
+   *
+   * @static
+   * @memberOf _
+   * @since 0.1.0
+   * @category Array
+   * @param {Array} array The array to flatten.
+   * @returns {Array} Returns the new flattened array.
+   * @example
+   *
+   * _.flatten([1, [2, [3, [4]], 5]]);
+   * // => [1, 2, [3, [4]], 5]
+   */
+  function flatten(array) {
+    var length = array == null ? 0 : array.length;
+    return length ? baseFlatten(array) : [];
+  }
+
+  /**
+   * A specialized version of `baseRest` which flattens the rest array.
+   *
+   * @private
+   * @param {Function} func The function to apply a rest parameter to.
+   * @returns {Function} Returns the new function.
+   */
+  function flatRest(func) {
+    return setToString(overRest(func, undefined, flatten), func + '');
+  }
+
+  /** Built-in value references. */
+  var getPrototype = overArg(Object.getPrototypeOf, Object);
+
+  /** `Object#toString` result references. */
+  var objectTag$2 = '[object Object]';
+
+  /** Used for built-in method references. */
+  var funcProto = Function.prototype,
+      objectProto$3 = Object.prototype;
+
+  /** Used to resolve the decompiled source of functions. */
+  var funcToString = funcProto.toString;
+
+  /** Used to check objects for own properties. */
+  var hasOwnProperty$2 = objectProto$3.hasOwnProperty;
+
+  /** Used to infer the `Object` constructor. */
+  var objectCtorString = funcToString.call(Object);
+
+  /**
+   * Checks if `value` is a plain object, that is, an object created by the
+   * `Object` constructor or one with a `[[Prototype]]` of `null`.
+   *
+   * @static
+   * @memberOf _
+   * @since 0.8.0
+   * @category Lang
+   * @param {*} value The value to check.
+   * @returns {boolean} Returns `true` if `value` is a plain object, else `false`.
+   * @example
+   *
+   * function Foo() {
+   *   this.a = 1;
+   * }
+   *
+   * _.isPlainObject(new Foo);
+   * // => false
+   *
+   * _.isPlainObject([1, 2, 3]);
+   * // => false
+   *
+   * _.isPlainObject({ 'x': 0, 'y': 0 });
+   * // => true
+   *
+   * _.isPlainObject(Object.create(null));
+   * // => true
+   */
+  function isPlainObject(value) {
+    if (!isObjectLike(value) || baseGetTag(value) != objectTag$2) {
+      return false;
+    }
+    var proto = getPrototype(value);
+    if (proto === null) {
+      return true;
+    }
+    var Ctor = hasOwnProperty$2.call(proto, 'constructor') && proto.constructor;
+    return typeof Ctor == 'function' && Ctor instanceof Ctor &&
+      funcToString.call(Ctor) == objectCtorString;
+  }
+
+  /**
+   * The base implementation of `_.slice` without an iteratee call guard.
+   *
+   * @private
+   * @param {Array} array The array to slice.
+   * @param {number} [start=0] The start position.
+   * @param {number} [end=array.length] The end position.
+   * @returns {Array} Returns the slice of `array`.
+   */
+  function baseSlice(array, start, end) {
+    var index = -1,
+        length = array.length;
+
+    if (start < 0) {
+      start = -start > length ? 0 : (length + start);
+    }
+    end = end > length ? length : end;
+    if (end < 0) {
+      end += length;
+    }
+    length = start > end ? 0 : ((end - start) >>> 0);
+    start >>>= 0;
+
+    var result = Array(length);
+    while (++index < length) {
+      result[index] = array[index + start];
+    }
+    return result;
+  }
+
+  /**
+   * Removes all key-value entries from the stack.
+   *
+   * @private
+   * @name clear
+   * @memberOf Stack
+   */
+  function stackClear() {
+    this.__data__ = new ListCache;
+    this.size = 0;
+  }
+
+  /**
+   * Removes `key` and its value from the stack.
+   *
+   * @private
+   * @name delete
+   * @memberOf Stack
+   * @param {string} key The key of the value to remove.
+   * @returns {boolean} Returns `true` if the entry was removed, else `false`.
+   */
+  function stackDelete(key) {
+    var data = this.__data__,
+        result = data['delete'](key);
+
+    this.size = data.size;
+    return result;
+  }
+
+  /**
+   * Gets the stack value for `key`.
+   *
+   * @private
+   * @name get
+   * @memberOf Stack
+   * @param {string} key The key of the value to get.
+   * @returns {*} Returns the entry value.
+   */
+  function stackGet(key) {
+    return this.__data__.get(key);
+  }
+
+  /**
+   * Checks if a stack value for `key` exists.
+   *
+   * @private
+   * @name has
+   * @memberOf Stack
+   * @param {string} key The key of the entry to check.
+   * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.
+   */
+  function stackHas(key) {
+    return this.__data__.has(key);
+  }
+
+  /** Used as the size to enable large array optimizations. */
+  var LARGE_ARRAY_SIZE = 200;
+
+  /**
+   * Sets the stack `key` to `value`.
+   *
+   * @private
+   * @name set
+   * @memberOf Stack
+   * @param {string} key The key of the value to set.
+   * @param {*} value The value to set.
+   * @returns {Object} Returns the stack cache instance.
+   */
+  function stackSet(key, value) {
+    var data = this.__data__;
+    if (data instanceof ListCache) {
+      var pairs = data.__data__;
+      if (!Map || (pairs.length < LARGE_ARRAY_SIZE - 1)) {
+        pairs.push([key, value]);
+        this.size = ++data.size;
+        return this;
+      }
+      data = this.__data__ = new MapCache(pairs);
+    }
+    data.set(key, value);
+    this.size = data.size;
+    return this;
+  }
+
+  /**
+   * Creates a stack cache object to store key-value pairs.
+   *
+   * @private
+   * @constructor
+   * @param {Array} [entries] The key-value pairs to cache.
+   */
+  function Stack(entries) {
+    var data = this.__data__ = new ListCache(entries);
+    this.size = data.size;
+  }
+
+  // Add methods to `Stack`.
+  Stack.prototype.clear = stackClear;
+  Stack.prototype['delete'] = stackDelete;
+  Stack.prototype.get = stackGet;
+  Stack.prototype.has = stackHas;
+  Stack.prototype.set = stackSet;
+
+  /** Detect free variable `exports`. */
+  var freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;
+
+  /** Detect free variable `module`. */
+  var freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;
+
+  /** Detect the popular CommonJS extension `module.exports`. */
+  var moduleExports = freeModule && freeModule.exports === freeExports;
+
+  /** Built-in value references. */
+  var Buffer = moduleExports ? root.Buffer : undefined;
+      Buffer ? Buffer.allocUnsafe : undefined;
+
+  /**
+   * Creates a clone of  `buffer`.
+   *
+   * @private
+   * @param {Buffer} buffer The buffer to clone.
+   * @param {boolean} [isDeep] Specify a deep clone.
+   * @returns {Buffer} Returns the cloned buffer.
+   */
+  function cloneBuffer(buffer, isDeep) {
+    {
+      return buffer.slice();
+    }
+  }
+
+  /**
+   * A specialized version of `_.filter` for arrays without support for
+   * iteratee shorthands.
+   *
+   * @private
+   * @param {Array} [array] The array to iterate over.
+   * @param {Function} predicate The function invoked per iteration.
+   * @returns {Array} Returns the new filtered array.
+   */
+  function arrayFilter(array, predicate) {
+    var index = -1,
+        length = array == null ? 0 : array.length,
+        resIndex = 0,
+        result = [];
+
+    while (++index < length) {
+      var value = array[index];
+      if (predicate(value, index, array)) {
+        result[resIndex++] = value;
+      }
+    }
+    return result;
+  }
+
+  /**
+   * This method returns a new empty array.
+   *
+   * @static
+   * @memberOf _
+   * @since 4.13.0
+   * @category Util
+   * @returns {Array} Returns the new empty array.
+   * @example
+   *
+   * var arrays = _.times(2, _.stubArray);
+   *
+   * console.log(arrays);
+   * // => [[], []]
+   *
+   * console.log(arrays[0] === arrays[1]);
+   * // => false
+   */
+  function stubArray() {
+    return [];
+  }
+
+  /** Used for built-in method references. */
+  var objectProto$2 = Object.prototype;
+
+  /** Built-in value references. */
+  var propertyIsEnumerable = objectProto$2.propertyIsEnumerable;
+
+  /* Built-in method references for those with the same name as other `lodash` methods. */
+  var nativeGetSymbols$1 = Object.getOwnPropertySymbols;
+
+  /**
+   * Creates an array of the own enumerable symbols of `object`.
+   *
+   * @private
+   * @param {Object} object The object to query.
+   * @returns {Array} Returns the array of symbols.
+   */
+  var getSymbols = !nativeGetSymbols$1 ? stubArray : function(object) {
+    if (object == null) {
+      return [];
+    }
+    object = Object(object);
+    return arrayFilter(nativeGetSymbols$1(object), function(symbol) {
+      return propertyIsEnumerable.call(object, symbol);
+    });
+  };
+
+  /* Built-in method references for those with the same name as other `lodash` methods. */
+  var nativeGetSymbols = Object.getOwnPropertySymbols;
+
+  /**
+   * Creates an array of the own and inherited enumerable symbols of `object`.
+   *
+   * @private
+   * @param {Object} object The object to query.
+   * @returns {Array} Returns the array of symbols.
+   */
+  var getSymbolsIn = !nativeGetSymbols ? stubArray : function(object) {
+    var result = [];
+    while (object) {
+      arrayPush(result, getSymbols(object));
+      object = getPrototype(object);
+    }
+    return result;
+  };
+
+  /**
+   * The base implementation of `getAllKeys` and `getAllKeysIn` which uses
+   * `keysFunc` and `symbolsFunc` to get the enumerable property names and
+   * symbols of `object`.
+   *
+   * @private
+   * @param {Object} object The object to query.
+   * @param {Function} keysFunc The function to get the keys of `object`.
+   * @param {Function} symbolsFunc The function to get the symbols of `object`.
+   * @returns {Array} Returns the array of property names and symbols.
+   */
+  function baseGetAllKeys(object, keysFunc, symbolsFunc) {
+    var result = keysFunc(object);
+    return isArray(object) ? result : arrayPush(result, symbolsFunc(object));
+  }
+
+  /**
+   * Creates an array of own and inherited enumerable property names and
+   * symbols of `object`.
+   *
+   * @private
+   * @param {Object} object The object to query.
+   * @returns {Array} Returns the array of property names and symbols.
+   */
+  function getAllKeysIn(object) {
+    return baseGetAllKeys(object, keysIn, getSymbolsIn);
+  }
+
+  /* Built-in method references that are verified to be native. */
+  var DataView = getNative(root, 'DataView');
+
+  /* Built-in method references that are verified to be native. */
+  var Promise$1 = getNative(root, 'Promise');
+
+  /* Built-in method references that are verified to be native. */
+  var Set = getNative(root, 'Set');
+
+  /** `Object#toString` result references. */
+  var mapTag$3 = '[object Map]',
+      objectTag$1 = '[object Object]',
+      promiseTag = '[object Promise]',
+      setTag$3 = '[object Set]',
+      weakMapTag$1 = '[object WeakMap]';
+
+  var dataViewTag$2 = '[object DataView]';
+
+  /** Used to detect maps, sets, and weakmaps. */
+  var dataViewCtorString = toSource(DataView),
+      mapCtorString = toSource(Map),
+      promiseCtorString = toSource(Promise$1),
+      setCtorString = toSource(Set),
+      weakMapCtorString = toSource(WeakMap);
+
+  /**
+   * Gets the `toStringTag` of `value`.
+   *
+   * @private
+   * @param {*} value The value to query.
+   * @returns {string} Returns the `toStringTag`.
+   */
+  var getTag = baseGetTag;
+
+  // Fallback for data views, maps, sets, and weak maps in IE 11 and promises in Node.js < 6.
+  if ((DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag$2) ||
+      (Map && getTag(new Map) != mapTag$3) ||
+      (Promise$1 && getTag(Promise$1.resolve()) != promiseTag) ||
+      (Set && getTag(new Set) != setTag$3) ||
+      (WeakMap && getTag(new WeakMap) != weakMapTag$1)) {
+    getTag = function(value) {
+      var result = baseGetTag(value),
+          Ctor = result == objectTag$1 ? value.constructor : undefined,
+          ctorString = Ctor ? toSource(Ctor) : '';
+
+      if (ctorString) {
+        switch (ctorString) {
+          case dataViewCtorString: return dataViewTag$2;
+          case mapCtorString: return mapTag$3;
+          case promiseCtorString: return promiseTag;
+          case setCtorString: return setTag$3;
+          case weakMapCtorString: return weakMapTag$1;
+        }
+      }
+      return result;
+    };
+  }
+
+  /** Used for built-in method references. */
+  var objectProto$1 = Object.prototype;
+
+  /** Used to check objects for own properties. */
+  var hasOwnProperty$1 = objectProto$1.hasOwnProperty;
+
+  /**
+   * Initializes an array clone.
+   *
+   * @private
+   * @param {Array} array The array to clone.
+   * @returns {Array} Returns the initialized clone.
+   */
+  function initCloneArray(array) {
+    var length = array.length,
+        result = new array.constructor(length);
+
+    // Add properties assigned by `RegExp#exec`.
+    if (length && typeof array[0] == 'string' && hasOwnProperty$1.call(array, 'index')) {
+      result.index = array.index;
+      result.input = array.input;
+    }
+    return result;
+  }
+
+  /** Built-in value references. */
+  var Uint8Array = root.Uint8Array;
+
+  /**
+   * Creates a clone of `arrayBuffer`.
+   *
+   * @private
+   * @param {ArrayBuffer} arrayBuffer The array buffer to clone.
+   * @returns {ArrayBuffer} Returns the cloned array buffer.
+   */
+  function cloneArrayBuffer(arrayBuffer) {
+    var result = new arrayBuffer.constructor(arrayBuffer.byteLength);
+    new Uint8Array(result).set(new Uint8Array(arrayBuffer));
+    return result;
+  }
+
+  /**
+   * Creates a clone of `dataView`.
+   *
+   * @private
+   * @param {Object} dataView The data view to clone.
+   * @param {boolean} [isDeep] Specify a deep clone.
+   * @returns {Object} Returns the cloned data view.
+   */
+  function cloneDataView(dataView, isDeep) {
+    var buffer = cloneArrayBuffer(dataView.buffer) ;
+    return new dataView.constructor(buffer, dataView.byteOffset, dataView.byteLength);
+  }
+
+  /** Used to match `RegExp` flags from their coerced string values. */
+  var reFlags = /\w*$/;
+
+  /**
+   * Creates a clone of `regexp`.
+   *
+   * @private
+   * @param {Object} regexp The regexp to clone.
+   * @returns {Object} Returns the cloned regexp.
+   */
+  function cloneRegExp(regexp) {
+    var result = new regexp.constructor(regexp.source, reFlags.exec(regexp));
+    result.lastIndex = regexp.lastIndex;
+    return result;
+  }
+
+  /** Used to convert symbols to primitives and strings. */
+  var symbolProto = Symbol$1 ? Symbol$1.prototype : undefined,
+      symbolValueOf = symbolProto ? symbolProto.valueOf : undefined;
+
+  /**
+   * Creates a clone of the `symbol` object.
+   *
+   * @private
+   * @param {Object} symbol The symbol object to clone.
+   * @returns {Object} Returns the cloned symbol object.
+   */
+  function cloneSymbol(symbol) {
+    return symbolValueOf ? Object(symbolValueOf.call(symbol)) : {};
+  }
+
+  /**
+   * Creates a clone of `typedArray`.
+   *
+   * @private
+   * @param {Object} typedArray The typed array to clone.
+   * @param {boolean} [isDeep] Specify a deep clone.
+   * @returns {Object} Returns the cloned typed array.
+   */
+  function cloneTypedArray(typedArray, isDeep) {
+    var buffer = cloneArrayBuffer(typedArray.buffer) ;
+    return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length);
+  }
+
+  /** `Object#toString` result references. */
+  var boolTag$1 = '[object Boolean]',
+      dateTag$1 = '[object Date]',
+      mapTag$2 = '[object Map]',
+      numberTag$1 = '[object Number]',
+      regexpTag$1 = '[object RegExp]',
+      setTag$2 = '[object Set]',
+      stringTag$1 = '[object String]',
+      symbolTag$1 = '[object Symbol]';
+
+  var arrayBufferTag$1 = '[object ArrayBuffer]',
+      dataViewTag$1 = '[object DataView]',
+      float32Tag$1 = '[object Float32Array]',
+      float64Tag$1 = '[object Float64Array]',
+      int8Tag$1 = '[object Int8Array]',
+      int16Tag$1 = '[object Int16Array]',
+      int32Tag$1 = '[object Int32Array]',
+      uint8Tag$1 = '[object Uint8Array]',
+      uint8ClampedTag$1 = '[object Uint8ClampedArray]',
+      uint16Tag$1 = '[object Uint16Array]',
+      uint32Tag$1 = '[object Uint32Array]';
+
+  /**
+   * Initializes an object clone based on its `toStringTag`.
+   *
+   * **Note:** This function only supports cloning values with tags of
+   * `Boolean`, `Date`, `Error`, `Map`, `Number`, `RegExp`, `Set`, or `String`.
+   *
+   * @private
+   * @param {Object} object The object to clone.
+   * @param {string} tag The `toStringTag` of the object to clone.
+   * @param {boolean} [isDeep] Specify a deep clone.
+   * @returns {Object} Returns the initialized clone.
+   */
+  function initCloneByTag(object, tag, isDeep) {
+    var Ctor = object.constructor;
+    switch (tag) {
+      case arrayBufferTag$1:
+        return cloneArrayBuffer(object);
+
+      case boolTag$1:
+      case dateTag$1:
+        return new Ctor(+object);
+
+      case dataViewTag$1:
+        return cloneDataView(object);
+
+      case float32Tag$1: case float64Tag$1:
+      case int8Tag$1: case int16Tag$1: case int32Tag$1:
+      case uint8Tag$1: case uint8ClampedTag$1: case uint16Tag$1: case uint32Tag$1:
+        return cloneTypedArray(object);
+
+      case mapTag$2:
+        return new Ctor;
+
+      case numberTag$1:
+      case stringTag$1:
+        return new Ctor(object);
+
+      case regexpTag$1:
+        return cloneRegExp(object);
+
+      case setTag$2:
+        return new Ctor;
+
+      case symbolTag$1:
+        return cloneSymbol(object);
+    }
+  }
+
+  /** `Object#toString` result references. */
+  var mapTag$1 = '[object Map]';
+
+  /**
+   * The base implementation of `_.isMap` without Node.js optimizations.
+   *
+   * @private
+   * @param {*} value The value to check.
+   * @returns {boolean} Returns `true` if `value` is a map, else `false`.
+   */
+  function baseIsMap(value) {
+    return isObjectLike(value) && getTag(value) == mapTag$1;
+  }
+
+  /* Node.js helper references. */
+  var nodeIsMap = nodeUtil && nodeUtil.isMap;
+
+  /**
+   * Checks if `value` is classified as a `Map` object.
+   *
+   * @static
+   * @memberOf _
+   * @since 4.3.0
+   * @category Lang
+   * @param {*} value The value to check.
+   * @returns {boolean} Returns `true` if `value` is a map, else `false`.
+   * @example
+   *
+   * _.isMap(new Map);
+   * // => true
+   *
+   * _.isMap(new WeakMap);
+   * // => false
+   */
+  var isMap = nodeIsMap ? baseUnary(nodeIsMap) : baseIsMap;
+
+  /** `Object#toString` result references. */
+  var setTag$1 = '[object Set]';
+
+  /**
+   * The base implementation of `_.isSet` without Node.js optimizations.
+   *
+   * @private
+   * @param {*} value The value to check.
+   * @returns {boolean} Returns `true` if `value` is a set, else `false`.
+   */
+  function baseIsSet(value) {
+    return isObjectLike(value) && getTag(value) == setTag$1;
+  }
+
+  /* Node.js helper references. */
+  var nodeIsSet = nodeUtil && nodeUtil.isSet;
+
+  /**
+   * Checks if `value` is classified as a `Set` object.
+   *
+   * @static
+   * @memberOf _
+   * @since 4.3.0
+   * @category Lang
+   * @param {*} value The value to check.
+   * @returns {boolean} Returns `true` if `value` is a set, else `false`.
+   * @example
+   *
+   * _.isSet(new Set);
+   * // => true
+   *
+   * _.isSet(new WeakSet);
+   * // => false
+   */
+  var isSet = nodeIsSet ? baseUnary(nodeIsSet) : baseIsSet;
+
+  /** `Object#toString` result references. */
+  var argsTag = '[object Arguments]',
+      arrayTag = '[object Array]',
+      boolTag = '[object Boolean]',
+      dateTag = '[object Date]',
+      errorTag = '[object Error]',
+      funcTag = '[object Function]',
+      genTag = '[object GeneratorFunction]',
+      mapTag = '[object Map]',
+      numberTag = '[object Number]',
+      objectTag = '[object Object]',
+      regexpTag = '[object RegExp]',
+      setTag = '[object Set]',
+      stringTag = '[object String]',
+      symbolTag = '[object Symbol]',
+      weakMapTag = '[object WeakMap]';
+
+  var arrayBufferTag = '[object ArrayBuffer]',
+      dataViewTag = '[object DataView]',
+      float32Tag = '[object Float32Array]',
+      float64Tag = '[object Float64Array]',
+      int8Tag = '[object Int8Array]',
+      int16Tag = '[object Int16Array]',
+      int32Tag = '[object Int32Array]',
+      uint8Tag = '[object Uint8Array]',
+      uint8ClampedTag = '[object Uint8ClampedArray]',
+      uint16Tag = '[object Uint16Array]',
+      uint32Tag = '[object Uint32Array]';
+
+  /** Used to identify `toStringTag` values supported by `_.clone`. */
+  var cloneableTags = {};
+  cloneableTags[argsTag] = cloneableTags[arrayTag] =
+  cloneableTags[arrayBufferTag] = cloneableTags[dataViewTag] =
+  cloneableTags[boolTag] = cloneableTags[dateTag] =
+  cloneableTags[float32Tag] = cloneableTags[float64Tag] =
+  cloneableTags[int8Tag] = cloneableTags[int16Tag] =
+  cloneableTags[int32Tag] = cloneableTags[mapTag] =
+  cloneableTags[numberTag] = cloneableTags[objectTag] =
+  cloneableTags[regexpTag] = cloneableTags[setTag] =
+  cloneableTags[stringTag] = cloneableTags[symbolTag] =
+  cloneableTags[uint8Tag] = cloneableTags[uint8ClampedTag] =
+  cloneableTags[uint16Tag] = cloneableTags[uint32Tag] = true;
+  cloneableTags[errorTag] = cloneableTags[funcTag] =
+  cloneableTags[weakMapTag] = false;
+
+  /**
+   * The base implementation of `_.clone` and `_.cloneDeep` which tracks
+   * traversed objects.
+   *
+   * @private
+   * @param {*} value The value to clone.
+   * @param {boolean} bitmask The bitmask flags.
+   *  1 - Deep clone
+   *  2 - Flatten inherited properties
+   *  4 - Clone symbols
+   * @param {Function} [customizer] The function to customize cloning.
+   * @param {string} [key] The key of `value`.
+   * @param {Object} [object] The parent object of `value`.
+   * @param {Object} [stack] Tracks traversed objects and their clone counterparts.
+   * @returns {*} Returns the cloned value.
+   */
+  function baseClone(value, bitmask, customizer, key, object, stack) {
+    var result;
+
+    if (customizer) {
+      result = object ? customizer(value, key, object, stack) : customizer(value);
+    }
+    if (result !== undefined) {
+      return result;
+    }
+    if (!isObject(value)) {
+      return value;
+    }
+    var isArr = isArray(value);
+    if (isArr) {
+      result = initCloneArray(value);
+    } else {
+      var tag = getTag(value),
+          isFunc = tag == funcTag || tag == genTag;
+
+      if (isBuffer(value)) {
+        return cloneBuffer(value);
+      }
+      if (tag == objectTag || tag == argsTag || (isFunc && !object)) {
+        result = {} ;
+      } else {
+        if (!cloneableTags[tag]) {
+          return object ? value : {};
+        }
+        result = initCloneByTag(value, tag);
+      }
+    }
+    // Check for circular references and return its corresponding clone.
+    stack || (stack = new Stack);
+    var stacked = stack.get(value);
+    if (stacked) {
+      return stacked;
+    }
+    stack.set(value, result);
+
+    if (isSet(value)) {
+      value.forEach(function(subValue) {
+        result.add(baseClone(subValue, bitmask, customizer, subValue, value, stack));
+      });
+    } else if (isMap(value)) {
+      value.forEach(function(subValue, key) {
+        result.set(key, baseClone(subValue, bitmask, customizer, key, value, stack));
+      });
+    }
+
+    var keysFunc = (getAllKeysIn )
+      ;
+
+    var props = isArr ? undefined : keysFunc(value);
+    arrayEach(props || value, function(subValue, key) {
+      if (props) {
+        key = subValue;
+        subValue = value[key];
+      }
+      // Recursively populate clone (susceptible to call stack limits).
+      assignValue(result, key, baseClone(subValue, bitmask, customizer, key, value, stack));
+    });
+    return result;
+  }
+
+  /**
+   * Gets the last element of `array`.
+   *
+   * @static
+   * @memberOf _
+   * @since 0.1.0
+   * @category Array
+   * @param {Array} array The array to query.
+   * @returns {*} Returns the last element of `array`.
+   * @example
+   *
+   * _.last([1, 2, 3]);
+   * // => 3
+   */
+  function last(array) {
+    var length = array == null ? 0 : array.length;
+    return length ? array[length - 1] : undefined;
+  }
+
+  /**
+   * Gets the parent value at `path` of `object`.
+   *
+   * @private
+   * @param {Object} object The object to query.
+   * @param {Array} path The path to get the parent value of.
+   * @returns {*} Returns the parent value.
+   */
+  function parent(object, path) {
+    return path.length < 2 ? object : baseGet(object, baseSlice(path, 0, -1));
+  }
+
+  /** Used for built-in method references. */
+  var objectProto = Object.prototype;
+
+  /** Used to check objects for own properties. */
+  var hasOwnProperty = objectProto.hasOwnProperty;
+
+  /**
+   * The base implementation of `_.unset`.
+   *
+   * @private
+   * @param {Object} object The object to modify.
+   * @param {Array|string} path The property path to unset.
+   * @returns {boolean} Returns `true` if the property is deleted, else `false`.
+   */
+  function baseUnset(object, path) {
+    path = castPath(path, object);
+
+    // Prevent prototype pollution, see: https://github.com/lodash/lodash/security/advisories/GHSA-xxjr-mmjv-4gpg
+    var index = -1,
+        length = path.length;
+
+    if (!length) {
+      return true;
+    }
+
+    var isRootPrimitive = object == null || (typeof object !== 'object' && typeof object !== 'function');
+
+    while (++index < length) {
+      var key = path[index];
+
+      // skip non-string keys (e.g., Symbols, numbers)
+      if (typeof key !== 'string') {
+        continue;
+      }
+
+      // Always block "__proto__" anywhere in the path if it's not expected
+      if (key === '__proto__' && !hasOwnProperty.call(object, '__proto__')) {
+        return false;
+      }
+
+      // Block "constructor.prototype" chains
+      if (key === 'constructor' &&
+          (index + 1) < length &&
+          typeof path[index + 1] === 'string' &&
+          path[index + 1] === 'prototype') {
+
+        // Allow ONLY when the path starts at a primitive root, e.g., _.unset(0, 'constructor.prototype.a')
+        if (isRootPrimitive && index === 0) {
+          continue;
+        }
+
+        return false;
+      }
+    }
+
+    var obj = parent(object, path);
+    return obj == null || delete obj[toKey(last(path))];
+  }
+
+  /**
+   * Used by `_.omit` to customize its `_.cloneDeep` use to only clone plain
+   * objects.
+   *
+   * @private
+   * @param {*} value The value to inspect.
+   * @param {string} key The key of the property to inspect.
+   * @returns {*} Returns the uncloned value or `undefined` to defer cloning to `_.cloneDeep`.
+   */
+  function customOmitClone(value) {
+    return isPlainObject(value) ? undefined : value;
+  }
+
+  /** Used to compose bitmasks for cloning. */
+  var CLONE_DEEP_FLAG = 1,
+      CLONE_FLAT_FLAG = 2,
+      CLONE_SYMBOLS_FLAG = 4;
+
+  /**
+   * The opposite of `_.pick`; this method creates an object composed of the
+   * own and inherited enumerable property paths of `object` that are not omitted.
+   *
+   * **Note:** This method is considerably slower than `_.pick`.
+   *
+   * @static
+   * @since 0.1.0
+   * @memberOf _
+   * @category Object
+   * @param {Object} object The source object.
+   * @param {...(string|string[])} [paths] The property paths to omit.
+   * @returns {Object} Returns the new object.
+   * @example
+   *
+   * var object = { 'a': 1, 'b': '2', 'c': 3 };
+   *
+   * _.omit(object, ['a', 'c']);
+   * // => { 'b': '2' }
+   */
+  var omit = flatRest(function(object, paths) {
+    var result = {};
+    if (object == null) {
+      return result;
+    }
+    var isDeep = false;
+    paths = arrayMap(paths, function(path) {
+      path = castPath(path, object);
+      isDeep || (isDeep = path.length > 1);
+      return path;
+    });
+    copyObject(object, getAllKeysIn(object), result);
+    if (isDeep) {
+      result = baseClone(result, CLONE_DEEP_FLAG | CLONE_FLAT_FLAG | CLONE_SYMBOLS_FLAG, customOmitClone);
+    }
+    var length = paths.length;
+    while (length--) {
+      baseUnset(result, paths[length]);
+    }
+    return result;
+  });
+
+  const _sfc_main$5 = /*@__PURE__*/Object.assign({
+    inheritAttrs: false,
+    name: "EasyButton"
+  }, {
+    __name: 'button',
+    setup(__props) {
+
+
+
+  const loading = vue.ref(false);
+
+  const attrs = vue.useAttrs();
+  const onClick = async () => {
+    try {
+      loading.value = true;
+
+      if (isFunction$1(attrs.onClick)) {
+        await attrs.onClick();
+      }
+    } finally {
+      loading.value = false;
+    }
+  };
+
+  return (_ctx, _cache) => {
+    return (vue.openBlock(), vue.createBlock(vue.unref(elementPlus.ElButton), vue.mergeProps({ loading: loading.value }, vue.unref(omit)(vue.unref(attrs), 'onClick'), { onClick: onClick }), {
+      default: vue.withCtx(() => [
+        vue.renderSlot(_ctx.$slots, "default")
+      ]),
+      _: 3 /* FORWARDED */
+    }, 16 /* FULL_PROPS */, ["loading"]))
+  }
+  }
+
+  });
+
+  // 用来整合组件的，最终实现导出组件
+
+
+  // 通过 withInstall 方法给 button 添加了一个 Vue3 插件所需的 install 方法
+  const EasyButton = withInstall(_sfc_main$5);
+
+  function useDynamicComponent() {
+    /**
+     *
+     * @param {string | number | Component | Function} type 组件名称
+     * @param {Object} scope 作用域
+     * @returns {Component}
+     */
+    const getComponent = (type, scope) => {
+      //  非 string / number，说明是组件对象或渲染函数
+      if (type && !isString(type) && !isNumber(type)) {
+        return isFunction$1(type) ? type(scope) : type
+      }
+
+      const componentKey = type;
+      let dynamicComponent;
+
+      // 只解析 el- 前缀的组件
+      if (isString(componentKey) && componentKey.startsWith("el-")) {
+        dynamicComponent = vue.resolveComponent(componentKey);
+      }
+
+      // 成功解析到组件（resolveComponent 失败会返回字符串）
+      if (dynamicComponent && !isString(dynamicComponent)) {
+        return dynamicComponent
+      }
+
+      // fallback：文本组件
+      return {
+        name: "DynamicText",
+        props: ["modelValue"],
+        render() {
+          if (!scope) {
+            return vue.h("span", {}, componentKey)
+          }
+
+          // 否则是 value,判断是否为空(null 或空字符串)
+          const isEmpty = this.modelValue === null || this.modelValue === "" || this.modelValue === undefined;
+          const displayValue = isEmpty ? "--" : this.modelValue;
+          return vue.h("span", {}, displayValue)
+        }
+      }
+    };
+
+    return {
+      getComponent
+    }
+  }
+
+  const _sfc_main$4 = /*@__PURE__*/Object.assign({
+    name: "EasyDescriptionsComp"
+  }, {
+    __name: 'comp',
+    props: /*@__PURE__*/vue.mergeModels({
+    id: {
+      type: String,
+      default: ""
+    },
+    components: {
+      type: [String, Number, Function, Object],
+      default: ""
+    },
+    props: {
+      type: Object,
+      default: () => ({})
+    }
+  }, {
+      "modelValue": {},
+      "modelModifiers": {},
+    }),
+    emits: ["update:modelValue"],
+    setup(__props) {
+
+
+
+
+
+  const descriptionsData = vue.useModel(__props, "modelValue");
+
+  const { getComponent } = useDynamicComponent();
+
+  return (_ctx, _cache) => {
+    return vue.renderSlot(_ctx.$slots, __props.components, {}, () => [
+      (__props.id)
+        ? (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(vue.unref(getComponent)(__props.components, descriptionsData.value)), vue.mergeProps({
+            key: 0,
+            modelValue: descriptionsData.value[__props.id],
+            "onUpdate:modelValue": _cache[0] || (_cache[0] = $event => ((descriptionsData.value[__props.id]) = $event))
+          }, __props.props), null, 16 /* FULL_PROPS */, ["modelValue"]))
+        : (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(vue.unref(getComponent)(__props.components)), vue.normalizeProps(vue.mergeProps({ key: 1 }, __props.props)), null, 16 /* FULL_PROPS */))
+    ])
+  }
+  }
+
+  });
+
+  const _hoisted_1$3 = { class: "epl-descriptions" };
+
+
+  const _sfc_main$3 = /*@__PURE__*/Object.assign({
+    name: "EasyDescriptions"
+  }, {
+    __name: 'descriptions',
+    props: /*@__PURE__*/vue.mergeModels({
+    items: {
+      type: Array,
+      default: () => []
+    }
+  }, {
+      "modelValue": {},
+      "modelModifiers": {},
+    }),
+    emits: ["update:modelValue"],
+    setup(__props, { expose: __expose }) {
+
+
+
+  const props = __props;
+
+  const descriptionsData = vue.useModel(__props, "modelValue");
+
+  // 内部处理单个列表的函数
+  const normalizeItems = list => {
+    return list.reduce((prev, item) => {
+      const isHidden = isFunction$1(item.hidden) ? item.hidden(descriptionsData.value) : item.hidden;
+
+      if (isHidden) return prev
+
+      prev.push({
+        ...item,
+        label: isObject$1(item.label)
+          ? item.label
+          : {
+              components: item.label
+            },
+        value: isObject$1(item.value)
+          ? item.value
+          : {
+              id: item.value,
+              components: item.value
+            }
+      });
+
+      return prev
+    }, [])
+  };
+
+  const renderList = vue.computed(() => {
+    if (!props.items || props.items.length === 0) return []
+
+    // 判断是否为分组模式：第一项包含 items 字段且是一个数组
+    // 为了兼容性更好，这里假设如果 item 内部有 items 属性，则认为是分组
+    const isGroup = props.items.some(item => item.items && Array.isArray(item.items));
+
+    if (isGroup) {
+      // 分组模式
+      return props.items
+        .filter(group => {
+          const isHidden = isFunction$1(group.hidden) ? group.hidden(descriptionsData.value) : group.hidden;
+          return !isHidden
+        })
+        .map(group => {
+          // 分离出内部使用的属性，其他的属性放入 bindProps 透传给 el-descriptions
+          // eslint-disable-next-line no-unused-vars
+          const { extra, items, hidden, ...rest } = group;
+          return {
+            ...group,
+            rows: normalizeItems(group.items),
+            bindProps: rest
+          }
+        })
+    } else {
+      // 单组模式：包装成一个默认分组
+      return [
+        {
+          rows: normalizeItems(props.items),
+          bindProps: {}
+        }
+      ]
+    }
+  });
+
+  __expose({});
+
+  return (_ctx, _cache) => {
+    return (vue.openBlock(), vue.createElementBlock("div", _hoisted_1$3, [
+      (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(renderList.value, (group, index) => {
+        return (vue.openBlock(), vue.createBlock(vue.unref(elementPlus.ElDescriptions), vue.mergeProps({
+          key: index,
+          ref_for: true
+        }, { ..._ctx.$attrs, ...group.bindProps }, { style: {"margin-bottom":"20px"} }), vue.createSlots({
+          default: vue.withCtx(() => [
+            (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(group.rows, (item) => {
+              return (vue.openBlock(), vue.createBlock(vue.unref(elementPlus.ElDescriptionsItem), vue.mergeProps({
+                key: item.label
+              }, { ref_for: true }, item), {
+                label: vue.withCtx(() => [
+                  (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(
+                  vue.h(
+                    _sfc_main$4,
+                    {
+                      modelValue: descriptionsData.value,
+                      ...item.label
+                    },
+                    _ctx.$slots
+                  )
+                )))
+                ]),
+                default: vue.withCtx(() => [
+                  (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(
+                  vue.h(
+                    _sfc_main$4,
+                    {
+                      modelValue: descriptionsData.value,
+                      ...item.value
+                    },
+                    _ctx.$slots
+                  )
+                )))
+                ]),
+                _: 2 /* DYNAMIC */
+              }, 1040 /* FULL_PROPS, DYNAMIC_SLOTS */))
+            }), 128 /* KEYED_FRAGMENT */))
+          ]),
+          _: 2 /* DYNAMIC */
+        }, [
+          (group.title || _ctx.$slots.title)
+            ? {
+                name: "title",
+                fn: vue.withCtx(() => [
+                  (group.title)
+                    ? (vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: 0 }, [
+                        vue.createTextVNode(vue.toDisplayString(group.title), 1 /* TEXT */)
+                      ], 64 /* STABLE_FRAGMENT */))
+                    : vue.renderSlot(_ctx.$slots, "title", {
+                        key: 1,
+                        group: group,
+                        index: index
+                      })
+                ]),
+                key: "0"
+              }
+            : undefined,
+          (group.extra || _ctx.$slots.extra)
+            ? {
+                name: "extra",
+                fn: vue.withCtx(() => [
+                  (group.extra)
+                    ? (vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: 0 }, [
+                        vue.createTextVNode(vue.toDisplayString(group.extra), 1 /* TEXT */)
+                      ], 64 /* STABLE_FRAGMENT */))
+                    : vue.renderSlot(_ctx.$slots, "extra", {
+                        key: 1,
+                        group: group,
+                        index: index
+                      })
+                ]),
+                key: "1"
+              }
+            : undefined
+        ]), 1040 /* FULL_PROPS, DYNAMIC_SLOTS */))
+      }), 128 /* KEYED_FRAGMENT */))
+    ]))
+  }
+  }
+
+  });
+
+  // 用来整合组件的，最终实现导出组件
+
+
+  // 通过 withInstall 方法给 button 添加了一个 Vue3 插件所需的 install 方法
+  const EasyDescriptions = withInstall(_sfc_main$3);
+
+  Math.easeInOutQuad = function (t, b, c, d) {
+    t /= d / 2;
+    if (t < 1) {
+      return (c / 2) * t * t + b
+    }
+    t--;
+    return (-c / 2) * (t * (t - 2) - 1) + b
+  };
+
+  // requestAnimationFrame for Smart Animating http://goo.gl/sx5sts
+  var requestAnimFrame = (function () {
+    if (typeof window === "undefined") {
+      return function (callback) {
+        setTimeout(callback, 1000 / 60);
+      }
+    }
+    return (
+      window.requestAnimationFrame ||
+      window.webkitRequestAnimationFrame ||
+      window.mozRequestAnimationFrame ||
+      function (callback) {
+        window.setTimeout(callback, 1000 / 60);
+      }
+    )
+  })();
+
+  /**
+   * Because it's so fucking difficult to detect the scrolling element, just move them all
+   * @param {number} amount
+   */
+  function move(amount) {
+    document.documentElement.scrollTop = amount;
+    document.body.parentNode.scrollTop = amount;
+    document.body.scrollTop = amount;
+  }
+
+  function position() {
+    return document.documentElement.scrollTop || document.body.parentNode.scrollTop || document.body.scrollTop
+  }
+
+  /**
+   * @param {number} to
+   * @param {number} duration
+   * @param {Function} callback
+   */
+  function scrollTo(to, duration, callback) {
+    const start = position();
+    const change = to - start;
+    const increment = 20;
+    let currentTime = 0;
+    duration = isUndefined(duration) ? 500 : duration;
+    var animateScroll = function () {
+      // increment the time
+      currentTime += increment;
+      // find the value with the quadratic in-out easing function
+      var val = Math.easeInOutQuad(currentTime, start, change, duration);
+      // move the document.body
+      move(val);
+      // do the animation unless its over
+      if (currentTime < duration) {
+        requestAnimFrame(animateScroll);
+      }
+    };
+    animateScroll();
+  }
+
+  function styleInject(css, ref) {
+    if ( ref === void 0 ) ref = {};
+    var insertAt = ref.insertAt;
+
+    if (!css || typeof document === 'undefined') { return; }
+
+    var head = document.head || document.getElementsByTagName('head')[0];
+    var style = document.createElement('style');
+    style.type = 'text/css';
+
+    if (insertAt === 'top') {
+      if (head.firstChild) {
+        head.insertBefore(style, head.firstChild);
+      } else {
+        head.appendChild(style);
+      }
+    } else {
+      head.appendChild(style);
+    }
+
+    if (style.styleSheet) {
+      style.styleSheet.cssText = css;
+    } else {
+      style.appendChild(document.createTextNode(css));
+    }
+  }
+
+  var css_248z$2 = ".table-container[data-v-d1947650] {\n  display: flex;\n  flex-direction: column;\n  flex: 1;\n  min-height: 400px;\n}\n.table-container .table[data-v-d1947650] {\n  flex: 1;\n  position: relative;\n}\n.table-container .table [data-v-d1947650] .el-table {\n  position: absolute;\n  height: 100%;\n}\n\n.pagination-container[data-v-d1947650] {\n  padding: 16px 0;\n  display: flex;\n}\n\n.operate-group[data-v-d1947650] {\n  display: flex;\n  align-items: center;\n}\n.operate-group .el-button + .el-button[data-v-d1947650],\n.operate-group .el-button + .custom-dropdown[data-v-d1947650] {\n  margin-left: 16px;\n  position: relative;\n}\n.operate-group .el-button + .el-button[data-v-d1947650]::before,\n.operate-group .el-button + .custom-dropdown[data-v-d1947650]::before {\n  content: \"\";\n  position: absolute;\n  left: -8px;\n  top: 50%;\n  transform: translateY(-50%);\n  width: 1px;\n  height: 12px;\n  background-color: #dcdfe6;\n}\n.operate-group [data-v-d1947650] .custom-text {\n  color: #606266;\n  padding: 0;\n}\n.operate-group [data-v-d1947650] .custom-text:hover {\n  color: #409eff;\n}";
+  styleInject(css_248z$2);
+
+  var _export_sfc = (sfc, props) => {
+    const target = sfc.__vccOpts || sfc;
+    for (const [key, val] of props) {
+      target[key] = val;
+    }
+    return target;
+  };
+
+  const _hoisted_1$2 = { class: "table-container" };
+  const _hoisted_2$2 = { class: "table" };
+  const _hoisted_3$2 = { key: 0 };
+  const _hoisted_4$2 = ["innerHTML"];
+  const _hoisted_5$2 = ["innerHTML"];
+  const _hoisted_6 = { class: "operate-group" };
+
+
+  const _sfc_main$2 = /*@__PURE__*/Object.assign({ name: "EasyTable" }, {
+    __name: 'table',
+    props: {
+    columns: { type: Array, default: () => [] },
+    tableData: { type: Array, default: () => [] },
+    total: { type: Number, default: 0 },
+    page: { type: Number, default: 1 },
+    options: {
+      type: Object,
+      default: () => ({ stripe: false, highlightCurrentRow: false, border: true })
+    },
+    limit: { type: Number, default: 20 },
+    pageSizes: { type: Array, default: () => [10, 20, 30, 50] },
+    pagerCount: {
+      type: Number,
+      default: () => (typeof document !== "undefined" && document.body.clientWidth < 992 ? 5 : 7)
+    },
+    layout: { type: String, default: "total, sizes, prev, pager, next, jumper" },
+    background: { type: Boolean, default: true },
+    autoScroll: { type: Boolean, default: true },
+    hidden: { type: Boolean, default: false },
+    operates: { type: Object, default: () => ({ list: [] }) },
+    paginationPosition: { type: String, default: "right" }
+  },
+    emits: ["update:page", "update:limit", "pagination", "sortChange", "handleSelectionChange"],
+    setup(__props, { expose: __expose, emit: __emit }) {
+
+
+
+  const props = __props;
+
+  const emit = __emit;
+
+  const slots = vue.useSlots();
+  const iTableRef = vue.ref(null);
+  const processedHeaders = vue.ref([]);
+
+  /** 1. 逻辑优化：使用 watch 监听 columns 变化，避免在 onBeforeUpdate 中过度计算 **/
+  vue.watch(
+    () => [props.columns, slots],
+    () => {
+      processedHeaders.value = props.columns.map(column => {
+        const col = { ...column };
+        if (!col.key) col.key = col.prop;
+
+        // 匹配插槽逻辑保持不变
+        Object.keys(slots).forEach(key => {
+          const res = key.match(/^(\S+)-(\S+)/);
+
+          if (res && res[2] === col.key) {
+            col.slot = { ...col.slot, [res[1]]: res[0] };
+          }
+        });
+
+        return col
+      });
+    },
+    { immediate: true, deep: true }
+  );
+
+  /** 2. 工具函数 **/
+
+  // 计算表头宽度
+  const headSpanFit = column => {
+    const labelLen = column?.label?.length || 0;
+    return Math.max(labelLen * 20, 100)
+  };
+
+  // 判断列是否显示
+  const isColumnVisible = column => {
+    if (isFunction$1(column.show)) return column.show()
+    return column.show !== false
+  };
+
+  // 获取渲染内容
+  const getRenderContent = (column, scope) => {
+    return isFunction$1(column.render) ? column.render(scope) : column.render
+  };
+
+  // 获取可见按钮
+  const getVisibleButtons = row => {
+    const list = (props.operates?.list || []).filter(item => {
+      return isFunction$1(item.show) ? item.show(row) : item.show !== false
+    });
+    return list.length > 3
+      ? {
+          outside: list.slice(0, 2),
+          inside: list.slice(2)
+        }
+      : {
+          outside: list,
+          inside: []
+        }
+  };
+
+  /** 3. 分页计算属性 **/
+  // 当前页码
+  const currentPage = vue.computed({
+    get: () => props.page,
+    set: val => emit("update:page", val)
+  });
+
+  // 每页条数
+  const pageSize = vue.computed({
+    get: () => props.limit,
+    set: val => emit("update:limit", val)
+  });
+
+  // 分页对齐方式
+  const paginationJustify = vue.computed(() => {
+    const map = { left: "flex-start", center: "center", right: "flex-end" };
+    return map[props.paginationPosition] || "flex-end"
+  });
+
+  /** 4. 事件处理 **/
+  // 改变每页条数
+  const handleSizeChange = val => {
+    if (currentPage.value * val > props.total) currentPage.value = 1;
+    emit("pagination", { page: currentPage.value, limit: val });
+    if (props.autoScroll) scrollTo(0, 800);
+  };
+
+  // 改变当前页
+  const handleCurrentChange = val => {
+    emit("pagination", { page: val, limit: pageSize.value });
+    if (props.autoScroll) scrollTo(0, 800);
+  };
+
+  // 改变排序
+  const sortChange = args => emit("sortChange", args);
+
+  // 改变选择
+  const handleSelectionChange = val => emit("handleSelectionChange", val);
+
+  __expose({ iTableRef });
+
+  return (_ctx, _cache) => {
+    const _component_el_table_column = vue.resolveComponent("el-table-column");
+    const _component_el_icon = vue.resolveComponent("el-icon");
+    const _component_el_button = vue.resolveComponent("el-button");
+    const _component_el_dropdown_item = vue.resolveComponent("el-dropdown-item");
+    const _component_el_dropdown_menu = vue.resolveComponent("el-dropdown-menu");
+    const _component_el_dropdown = vue.resolveComponent("el-dropdown");
+    const _component_el_table = vue.resolveComponent("el-table");
+    const _component_el_pagination = vue.resolveComponent("el-pagination");
+
+    return (vue.openBlock(), vue.createElementBlock("div", _hoisted_1$2, [
+      vue.createElementVNode("div", _hoisted_2$2, [
+        vue.createVNode(_component_el_table, vue.mergeProps({
+          id: "iTable",
+          ref_key: "iTableRef",
+          ref: iTableRef,
+          data: __props.tableData
+        }, __props.options, {
+          height: "100%",
+          style: {"width":"100%"},
+          onSortChange: sortChange,
+          onSelectionChange: handleSelectionChange
+        }), {
+          default: vue.withCtx(() => [
+            (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(processedHeaders.value, (column, index) => {
+              return (vue.openBlock(), vue.createElementBlock(vue.Fragment, {
+                key: index + (column.prop || '')
+              }, [
+                (isColumnVisible(column))
+                  ? (vue.openBlock(), vue.createBlock(_component_el_table_column, vue.mergeProps({
+                      key: 0,
+                      "min-width": headSpanFit(column)
+                    }, { ref_for: true }, column), vue.createSlots({ _: 2 /* DYNAMIC */ }, [
+                      vue.renderList(column.slot, (value, key) => {
+                        return {
+                          name: key,
+                          fn: vue.withCtx((scope) => [
+                            vue.renderSlot(_ctx.$slots, value, vue.mergeProps({ ref_for: true }, scope), undefined, true)
+                          ])
+                        }
+                      }),
+                      (!column.slot)
+                        ? {
+                            name: "default",
+                            fn: vue.withCtx((scope) => [
+                              vue.createCommentVNode(" 渲染render "),
+                              (column.render)
+                                ? (vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: 0 }, [
+                                    vue.createCommentVNode(" 如果render返回的是字符串 "),
+                                    (vue.unref(isString)(getRenderContent(column, scope)))
+                                      ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_3$2, [
+                                          vue.createElementVNode("div", {
+                                            innerHTML: getRenderContent(column, scope)
+                                          }, null, 8 /* PROPS */, _hoisted_4$2)
+                                        ]))
+                                      : (vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: 1 }, [
+                                          vue.createCommentVNode(" 如果render返回的是组件 "),
+                                          (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(column.render), vue.mergeProps({ ref_for: true }, scope, {
+                                            row: scope.row,
+                                            index: scope.$index
+                                          }), null, 16 /* FULL_PROPS */, ["row", "index"]))
+                                        ], 2112 /* STABLE_FRAGMENT, DEV_ROOT_FRAGMENT */))
+                                  ], 64 /* STABLE_FRAGMENT */))
+                                : (column.formatter)
+                                  ? (vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: 1 }, [
+                                      vue.createCommentVNode(" 渲染formatter "),
+                                      vue.createElementVNode("span", {
+                                        innerHTML: column.formatter(scope.row, column)
+                                      }, null, 8 /* PROPS */, _hoisted_5$2)
+                                    ], 64 /* STABLE_FRAGMENT */))
+                                  : (!column.type)
+                                    ? (vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: 2 }, [
+                                        vue.createCommentVNode(" 渲染默认内容 "),
+                                        vue.createElementVNode("span", null, vue.toDisplayString(scope.row[column.prop] ?? "--"), 1 /* TEXT */)
+                                      ], 64 /* STABLE_FRAGMENT */))
+                                    : vue.createCommentVNode("v-if", true)
+                            ]),
+                            key: "0"
+                          }
+                        : undefined
+                    ]), 1040 /* FULL_PROPS, DYNAMIC_SLOTS */, ["min-width"]))
+                  : vue.createCommentVNode("v-if", true)
+              ], 64 /* STABLE_FRAGMENT */))
+            }), 128 /* KEYED_FRAGMENT */)),
+            vue.createCommentVNode(" 操作列 "),
+            (__props.operates.list?.length)
+              ? (vue.openBlock(), vue.createBlock(_component_el_table_column, {
+                  key: 0,
+                  label: "操作",
+                  align: "left",
+                  width: __props.operates.width,
+                  fixed: __props.operates.fixed
+                }, {
+                  default: vue.withCtx((scope) => [
+                    vue.createElementVNode("div", _hoisted_6, [
+                      vue.createCommentVNode(" 渲染外部按钮 "),
+                      (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(getVisibleButtons(scope.row).outside, (item, idx) => {
+                        return (vue.openBlock(), vue.createBlock(_component_el_button, vue.mergeProps({
+                          key: idx,
+                          ref_for: true
+                        }, item, {
+                          type: item.type || 'primary',
+                          size: item.size || 'small',
+                          onClick: vue.withModifiers($event => (item.method(scope.row, scope.$index)), ["stop"])
+                        }), {
+                          default: vue.withCtx(() => [
+                            vue.createTextVNode(vue.toDisplayString(item.label) + " ", 1 /* TEXT */),
+                            (item.icon)
+                              ? (vue.openBlock(), vue.createBlock(_component_el_icon, {
+                                  key: 0,
+                                  class: "el-icon--right"
+                                }, {
+                                  default: vue.withCtx(() => [
+                                    (vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent(item.icon)))
+                                  ]),
+                                  _: 2 /* DYNAMIC */
+                                }, 1024 /* DYNAMIC_SLOTS */))
+                              : vue.createCommentVNode("v-if", true)
+                          ]),
+                          _: 2 /* DYNAMIC */
+                        }, 1040 /* FULL_PROPS, DYNAMIC_SLOTS */, ["type", "size", "onClick"]))
+                      }), 128 /* KEYED_FRAGMENT */)),
+                      vue.createCommentVNode(" 渲染下拉按钮 "),
+                      (getVisibleButtons(scope.row).inside.length)
+                        ? (vue.openBlock(), vue.createBlock(_component_el_dropdown, {
+                            key: 0,
+                            class: "custom-dropdown",
+                            trigger: "click"
+                          }, {
+                            dropdown: vue.withCtx(() => [
+                              vue.createVNode(_component_el_dropdown_menu, null, {
+                                default: vue.withCtx(() => [
+                                  (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(getVisibleButtons(scope.row).inside, (item, idx) => {
+                                    return (vue.openBlock(), vue.createBlock(_component_el_dropdown_item, vue.mergeProps({ key: idx }, { ref_for: true }, item, {
+                                      onClick: $event => (item.method(scope.row, scope.$index))
+                                    }), {
+                                      default: vue.withCtx(() => [
+                                        vue.createTextVNode(vue.toDisplayString(item.label), 1 /* TEXT */)
+                                      ]),
+                                      _: 2 /* DYNAMIC */
+                                    }, 1040 /* FULL_PROPS, DYNAMIC_SLOTS */, ["onClick"]))
+                                  }), 128 /* KEYED_FRAGMENT */))
+                                ]),
+                                _: 2 /* DYNAMIC */
+                              }, 1024 /* DYNAMIC_SLOTS */)
+                            ]),
+                            default: vue.withCtx(() => [
+                              vue.createVNode(_component_el_button, {
+                                link: "",
+                                size: "small",
+                                class: "custom-text"
+                              }, {
+                                default: vue.withCtx(() => [
+                                  vue.createVNode(_component_el_icon, { size: 18 }, {
+                                    default: vue.withCtx(() => [
+                                      vue.createVNode(vue.unref(iconsVue.MoreFilled))
+                                    ]),
+                                    _: 1 /* STABLE */
+                                  })
+                                ]),
+                                _: 1 /* STABLE */
+                              })
+                            ]),
+                            _: 2 /* DYNAMIC */
+                          }, 1024 /* DYNAMIC_SLOTS */))
+                        : vue.createCommentVNode("v-if", true)
+                    ])
+                  ]),
+                  _: 1 /* STABLE */
+                }, 8 /* PROPS */, ["width", "fixed"]))
+              : vue.createCommentVNode("v-if", true)
+          ]),
+          _: 3 /* FORWARDED */
+        }, 16 /* FULL_PROPS */, ["data"])
+      ]),
+      vue.createCommentVNode(" 分页 "),
+      (!__props.hidden)
+        ? (vue.openBlock(), vue.createElementBlock("div", {
+            key: 0,
+            class: "pagination-container",
+            style: vue.normalizeStyle({ justifyContent: paginationJustify.value })
+          }, [
+            vue.createVNode(_component_el_pagination, {
+              "current-page": currentPage.value,
+              "onUpdate:currentPage": _cache[0] || (_cache[0] = $event => ((currentPage).value = $event)),
+              "page-size": pageSize.value,
+              "onUpdate:pageSize": _cache[1] || (_cache[1] = $event => ((pageSize).value = $event)),
+              background: __props.background,
+              layout: __props.layout,
+              "page-sizes": __props.pageSizes,
+              "pager-count": __props.pagerCount,
+              total: __props.total,
+              onSizeChange: handleSizeChange,
+              onCurrentChange: handleCurrentChange
+            }, null, 8 /* PROPS */, ["current-page", "page-size", "background", "layout", "page-sizes", "pager-count", "total"])
+          ], 4 /* STYLE */))
+        : vue.createCommentVNode("v-if", true)
+    ]))
+  }
+  }
+
+  });
+  var table = /*#__PURE__*/_export_sfc(_sfc_main$2, [['__scopeId',"data-v-d1947650"]]);
+
+  // 用来整合组件的，最终实现导出组件
+
+
+  // 通过 withInstall 方法给 button 添加了一个 Vue3 插件所需的 install 方法
+  const EasyTable = withInstall(table);
+
+  const UPDATE_MODEL_EVENT = "update:modelValue";
+
+  var css_248z$1 = "\n/* 保持原有样式 */\n.component-upload-image[data-v-9ac7dd1b] .el-upload--picture-card {\n  width: 100px;\n  height: 100px;\n  line-height: 110px;\n}\n.component-upload-image[data-v-9ac7dd1b] .el-upload-list--picture-card .el-upload-list__item {\n  width: 100px;\n  height: 100px;\n}\n.component-upload-image[data-v-9ac7dd1b] .hide .el-upload--picture-card {\n  display: none;\n}\n";
+  styleInject(css_248z$1);
+
+  const _hoisted_1$1 = { class: "component-upload-image" };
+  const _hoisted_2$1 = {
+    key: 0,
+    class: "el-upload__tip"
+  };
+  const _hoisted_3$1 = { style: {"color":"#f56c6c"} };
+  const _hoisted_4$1 = { style: {"color":"#f56c6c"} };
+  const _hoisted_5$1 = ["src"];
+
+
+  const _sfc_main$1 = /*@__PURE__*/Object.assign({ name: "EasyImageUpload" }, {
+    __name: 'ImageUpload',
+    props: {
+    modelValue: [String, Object, Array],
+    limit: { type: Number, default: 5 },
+    fileSize: { type: Number, default: 5 },
+    fileType: { type: Array, default: () => ["png", "jpg", "jpeg"] },
+    isShowTip: { type: Boolean, default: true },
+    action: { type: String, required: true },
+    headers: { type: Object, default: () => ({}) },
+    baseUrl: { type: String, default: "" },
+
+    checkSuccess: {
+      type: Function,
+      default: res => res.code === 200 || res.success === true
+    },
+    // 自定义提取图片地址的路径，支持 "data.url" 这种深层嵌套
+    responsePath: {
+      type: String,
+      default: "data"
+    },
+    // 错误消息提取字段
+    errorField: {
+      type: String,
+      default: "msg"
+    }
+  },
+    emits: [UPDATE_MODEL_EVENT],
+    setup(__props, { emit: __emit }) {
+
+
+
+  const props = __props;
+
+  const emit = __emit;
+
+  const number = vue.ref(0);
+  const uploadList = vue.ref([]);
+  const dialogImageUrl = vue.ref("");
+  const dialogVisible = vue.ref(false);
+  const fileList = vue.ref([]);
+  const imageUploadRef = vue.ref(null);
+
+  const showTip = vue.computed(() => props.isShowTip && (props.fileType || props.fileSize));
+
+  // 深度解析对象属性 (例如把 res["data.imgUrl"] 转为 res.data.imgUrl)
+  const getDeepValue = (obj, path) => {
+    if (!path) return obj
+    return path.split(".").reduce((acc, key) => (acc && acc[key] !== undefined ? acc[key] : undefined), obj)
+  };
+
+  vue.watch(
+    () => props.modelValue,
+    val => {
+      if (val) {
+        const list = Array.isArray(val) ? val : val.split(",");
+        fileList.value = list.map(item => {
+          if (isString(item)) {
+            let url = item;
+            if (!/^https?:\/\//.test(url) && props.baseUrl) {
+              url = props.baseUrl + item;
+            }
+            item = { name: getFileName(item), url: url };
+          }
+          return item
+        });
+      } else {
+        fileList.value = [];
+      }
+    },
+    { deep: true, immediate: true }
+  );
+
+  function handleBeforeUpload(file) {
+    let isImg = false;
+    if (props.fileType.length) {
+      const fileExtension = file.name.slice(file.name.lastIndexOf(".") + 1).toLowerCase();
+      isImg = props.fileType.map(t => t.toLowerCase()).includes(fileExtension);
+    } else {
+      isImg = file.type.indexOf("image") > -1;
+    }
+
+    if (!isImg) {
+      elementPlus.ElMessage.error(`格式不正确, 请上传${props.fileType.join("/")}图片!`);
+      return false
+    }
+    if (props.fileSize && file.size / 1024 / 1024 > props.fileSize) {
+      elementPlus.ElMessage.error(`大小不能超过 ${props.fileSize} MB!`);
+      return false
+    }
+    number.value++;
+    return true
+  }
+
+  function handleExceed() {
+    elementPlus.ElMessage.error(`上传数量不能超过 ${props.limit} 个!`);
+  }
+
+  // 修改后的核心逻辑
+  function handleUploadSuccess(res, file) {
+    // 1. 使用传入的校验函数
+    if (props.checkSuccess(res)) {
+      // 2. 动态提取 URL
+      const url = getDeepValue(res, props.responsePath);
+
+      if (url) {
+        uploadList.value.push({ name: getFileName(url), url: url });
+        uploadedSuccessfully();
+      } else {
+        handleUploadError(`无法从响应中解析图片路径: ${props.responsePath}`);
+      }
+    } else {
+      number.value--;
+      const errorMsg = getDeepValue(res, props.errorField) || "上传失败";
+      elementPlus.ElMessage.error(errorMsg);
+      imageUploadRef.value.handleRemove(file);
+      uploadedSuccessfully();
+    }
+  }
+
+  function handleRemove(file) {
+    const findex = fileList.value.findIndex(f => f.name === file.name);
+    if (findex > -1) {
+      fileList.value.splice(findex, 1);
+      emit(UPDATE_MODEL_EVENT, listToString(fileList.value));
+    }
+  }
+
+  function uploadedSuccessfully() {
+    if (number.value > 0 && uploadList.value.length === number.value) {
+      fileList.value = fileList.value.filter(f => f.url !== undefined).concat(uploadList.value);
+      uploadList.value = [];
+      number.value = 0;
+      emit(UPDATE_MODEL_EVENT, listToString(fileList.value));
+    }
+  }
+
+  function handleUploadError(msg) {
+    elementPlus.ElMessage.error(isString(msg) ? msg : "上传图片失败");
+    number.value--;
+  }
+
+  function handlePictureCardPreview(file) {
+    dialogImageUrl.value = file.url;
+    dialogVisible.value = true;
+  }
+
+  function getFileName(name) {
+    if (!isString(name)) return ""
+    return name.slice(name.lastIndexOf("/") + 1)
+  }
+
+  function listToString(list, separator = ",") {
+    return list
+      .filter(item => item.url && item.url.indexOf("blob:") !== 0)
+      .map(item => {
+        let url = item.url;
+        if (props.baseUrl && url.indexOf(props.baseUrl) === 0) {
+          url = url.replace(props.baseUrl, "");
+        }
+        return url
+      })
+      .join(separator)
+  }
+
+  return (_ctx, _cache) => {
+    const _component_el_icon = vue.resolveComponent("el-icon");
+    const _component_el_upload = vue.resolveComponent("el-upload");
+    const _component_el_dialog = vue.resolveComponent("el-dialog");
+
+    return (vue.openBlock(), vue.createElementBlock("div", _hoisted_1$1, [
+      vue.createVNode(_component_el_upload, {
+        ref_key: "imageUploadRef",
+        ref: imageUploadRef,
+        multiple: "",
+        action: __props.action,
+        "list-type": "picture-card",
+        "on-success": handleUploadSuccess,
+        "before-upload": handleBeforeUpload,
+        limit: __props.limit,
+        "on-error": handleUploadError,
+        "on-exceed": handleExceed,
+        "on-remove": handleRemove,
+        "show-file-list": true,
+        headers: __props.headers,
+        "file-list": fileList.value,
+        "on-preview": handlePictureCardPreview,
+        class: vue.normalizeClass({ hide: fileList.value.length >= __props.limit })
+      }, {
+        default: vue.withCtx(() => [
+          vue.createVNode(_component_el_icon, { class: "avatar-uploader-icon" }, {
+            default: vue.withCtx(() => [
+              vue.createVNode(vue.unref(iconsVue.Plus))
+            ]),
+            _: 1 /* STABLE */
+          })
+        ]),
+        _: 1 /* STABLE */
+      }, 8 /* PROPS */, ["action", "limit", "headers", "file-list", "class"]),
+      (showTip.value)
+        ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_2$1, [
+            _cache[3] || (_cache[3] = vue.createTextVNode(" 请上传 ", -1 /* CACHED */)),
+            (__props.fileSize)
+              ? (vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: 0 }, [
+                  _cache[1] || (_cache[1] = vue.createTextVNode(" 大小不超过 ", -1 /* CACHED */)),
+                  vue.createElementVNode("b", _hoisted_3$1, vue.toDisplayString(__props.fileSize) + "MB", 1 /* TEXT */)
+                ], 64 /* STABLE_FRAGMENT */))
+              : vue.createCommentVNode("v-if", true),
+            (__props.fileType)
+              ? (vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: 1 }, [
+                  _cache[2] || (_cache[2] = vue.createTextVNode(" 格式为 ", -1 /* CACHED */)),
+                  vue.createElementVNode("b", _hoisted_4$1, vue.toDisplayString(__props.fileType.join("/")), 1 /* TEXT */)
+                ], 64 /* STABLE_FRAGMENT */))
+              : vue.createCommentVNode("v-if", true),
+            _cache[4] || (_cache[4] = vue.createTextVNode(" 的文件 ", -1 /* CACHED */))
+          ]))
+        : vue.createCommentVNode("v-if", true),
+      vue.createVNode(_component_el_dialog, {
+        modelValue: dialogVisible.value,
+        "onUpdate:modelValue": _cache[0] || (_cache[0] = $event => ((dialogVisible).value = $event)),
+        title: "预览",
+        width: "800px",
+        "append-to-body": ""
+      }, {
+        default: vue.withCtx(() => [
+          vue.createElementVNode("img", {
+            src: dialogImageUrl.value,
+            style: {"display":"block","max-width":"100%","margin":"0 auto"}
+          }, null, 8 /* PROPS */, _hoisted_5$1)
+        ]),
+        _: 1 /* STABLE */
+      }, 8 /* PROPS */, ["modelValue"])
+    ]))
+  }
+  }
+
+  });
+  var ImageUpload = /*#__PURE__*/_export_sfc(_sfc_main$1, [['__scopeId',"data-v-9ac7dd1b"]]);
+
+  const EasyImageUpload = withInstall(ImageUpload);
+
+  var css_248z = ".component-upload-file .upload-file-uploader[data-v-cc8b9b13] {\n  margin-bottom: 5px;\n}\n.component-upload-file .el-upload__tip[data-v-cc8b9b13] {\n  font-size: 12px;\n  color: #606266;\n  margin-top: 7px;\n}\n.component-upload-file .upload-file-list[data-v-cc8b9b13] {\n  margin: 0;\n  padding: 0;\n  list-style: none;\n}\n.component-upload-file .upload-file-list .el-upload-list__item[data-v-cc8b9b13] {\n  border: 1px solid #e4e7ed;\n  line-height: 2;\n  margin-bottom: 10px;\n  position: relative;\n  border-radius: 4px;\n  padding: 8px 10px;\n  transition: all 0.3s;\n}\n.component-upload-file .upload-file-list .el-upload-list__item[data-v-cc8b9b13]:hover {\n  background-color: #f5f7fa;\n}\n.component-upload-file .upload-file-list .ele-upload-list__item-content[data-v-cc8b9b13] {\n  display: flex;\n  justify-content: space-between;\n  align-items: center;\n  color: inherit;\n}\n.component-upload-file .upload-file-list .ele-upload-list__item-content .el-link[data-v-cc8b9b13] {\n  flex: 1;\n  margin-right: 10px;\n}\n.component-upload-file .upload-file-list .ele-upload-list__item-content-action .el-link[data-v-cc8b9b13] {\n  margin-right: 10px;\n}";
+  styleInject(css_248z);
+
+  const _hoisted_1 = { class: "component-upload-file" };
+  const _hoisted_2 = {
+    key: 0,
+    class: "el-upload__tip"
+  };
+  const _hoisted_3 = { style: {"color":"#f56c6c"} };
+  const _hoisted_4 = { style: {"color":"#f56c6c"} };
+  const _hoisted_5 = { class: "ele-upload-list__item-content-action" };
+
+
+  const _sfc_main = /*@__PURE__*/Object.assign({ name: "EasyFileUpload" }, {
+    __name: 'FileUpload',
+    props: {
+    modelValue: [String, Object, Array],
+    // 数量限制
+    limit: {
+      type: Number,
+      default: 5
+    },
+    // 大小限制(MB)
+    fileSize: {
+      type: Number,
+      default: 5
+    },
+    // 文件类型, 例如['doc', 'xls', 'ppt', 'txt', 'pdf']
+    fileType: {
+      type: Array,
+      default: () => ["doc", "xls", "ppt", "txt", "pdf"]
+    },
+    // 是否显示提示
+    isShowTip: {
+      type: Boolean,
+      default: true
+    },
+    // 上传地址
+    action: {
+      type: String,
+      required: true
+    },
+    // 请求头
+    headers: {
+      type: Object,
+      default: () => ({})
+    },
+    // 基础路径
+    baseUrl: {
+      type: String,
+      default: ""
+    },
+    // 自定义成功校验函数
+    checkSuccess: {
+      type: Function,
+      default: res => res.code === 200 || res.success === true
+    },
+    // 自定义提取文件地址的路径，支持 "data.url" 这种深层嵌套
+    responsePath: {
+      type: String,
+      default: "data"
+    },
+    // 错误消息提取字段
+    errorField: {
+      type: String,
+      default: "msg"
+    }
+  },
+    emits: [UPDATE_MODEL_EVENT],
+    setup(__props, { emit: __emit }) {
+
+
+
+  const props = __props;
+
+  const emit = __emit;
+
+  const number = vue.ref(0);
+  const uploadList = vue.ref([]);
+  const fileList = vue.ref([]);
+  const fileUploadRef = vue.ref(null);
+
+  const showTip = vue.computed(() => props.isShowTip && (props.fileType || props.fileSize));
+
+  // 深度解析对象属性 (例如把 res["data.url"] 转为 res.data.url)
+  const getDeepValue = (obj, path) => {
+    if (!path) return obj
+    return path.split(".").reduce((acc, key) => (acc && acc[key] !== undefined ? acc[key] : undefined), obj)
+  };
+
+  vue.watch(
+    () => props.modelValue,
+    val => {
+      if (val) {
+        const list = Array.isArray(val) ? val : val.split(",");
+        fileList.value = list.map((item, index) => {
+          if (isString(item)) {
+            item = { name: getFileName(item), url: item, uid: new Date().getTime() + index };
+          }
+          return item
+        });
+      } else {
+        fileList.value = [];
+      }
+    },
+    { deep: true, immediate: true }
+  );
+
+  // 上传前校检格式和大小
+  function handleBeforeUpload(file) {
+    // 校检文件类型
+    if (props.fileType && props.fileType.length) {
+      const fileName = file.name.split(".");
+      const fileExt = fileName[fileName.length - 1].toLowerCase();
+      const isTypeOk = props.fileType.map(t => t.toLowerCase()).includes(fileExt);
+      if (!isTypeOk) {
+        elementPlus.ElMessage.error(`文件格式不正确, 请上传${props.fileType.join("/")}格式文件!`);
+        return false
+      }
+    }
+    // 校检文件大小
+    if (props.fileSize && file.size / 1024 / 1024 > props.fileSize) {
+      elementPlus.ElMessage.error(`上传文件大小不能超过 ${props.fileSize} MB!`);
+      return false
+    }
+    number.value++;
+    return true
+  }
+
+  // 文件个数超出
+  function handleExceed() {
+    elementPlus.ElMessage.error(`上传文件数量不能超过 ${props.limit} 个!`);
+  }
+
+  // 上传失败
+  function handleUploadError(err) {
+    number.value--;
+    elementPlus.ElMessage.error(isString(err) ? err : "上传文件失败");
+  }
+
+  // 上传成功回调
+  function handleUploadSuccess(res, file) {
+    // 使用传入的校验函数
+    if (props.checkSuccess(res)) {
+      // 动态提取 URL
+      const url = getDeepValue(res, props.responsePath);
+
+      if (url) {
+        uploadList.value.push({ name: getFileName(url), url: url, uid: file.uid });
+        uploadedSuccessfully();
+      } else {
+        handleUploadError(`无法从响应中解析文件路径: ${props.responsePath}`);
+      }
+    } else {
+      number.value--;
+      const errorMsg = getDeepValue(res, props.errorField) || "上传失败";
+      elementPlus.ElMessage.error(errorMsg);
+      fileUploadRef.value?.handleRemove(file);
+      uploadedSuccessfully();
+    }
+  }
+
+  // 删除文件
+  function handleDelete(index) {
+    fileList.value.splice(index, 1);
+    emit(UPDATE_MODEL_EVENT, listToString(fileList.value));
+  }
+
+  // 移除文件
+  function handleRemove(file) {
+    const findex = fileList.value.findIndex(f => f.uid === file.uid);
+    if (findex > -1) {
+      fileList.value.splice(findex, 1);
+      emit(UPDATE_MODEL_EVENT, listToString(fileList.value));
+    }
+  }
+
+  // 上传结束处理
+  function uploadedSuccessfully() {
+    if (number.value > 0 && uploadList.value.length === number.value) {
+      fileList.value = fileList.value.filter(f => f.url !== undefined).concat(uploadList.value);
+      uploadList.value = [];
+      number.value = 0;
+      emit(UPDATE_MODEL_EVENT, listToString(fileList.value));
+    }
+  }
+
+  // 获取文件名称
+  function getFileName(name) {
+    if (!isString(name)) return ""
+    return name.slice(name.lastIndexOf("/") + 1)
+  }
+
+  // 获取文件完整 URL
+  function getFileUrl(url) {
+    if (!url) return ""
+    if (/^https?:\/\//.test(url)) return url
+    return props.baseUrl ? props.baseUrl + url : url
+  }
+
+  // 对象转成指定字符串分隔
+  function listToString(list, separator = ",") {
+    return list
+      .filter(item => item.url && item.url.indexOf("blob:") !== 0)
+      .map(item => {
+        let url = item.url;
+        // 如果设置了 baseUrl，保存时去除它
+        if (props.baseUrl && url.indexOf(props.baseUrl) === 0) {
+          url = url.replace(props.baseUrl, "");
+        }
+        return url
+      })
+      .join(separator)
+  }
+
+  return (_ctx, _cache) => {
+    const _component_el_icon = vue.resolveComponent("el-icon");
+    const _component_el_button = vue.resolveComponent("el-button");
+    const _component_el_upload = vue.resolveComponent("el-upload");
+    const _component_el_link = vue.resolveComponent("el-link");
+
+    return (vue.openBlock(), vue.createElementBlock("div", _hoisted_1, [
+      vue.createVNode(_component_el_upload, {
+        ref_key: "fileUploadRef",
+        ref: fileUploadRef,
+        multiple: "",
+        action: __props.action,
+        "before-upload": handleBeforeUpload,
+        "file-list": fileList.value,
+        limit: __props.limit,
+        "on-error": handleUploadError,
+        "on-exceed": handleExceed,
+        "on-success": handleUploadSuccess,
+        "on-remove": handleRemove,
+        "show-file-list": false,
+        headers: __props.headers,
+        class: "upload-file-uploader"
+      }, {
+        default: vue.withCtx(() => [
+          vue.createCommentVNode(" 上传按钮 "),
+          vue.createVNode(_component_el_button, { type: "primary" }, {
+            default: vue.withCtx(() => [
+              vue.createVNode(_component_el_icon, { class: "el-icon--left" }, {
+                default: vue.withCtx(() => [
+                  vue.createVNode(vue.unref(iconsVue.Upload))
+                ]),
+                _: 1 /* STABLE */
+              }),
+              _cache[0] || (_cache[0] = vue.createTextVNode(" 选取文件 ", -1 /* CACHED */))
+            ]),
+            _: 1 /* STABLE */
+          })
+        ]),
+        _: 1 /* STABLE */
+      }, 8 /* PROPS */, ["action", "file-list", "limit", "headers"]),
+      vue.createCommentVNode(" 上传提示 "),
+      (showTip.value)
+        ? (vue.openBlock(), vue.createElementBlock("div", _hoisted_2, [
+            _cache[3] || (_cache[3] = vue.createTextVNode(" 请上传 ", -1 /* CACHED */)),
+            (__props.fileSize)
+              ? (vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: 0 }, [
+                  _cache[1] || (_cache[1] = vue.createTextVNode(" 大小不超过 ", -1 /* CACHED */)),
+                  vue.createElementVNode("b", _hoisted_3, vue.toDisplayString(__props.fileSize) + "MB", 1 /* TEXT */)
+                ], 64 /* STABLE_FRAGMENT */))
+              : vue.createCommentVNode("v-if", true),
+            (__props.fileType && __props.fileType.length)
+              ? (vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: 1 }, [
+                  _cache[2] || (_cache[2] = vue.createTextVNode(" 格式为 ", -1 /* CACHED */)),
+                  vue.createElementVNode("b", _hoisted_4, vue.toDisplayString(__props.fileType.join("/")), 1 /* TEXT */)
+                ], 64 /* STABLE_FRAGMENT */))
+              : vue.createCommentVNode("v-if", true),
+            _cache[4] || (_cache[4] = vue.createTextVNode(" 的文件 ", -1 /* CACHED */))
+          ]))
+        : vue.createCommentVNode("v-if", true),
+      vue.createCommentVNode(" 文件列表 "),
+      vue.createVNode(vue.TransitionGroup, {
+        class: "upload-file-list el-upload-list el-upload-list--text",
+        name: "el-fade-in-linear",
+        tag: "ul"
+      }, {
+        default: vue.withCtx(() => [
+          (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(fileList.value, (file, index) => {
+            return (vue.openBlock(), vue.createElementBlock("li", {
+              key: file.uid || index,
+              class: "el-upload-list__item ele-upload-list__item-content"
+            }, [
+              vue.createVNode(_component_el_link, {
+                href: getFileUrl(file.url),
+                underline: "never",
+                target: "_blank"
+              }, {
+                default: vue.withCtx(() => [
+                  vue.createVNode(_component_el_icon, { class: "el-icon--left" }, {
+                    default: vue.withCtx(() => [
+                      vue.createVNode(vue.unref(iconsVue.Document))
+                    ]),
+                    _: 1 /* STABLE */
+                  }),
+                  vue.createElementVNode("span", null, vue.toDisplayString(getFileName(file.name)), 1 /* TEXT */)
+                ]),
+                _: 2 /* DYNAMIC */
+              }, 1032 /* PROPS, DYNAMIC_SLOTS */, ["href"]),
+              vue.createElementVNode("div", _hoisted_5, [
+                vue.createVNode(_component_el_link, {
+                  underline: "never",
+                  onClick: $event => (handleDelete(index)),
+                  type: "danger"
+                }, {
+                  default: vue.withCtx(() => [...(_cache[5] || (_cache[5] = [
+                    vue.createTextVNode("删除", -1 /* CACHED */)
+                  ]))]),
+                  _: 1 /* STABLE */
+                }, 8 /* PROPS */, ["onClick"])
+              ])
+            ]))
+          }), 128 /* KEYED_FRAGMENT */))
+        ]),
+        _: 1 /* STABLE */
+      })
+    ]))
+  }
+  }
+
+  });
+  var FileUpload = /*#__PURE__*/_export_sfc(_sfc_main, [['__scopeId',"data-v-cc8b9b13"]]);
+
+  const EasyFileUpload = withInstall(FileUpload);
+
+  /**
+   *
+   * @param {*} component 组件
+   * @param {*} componentProps 组件属性
+   * @param {*} modalProps 对话框属性
+   * @param {*} context 上下文
+   * @returns Promise
+   */
+  const useDialog = (component, componentProps = {}, modalProps = {}, context = null) => {
+    // 如果 component 是字符串，转换为渲染函数
+    const contentComponent = isString(component) ? { render: () => vue.h("div", component) } : vue.markRaw(component);
+
+    const {
+      title = "提示",
+      confirmButtonText = "确 认",
+      cancelButtonText = "取 消",
+      showConfirmButton = true,
+      showCancelButton = true,
+      methodKey = "submit",
+      beforeClose,
+      onConfirm,
+      onCancel,
+      footer,
+      draggable = true,
+      ...dialogProps
+    } = modalProps;
+
+    const visible = vue.ref(true);
+    const loading = vue.ref(false);
+    const componentRef = vue.ref(null);
+
+    const appContext = context || getGlobalAppContext();
+
+    const div = document.createElement("div");
+    document.body.appendChild(div);
+
+    return new Promise((resolve, reject) => {
+      let app = null;
+      let isSettled = false; // 标记 Promise 是否已完成，防止重复触发
+
+      // 销毁
+      const destroy = () => {
+        if (app) {
+          app.unmount();
+          app = null;
+        }
+        if (div.parentNode) {
+          div.parentNode.removeChild(div);
+        }
+      };
+
+      // 关闭
+      const close = () => {
+        visible.value = false;
+      };
+
+      // 统一处理 Promise 结束逻辑
+      const handleAction = async (action, data) => {
+        if (isSettled) return
+        isSettled = true;
+        if (action === "resolve") resolve(data);
+        else reject(data);
+        close();
+      };
+
+      // 确认
+      const handleConfirm = async () => {
+        loading.value = true;
+        try {
+          const target = componentRef.value;
+          // 调用组件方法
+          if (target && methodKey && isFunction$1(target[methodKey])) {
+            await target[methodKey]();
+          }
+          // 调用 onConfirm
+          if (isFunction$1(onConfirm)) {
+            await onConfirm(target);
+          }
+          // 返回 resolve
+          await handleAction("resolve", target);
+        } catch (e) {
+          isSettled = false; // 失败时不沉淀状态，允许用户修正后重试
+          reject(e);
+        } finally {
+          loading.value = false;
+        }
+      };
+
+      // 取消
+      const handleCancel = () => {
+        if (isFunction$1(onCancel)) onCancel();
+        handleAction("reject", "closed");
+      };
+
+      // DialogApp
+      const DialogApp = {
+        setup() {
+          return () =>
+            vue.h(
+              elementPlus.ElDialog,
+              {
+                ...dialogProps,
+                modelValue: visible.value,
+                "onUpdate:modelValue": val => {
+                  visible.value = val;
+                  if (!val && !isSettled) handleAction("reject", "closed");
+                },
+                title,
+                draggable,
+                destroyOnClose: true,
+                onClosed: destroy, // 动画结束后彻底回收
+                // 拦截右上角 X 和遮罩层点击
+                beforeClose: done => {
+                  if (beforeClose) {
+                    beforeClose(() => {
+                      if (!isSettled) handleAction("reject", "closed");
+                      done();
+                    });
+                  } else {
+                    if (!isSettled) handleAction("reject", "closed");
+                    done();
+                  }
+                }
+              },
+              {
+                // 默认内容 渲染组件
+                default: () => vue.h(contentComponent, { ...componentProps, ref: componentRef }),
+
+                // 底部内容
+                footer: () => {
+                  // 自定义 footer
+                  if (footer) {
+                    return isFunction$1(footer)
+                      ? footer({ close: handleCancel, confirm: handleConfirm, loading: loading.value })
+                      : footer
+                  }
+                  return vue.h("div", { class: "dialog-footer" }, [
+                    // 取消按钮
+                    showCancelButton && vue.h(elementPlus.ElButton, { onClick: handleCancel }, () => cancelButtonText),
+                    // 确认按钮
+                    showConfirmButton &&
+                      vue.h(
+                        elementPlus.ElButton,
+                        {
+                          type: "primary",
+                          loading: loading.value,
+                          onClick: handleConfirm
+                        },
+                        () => confirmButtonText
+                      )
+                  ])
+                }
+              }
+            )
+        }
+      };
+
+      app = vue.createApp(DialogApp);
+
+      // 优化：上下文继承
+      if (appContext) {
+        // 核心插件继承 (避免直接操作 _context 私有属性的风险)
+        // 如果你的 getGlobalAppContext 已经拿到了真实的 context，可以这样同步
+        Object.assign(app._context, {
+          ...appContext,
+          reload: app._context.reload // 保留新应用的 reload 方法
+        });
+
+        // 必须手动同步 provides 以确保 inject 可用
+        app._context.provides = { ...(appContext.provides || {}), ...app._context.provides };
+      }
+
+      app.mount(div);
+    })
+  };
+
+  // Dialog 是一个命令式 API（函数式调用），而非 Vue 组件
+  // 用法: const dialog = useDialog(component, props, options)
+  // 或者: import { EasyDialog } from "@easy-elplus"; EasyDialog(...)
+
+
+  // 导出命名函数，保持与其他组件命名一致性
+  const EasyDialog = useDialog;
+
+  // 组件列表
+  const components = [EasyButton, EasyDescriptions, EasyTable, EasyImageUpload, EasyFileUpload];
+
+  // 是否已安装标识（防止重复 install）
+  const INSTALLED_KEY = Symbol("INSTALLED_KEY");
+
+  // 组件库插件
+  const EasyElementPlus = {
+    install(app) {
+      // 防止重复安装
+      if (app[INSTALLED_KEY]) return
+
+      app[INSTALLED_KEY] = true;
+
+      // 保存全局应用上下文，供 EasyDialog 等工具使用
+      // 这样即使在非组件上下文中调用，也能访问到主应用的插件和全局组件
+      setGlobalAppContext(app._context);
+
+      // 逐个安装组件
+      components.forEach(component => {
+        app.use(component);
+      });
+    }
+  };
+
+  exports.EasyButton = EasyButton;
+  exports.EasyDescriptions = EasyDescriptions;
+  exports.EasyDialog = EasyDialog;
+  exports.EasyFileUpload = EasyFileUpload;
+  exports.EasyImageUpload = EasyImageUpload;
+  exports.EasyTable = EasyTable;
+  exports.default = EasyElementPlus;
+  exports.useDialog = useDialog;
+
+  Object.defineProperty(exports, '__esModule', { value: true });
+
+}));