@douyinfe/semi-ui 2.53.2 → 2.53.3-alpha.1

package/dist/umd/semi-ui.js

@@ -3062,6 +3062,367 @@ function toDate(argument) {
 }
 module.exports = exports.default;
 
+/***/ }),
+
+/***/ "Q0m1":
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+(function (global, factory) {
+     true ? module.exports = factory() :
+    0;
+})(this, (function () { 'use strict';
+
+    var toStringFunction = Function.prototype.toString;
+    var create = Object.create, defineProperty = Object.defineProperty, getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor, getOwnPropertyNames = Object.getOwnPropertyNames, getOwnPropertySymbols = Object.getOwnPropertySymbols, getPrototypeOf$1 = Object.getPrototypeOf;
+    var _a = Object.prototype, hasOwnProperty = _a.hasOwnProperty, propertyIsEnumerable = _a.propertyIsEnumerable;
+    var SYMBOL_PROPERTIES = typeof getOwnPropertySymbols === 'function';
+    var WEAK_MAP = typeof WeakMap === 'function';
+    /**
+     * @function createCache
+     *
+     * @description
+     * get a new cache object to prevent circular references
+     *
+     * @returns the new cache object
+     */
+    var createCache = (function () {
+        if (WEAK_MAP) {
+            return function () { return new WeakMap(); };
+        }
+        var Cache = /** @class */ (function () {
+            function Cache() {
+                this._keys = [];
+                this._values = [];
+            }
+            Cache.prototype.has = function (key) {
+                return !!~this._keys.indexOf(key);
+            };
+            Cache.prototype.get = function (key) {
+                return this._values[this._keys.indexOf(key)];
+            };
+            Cache.prototype.set = function (key, value) {
+                this._keys.push(key);
+                this._values.push(value);
+            };
+            return Cache;
+        }());
+        return function () { return new Cache(); };
+    })();
+    /**
+     * @function getCleanClone
+     *
+     * @description
+     * get an empty version of the object with the same prototype it has
+     *
+     * @param object the object to build a clean clone from
+     * @param realm the realm the object resides in
+     * @returns the empty cloned object
+     */
+    var getCleanClone = function (object, realm) {
+        var prototype = object.__proto__ || getPrototypeOf$1(object);
+        if (!prototype) {
+            return create(null);
+        }
+        var Constructor = prototype.constructor;
+        if (Constructor === realm.Object) {
+            return prototype === realm.Object.prototype ? {} : create(prototype);
+        }
+        if (~toStringFunction.call(Constructor).indexOf('[native code]')) {
+            try {
+                return new Constructor();
+            }
+            catch (_a) { }
+        }
+        return create(prototype);
+    };
+    /**
+     * @function getObjectCloneLoose
+     *
+     * @description
+     * get a copy of the object based on loose rules, meaning all enumerable keys
+     * and symbols are copied, but property descriptors are not considered
+     *
+     * @param object the object to clone
+     * @param realm the realm the object resides in
+     * @param handleCopy the function that handles copying the object
+     * @returns the copied object
+     */
+    var getObjectCloneLoose = function (object, realm, handleCopy, cache) {
+        var clone = getCleanClone(object, realm);
+        // set in the cache immediately to be able to reuse the object recursively
+        cache.set(object, clone);
+        for (var key in object) {
+            if (hasOwnProperty.call(object, key)) {
+                clone[key] = handleCopy(object[key], cache);
+            }
+        }
+        if (SYMBOL_PROPERTIES) {
+            var symbols = getOwnPropertySymbols(object);
+            for (var index = 0, length_1 = symbols.length, symbol = void 0; index < length_1; ++index) {
+                symbol = symbols[index];
+                if (propertyIsEnumerable.call(object, symbol)) {
+                    clone[symbol] = handleCopy(object[symbol], cache);
+                }
+            }
+        }
+        return clone;
+    };
+    /**
+     * @function getObjectCloneStrict
+     *
+     * @description
+     * get a copy of the object based on strict rules, meaning all keys and symbols
+     * are copied based on the original property descriptors
+     *
+     * @param object the object to clone
+     * @param realm the realm the object resides in
+     * @param handleCopy the function that handles copying the object
+     * @returns the copied object
+     */
+    var getObjectCloneStrict = function (object, realm, handleCopy, cache) {
+        var clone = getCleanClone(object, realm);
+        // set in the cache immediately to be able to reuse the object recursively
+        cache.set(object, clone);
+        var properties = SYMBOL_PROPERTIES
+            ? getOwnPropertyNames(object).concat(getOwnPropertySymbols(object))
+            : getOwnPropertyNames(object);
+        for (var index = 0, length_2 = properties.length, property = void 0, descriptor = void 0; index < length_2; ++index) {
+            property = properties[index];
+            if (property !== 'callee' && property !== 'caller') {
+                descriptor = getOwnPropertyDescriptor(object, property);
+                if (descriptor) {
+                    // Only clone the value if actually a value, not a getter / setter.
+                    if (!descriptor.get && !descriptor.set) {
+                        descriptor.value = handleCopy(object[property], cache);
+                    }
+                    try {
+                        defineProperty(clone, property, descriptor);
+                    }
+                    catch (error) {
+                        // Tee above can fail on node in edge cases, so fall back to the loose assignment.
+                        clone[property] = descriptor.value;
+                    }
+                }
+                else {
+                    // In extra edge cases where the property descriptor cannot be retrived, fall back to
+                    // the loose assignment.
+                    clone[property] = handleCopy(object[property], cache);
+                }
+            }
+        }
+        return clone;
+    };
+    /**
+     * @function getRegExpFlags
+     *
+     * @description
+     * get the flags to apply to the copied regexp
+     *
+     * @param regExp the regexp to get the flags of
+     * @returns the flags for the regexp
+     */
+    var getRegExpFlags = function (regExp) {
+        var flags = '';
+        if (regExp.global) {
+            flags += 'g';
+        }
+        if (regExp.ignoreCase) {
+            flags += 'i';
+        }
+        if (regExp.multiline) {
+            flags += 'm';
+        }
+        if (regExp.unicode) {
+            flags += 'u';
+        }
+        if (regExp.sticky) {
+            flags += 'y';
+        }
+        return flags;
+    };
+
+    // utils
+    var isArray = Array.isArray;
+    var getPrototypeOf = Object.getPrototypeOf;
+    var GLOBAL_THIS = (function () {
+        if (typeof globalThis !== 'undefined') {
+            return globalThis;
+        }
+        if (typeof self !== 'undefined') {
+            return self;
+        }
+        if (typeof window !== 'undefined') {
+            return window;
+        }
+        if (typeof __webpack_require__.g !== 'undefined') {
+            return __webpack_require__.g;
+        }
+        if (console && console.error) {
+            console.error('Unable to locate global object, returning "this".');
+        }
+        return this;
+    })();
+    /**
+     * @function copy
+     *
+     * @description
+     * copy an value deeply as much as possible
+     *
+     * If `strict` is applied, then all properties (including non-enumerable ones)
+     * are copied with their original property descriptors on both objects and arrays.
+     *
+     * The value is compared to the global constructors in the `realm` provided,
+     * and the native constructor is always used to ensure that extensions of native
+     * objects (allows in ES2015+) are maintained.
+     *
+     * @param value the value to copy
+     * @param [options] the options for copying with
+     * @param [options.isStrict] should the copy be strict
+     * @param [options.realm] the realm (this) value the value is copied from
+     * @returns the copied value
+     */
+    function copy(value, options) {
+        // manually coalesced instead of default parameters for performance
+        var isStrict = !!(options && options.isStrict);
+        var realm = (options && options.realm) || GLOBAL_THIS;
+        var getObjectClone = isStrict ? getObjectCloneStrict : getObjectCloneLoose;
+        /**
+         * @function handleCopy
+         *
+         * @description
+         * copy the value recursively based on its type
+         *
+         * @param value the value to copy
+         * @returns the copied value
+         */
+        var handleCopy = function (value, cache) {
+            if (!value || typeof value !== 'object') {
+                return value;
+            }
+            if (cache.has(value)) {
+                return cache.get(value);
+            }
+            var prototype = value.__proto__ || getPrototypeOf(value);
+            var Constructor = prototype && prototype.constructor;
+            // plain objects
+            if (!Constructor || Constructor === realm.Object) {
+                return getObjectClone(value, realm, handleCopy, cache);
+            }
+            var clone;
+            // arrays
+            if (isArray(value)) {
+                // if strict, include non-standard properties
+                if (isStrict) {
+                    return getObjectCloneStrict(value, realm, handleCopy, cache);
+                }
+                clone = new Constructor();
+                cache.set(value, clone);
+                for (var index = 0, length_1 = value.length; index < length_1; ++index) {
+                    clone[index] = handleCopy(value[index], cache);
+                }
+                return clone;
+            }
+            // dates
+            if (value instanceof realm.Date) {
+                return new Constructor(value.getTime());
+            }
+            // regexps
+            if (value instanceof realm.RegExp) {
+                clone = new Constructor(value.source, value.flags || getRegExpFlags(value));
+                clone.lastIndex = value.lastIndex;
+                return clone;
+            }
+            // maps
+            if (realm.Map && value instanceof realm.Map) {
+                clone = new Constructor();
+                cache.set(value, clone);
+                value.forEach(function (value, key) {
+                    clone.set(key, handleCopy(value, cache));
+                });
+                return clone;
+            }
+            // sets
+            if (realm.Set && value instanceof realm.Set) {
+                clone = new Constructor();
+                cache.set(value, clone);
+                value.forEach(function (value) {
+                    clone.add(handleCopy(value, cache));
+                });
+                return clone;
+            }
+            // blobs
+            if (realm.Blob && value instanceof realm.Blob) {
+                return value.slice(0, value.size, value.type);
+            }
+            // buffers (node-only)
+            if (realm.Buffer && realm.Buffer.isBuffer(value)) {
+                clone = realm.Buffer.allocUnsafe
+                    ? realm.Buffer.allocUnsafe(value.length)
+                    : new Constructor(value.length);
+                cache.set(value, clone);
+                value.copy(clone);
+                return clone;
+            }
+            // arraybuffers / dataviews
+            if (realm.ArrayBuffer) {
+                // dataviews
+                if (realm.ArrayBuffer.isView(value)) {
+                    clone = new Constructor(value.buffer.slice(0));
+                    cache.set(value, clone);
+                    return clone;
+                }
+                // arraybuffers
+                if (value instanceof realm.ArrayBuffer) {
+                    clone = value.slice(0);
+                    cache.set(value, clone);
+                    return clone;
+                }
+            }
+            // if the value cannot / should not be cloned, don't
+            if (
+            // promise-like
+            typeof value.then === 'function' ||
+                // errors
+                value instanceof Error ||
+                // weakmaps
+                (realm.WeakMap && value instanceof realm.WeakMap) ||
+                // weaksets
+                (realm.WeakSet && value instanceof realm.WeakSet)) {
+                return value;
+            }
+            // assume anything left is a custom constructor
+            return getObjectClone(value, realm, handleCopy, cache);
+        };
+        return handleCopy(value, createCache());
+    }
+    // Adding reference to allow usage in CommonJS libraries compiled using TSC, which
+    // expects there to be a default property on the exported value. See
+    // [#37](https://github.com/planttheidea/fast-copy/issues/37) for details.
+    copy.default = copy;
+    /**
+     * @function strictCopy
+     *
+     * @description
+     * copy the value with `strict` option pre-applied
+     *
+     * @param value the value to copy
+     * @param [options] the options for copying with
+     * @param [options.realm] the realm (this) value the value is copied from
+     * @returns the copied value
+     */
+    copy.strict = function strictCopy(value, options) {
+        return copy(value, {
+            isStrict: true,
+            realm: options ? options.realm : void 0,
+        });
+    };
+
+    return copy;
+
+}));
+//# sourceMappingURL=fast-copy.js.map
+
+
 /***/ }),
 
 /***/ "QF3D":
@@ -17161,7 +17522,7 @@ module.exports = exports.default;
 /******/ 		};
 /******/ 	
 /******/ 		// Execute the module function
-/******/ 		__webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+/******/ 		__webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);
 /******/ 	
 /******/ 		// Flag the module as loaded
 /******/ 		module.loaded = true;
@@ -23257,7 +23618,7 @@ class Base extends external_root_React_commonjs2_react_commonjs_react_amd_react_
       copied: false,
       // ellipsis
       // if text is overflow in container
-      isOverflowed: true,
+      isOverflowed: false,
       ellipsisContent: props.children,
       expanded: false,
       // if text is truncated with js
@@ -53989,406 +54350,9 @@ function getDefaultPickerDate(options) {
     nextDate: nextDate
   };
 }
-;// CONCATENATED MODULE: ../../node_modules/fast-copy/dist/esm/index.mjs
-var toStringFunction = Function.prototype.toString;
-var create = Object.create;
-var toStringObject = Object.prototype.toString;
-/**
- * @classdesc Fallback cache for when WeakMap is not natively supported
- */
-var LegacyCache = /** @class */ (function () {
-    function LegacyCache() {
-        this._keys = [];
-        this._values = [];
-    }
-    LegacyCache.prototype.has = function (key) {
-        return !!~this._keys.indexOf(key);
-    };
-    LegacyCache.prototype.get = function (key) {
-        return this._values[this._keys.indexOf(key)];
-    };
-    LegacyCache.prototype.set = function (key, value) {
-        this._keys.push(key);
-        this._values.push(value);
-    };
-    return LegacyCache;
-}());
-function createCacheLegacy() {
-    return new LegacyCache();
-}
-function createCacheModern() {
-    return new WeakMap();
-}
-/**
- * Get a new cache object to prevent circular references.
- */
-var createCache = typeof WeakMap !== 'undefined' ? createCacheModern : createCacheLegacy;
-/**
- * Get an empty version of the object with the same prototype it has.
- */
-function getCleanClone(prototype) {
-    if (!prototype) {
-        return create(null);
-    }
-    var Constructor = prototype.constructor;
-    if (Constructor === Object) {
-        return prototype === Object.prototype ? {} : create(prototype);
-    }
-    if (~toStringFunction.call(Constructor).indexOf('[native code]')) {
-        try {
-            return new Constructor();
-        }
-        catch (_a) { }
-    }
-    return create(prototype);
-}
-function getRegExpFlagsLegacy(regExp) {
-    var flags = '';
-    if (regExp.global) {
-        flags += 'g';
-    }
-    if (regExp.ignoreCase) {
-        flags += 'i';
-    }
-    if (regExp.multiline) {
-        flags += 'm';
-    }
-    if (regExp.unicode) {
-        flags += 'u';
-    }
-    if (regExp.sticky) {
-        flags += 'y';
-    }
-    return flags;
-}
-function getRegExpFlagsModern(regExp) {
-    return regExp.flags;
-}
-/**
- * Get the flags to apply to the copied regexp.
- */
-var getRegExpFlags = /test/g.flags === 'g' ? getRegExpFlagsModern : getRegExpFlagsLegacy;
-function getTagLegacy(value) {
-    var type = toStringObject.call(value);
-    return type.substring(8, type.length - 1);
-}
-function getTagModern(value) {
-    return value[Symbol.toStringTag] || getTagLegacy(value);
-}
-/**
- * Get the tag of the value passed, so that the correct copier can be used.
- */
-var getTag = typeof Symbol !== 'undefined' ? getTagModern : getTagLegacy;
-
-var defineProperty = Object.defineProperty, getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor, getOwnPropertyNames = Object.getOwnPropertyNames, getOwnPropertySymbols = Object.getOwnPropertySymbols;
-var _a = Object.prototype, esm_hasOwnProperty = _a.hasOwnProperty, propertyIsEnumerable = _a.propertyIsEnumerable;
-var SUPPORTS_SYMBOL = typeof getOwnPropertySymbols === 'function';
-function getStrictPropertiesModern(object) {
-    return getOwnPropertyNames(object).concat(getOwnPropertySymbols(object));
-}
-/**
- * Get the properites used when copying objects strictly. This includes both keys and symbols.
- */
-var getStrictProperties = SUPPORTS_SYMBOL
-    ? getStrictPropertiesModern
-    : getOwnPropertyNames;
-/**
- * Striclty copy all properties contained on the object.
- */
-function copyOwnPropertiesStrict(value, clone, state) {
-    var properties = getStrictProperties(value);
-    for (var index = 0, length_1 = properties.length, property = void 0, descriptor = void 0; index < length_1; ++index) {
-        property = properties[index];
-        if (property === 'callee' || property === 'caller') {
-            continue;
-        }
-        descriptor = getOwnPropertyDescriptor(value, property);
-        if (!descriptor) {
-            // In extra edge cases where the property descriptor cannot be retrived, fall back to
-            // the loose assignment.
-            clone[property] = state.copier(value[property], state);
-            continue;
-        }
-        // Only clone the value if actually a value, not a getter / setter.
-        if (!descriptor.get && !descriptor.set) {
-            descriptor.value = state.copier(descriptor.value, state);
-        }
-        try {
-            defineProperty(clone, property, descriptor);
-        }
-        catch (error) {
-            // Tee above can fail on node in edge cases, so fall back to the loose assignment.
-            clone[property] = descriptor.value;
-        }
-    }
-    return clone;
-}
-/**
- * Deeply copy the indexed values in the array.
- */
-function copyArrayLoose(array, state) {
-    var clone = new state.Constructor();
-    // set in the cache immediately to be able to reuse the object recursively
-    state.cache.set(array, clone);
-    for (var index = 0, length_2 = array.length; index < length_2; ++index) {
-        clone[index] = state.copier(array[index], state);
-    }
-    return clone;
-}
-/**
- * Deeply copy the indexed values in the array, as well as any custom properties.
- */
-function copyArrayStrict(array, state) {
-    var clone = new state.Constructor();
-    // set in the cache immediately to be able to reuse the object recursively
-    state.cache.set(array, clone);
-    return copyOwnPropertiesStrict(array, clone, state);
-}
-/**
- * Copy the contents of the ArrayBuffer.
- */
-function copyArrayBuffer(arrayBuffer, _state) {
-    return arrayBuffer.slice(0);
-}
-/**
- * Create a new Blob with the contents of the original.
- */
-function copyBlob(blob, _state) {
-    return blob.slice(0, blob.size, blob.type);
-}
-/**
- * Create a new DataView with the contents of the original.
- */
-function copyDataView(dataView, state) {
-    return new state.Constructor(copyArrayBuffer(dataView.buffer));
-}
-/**
- * Create a new Date based on the time of the original.
- */
-function copyDate(date, state) {
-    return new state.Constructor(date.getTime());
-}
-/**
- * Deeply copy the keys and values of the original.
- */
-function copyMapLoose(map, state) {
-    var clone = new state.Constructor();
-    // set in the cache immediately to be able to reuse the object recursively
-    state.cache.set(map, clone);
-    map.forEach(function (value, key) {
-        clone.set(key, state.copier(value, state));
-    });
-    return clone;
-}
-/**
- * Deeply copy the keys and values of the original, as well as any custom properties.
- */
-function copyMapStrict(map, state) {
-    return copyOwnPropertiesStrict(map, copyMapLoose(map, state), state);
-}
-function copyObjectLooseLegacy(object, state) {
-    var clone = getCleanClone(state.prototype);
-    // set in the cache immediately to be able to reuse the object recursively
-    state.cache.set(object, clone);
-    for (var key in object) {
-        if (esm_hasOwnProperty.call(object, key)) {
-            clone[key] = state.copier(object[key], state);
-        }
-    }
-    return clone;
-}
-function copyObjectLooseModern(object, state) {
-    var clone = getCleanClone(state.prototype);
-    // set in the cache immediately to be able to reuse the object recursively
-    state.cache.set(object, clone);
-    for (var key in object) {
-        if (esm_hasOwnProperty.call(object, key)) {
-            clone[key] = state.copier(object[key], state);
-        }
-    }
-    var symbols = getOwnPropertySymbols(object);
-    for (var index = 0, length_3 = symbols.length, symbol = void 0; index < length_3; ++index) {
-        symbol = symbols[index];
-        if (propertyIsEnumerable.call(object, symbol)) {
-            clone[symbol] = state.copier(object[symbol], state);
-        }
-    }
-    return clone;
-}
-/**
- * Deeply copy the properties (keys and symbols) and values of the original.
- */
-var copyObjectLoose = SUPPORTS_SYMBOL
-    ? copyObjectLooseModern
-    : copyObjectLooseLegacy;
-/**
- * Deeply copy the properties (keys and symbols) and values of the original, as well
- * as any hidden or non-enumerable properties.
- */
-function copyObjectStrict(object, state) {
-    var clone = getCleanClone(state.prototype);
-    // set in the cache immediately to be able to reuse the object recursively
-    state.cache.set(object, clone);
-    return copyOwnPropertiesStrict(object, clone, state);
-}
-/**
- * Create a new primitive wrapper from the value of the original.
- */
-function copyPrimitiveWrapper(primitiveObject, state) {
-    return new state.Constructor(primitiveObject.valueOf());
-}
-/**
- * Create a new RegExp based on the value and flags of the original.
- */
-function copyRegExp(regExp, state) {
-    var clone = new state.Constructor(regExp.source, getRegExpFlags(regExp));
-    clone.lastIndex = regExp.lastIndex;
-    return clone;
-}
-/**
- * Return the original value (an identity function).
- *
- * @note
- * THis is used for objects that cannot be copied, such as WeakMap.
- */
-function copySelf(value, _state) {
-    return value;
-}
-/**
- * Deeply copy the values of the original.
- */
-function copySetLoose(set, state) {
-    var clone = new state.Constructor();
-    // set in the cache immediately to be able to reuse the object recursively
-    state.cache.set(set, clone);
-    set.forEach(function (value) {
-        clone.add(state.copier(value, state));
-    });
-    return clone;
-}
-/**
- * Deeply copy the values of the original, as well as any custom properties.
- */
-function copySetStrict(set, state) {
-    return copyOwnPropertiesStrict(set, copySetLoose(set, state), state);
-}
-
-var esm_isArray = Array.isArray;
-var esm_assign = Object.assign;
-var getPrototypeOf = Object.getPrototypeOf || (function (obj) { return obj.__proto__; });
-var DEFAULT_LOOSE_OPTIONS = {
-    array: copyArrayLoose,
-    arrayBuffer: copyArrayBuffer,
-    blob: copyBlob,
-    dataView: copyDataView,
-    date: copyDate,
-    error: copySelf,
-    map: copyMapLoose,
-    object: copyObjectLoose,
-    regExp: copyRegExp,
-    set: copySetLoose,
-};
-var DEFAULT_STRICT_OPTIONS = esm_assign({}, DEFAULT_LOOSE_OPTIONS, {
-    array: copyArrayStrict,
-    map: copyMapStrict,
-    object: copyObjectStrict,
-    set: copySetStrict,
-});
-/**
- * Get the copiers used for each specific object tag.
- */
-function getTagSpecificCopiers(options) {
-    return {
-        Arguments: options.object,
-        Array: options.array,
-        ArrayBuffer: options.arrayBuffer,
-        Blob: options.blob,
-        Boolean: copyPrimitiveWrapper,
-        DataView: options.dataView,
-        Date: options.date,
-        Error: options.error,
-        Float32Array: options.arrayBuffer,
-        Float64Array: options.arrayBuffer,
-        Int8Array: options.arrayBuffer,
-        Int16Array: options.arrayBuffer,
-        Int32Array: options.arrayBuffer,
-        Map: options.map,
-        Number: copyPrimitiveWrapper,
-        Object: options.object,
-        Promise: copySelf,
-        RegExp: options.regExp,
-        Set: options.set,
-        String: copyPrimitiveWrapper,
-        WeakMap: copySelf,
-        WeakSet: copySelf,
-        Uint8Array: options.arrayBuffer,
-        Uint8ClampedArray: options.arrayBuffer,
-        Uint16Array: options.arrayBuffer,
-        Uint32Array: options.arrayBuffer,
-        Uint64Array: options.arrayBuffer,
-    };
-}
-/**
- * Create a custom copier based on the object-specific copy methods passed.
- */
-function createCopier(options) {
-    var normalizedOptions = esm_assign({}, DEFAULT_LOOSE_OPTIONS, options);
-    var tagSpecificCopiers = getTagSpecificCopiers(normalizedOptions);
-    var array = tagSpecificCopiers.Array, object = tagSpecificCopiers.Object;
-    function copier(value, state) {
-        state.prototype = state.Constructor = undefined;
-        if (!value || typeof value !== 'object') {
-            return value;
-        }
-        if (state.cache.has(value)) {
-            return state.cache.get(value);
-        }
-        state.prototype = getPrototypeOf(value);
-        state.Constructor = state.prototype && state.prototype.constructor;
-        // plain objects
-        if (!state.Constructor || state.Constructor === Object) {
-            return object(value, state);
-        }
-        // arrays
-        if (esm_isArray(value)) {
-            return array(value, state);
-        }
-        var tagSpecificCopier = tagSpecificCopiers[getTag(value)];
-        if (tagSpecificCopier) {
-            return tagSpecificCopier(value, state);
-        }
-        return typeof value.then === 'function' ? value : object(value, state);
-    }
-    return function copy(value) {
-        return copier(value, {
-            Constructor: undefined,
-            cache: createCache(),
-            copier: copier,
-            prototype: undefined,
-        });
-    };
-}
-/**
- * Create a custom copier based on the object-specific copy methods passed, defaulting to the
- * same internals as `copyStrict`.
- */
-function createStrictCopier(options) {
-    return createCopier(esm_assign({}, DEFAULT_STRICT_OPTIONS, options));
-}
-/**
- * Copy an value deeply as much as possible, where strict recreation of object properties
- * are maintained. All properties (including non-enumerable ones) are copied with their
- * original property descriptors on both objects and arrays.
- */
-var copyStrict = createStrictCopier({});
-/**
- * Copy an value deeply as much as possible.
- */
-var index = createCopier({});
-
-
-//# sourceMappingURL=index.mjs.map
-
+// EXTERNAL MODULE: ../../node_modules/fast-copy/dist/fast-copy.js
+var fast_copy = __webpack_require__("Q0m1");
+var fast_copy_default = /*#__PURE__*/__webpack_require__.n(fast_copy);
 ;// CONCATENATED MODULE: ../semi-foundation/datePicker/inputFoundation.ts
 
 
@@ -54505,7 +54469,7 @@ class inputFoundation_InputFoundation extends foundation {
       type,
       format
     });
-    const newInsetInputValue = set_default()(index(insetInputValue), valuePath, value);
+    const newInsetInputValue = set_default()(fast_copy_default()(insetInputValue), valuePath, value);
     const insetInputStr = this.concatInsetInputValue({
       insetInputValue: newInsetInputValue
     });
@@ -54539,7 +54503,7 @@ class inputFoundation_InputFoundation extends foundation {
       defaultPickerValue,
       dateFnsLocale
     } = this._adapter.getProps();
-    const insetInputValueWithTime = index(insetInputValue);
+    const insetInputValueWithTime = fast_copy_default()(insetInputValue);
     const {
       nowDate,
       nextDate
@@ -58660,7 +58624,7 @@ class YearAndMonthFoundation extends foundation {
     } = this.getProps();
     const left = datePicker_constants_strings.PANEL_TYPE_LEFT;
     const right = datePicker_constants_strings.PANEL_TYPE_RIGHT;
-    const year = index(currentYear);
+    const year = fast_copy_default()(currentYear);
     year[panelType] = item.value;
     // make sure the right panel time is always less than the left panel time
     if (type === 'monthRange') {
@@ -58687,7 +58651,7 @@ class YearAndMonthFoundation extends foundation {
     } = this.getProps();
     const left = datePicker_constants_strings.PANEL_TYPE_LEFT;
     const right = datePicker_constants_strings.PANEL_TYPE_RIGHT;
-    const month = index(currentMonth);
+    const month = fast_copy_default()(currentMonth);
     month[panelType] = item.month;
     // make sure the right panel time is always less than the left panel time
     if (type === 'monthRange' && panelType === left && currentYear[left] === currentYear[right] && item.value > month[right]) {
@@ -58734,7 +58698,7 @@ class YearAndMonthFoundation extends foundation {
         });
       }
       if (validMonth) {
-        const month = index(currentMonth);
+        const month = fast_copy_default()(currentMonth);
         month[panelType] = validMonth.month;
         // change year and month same time
         this._adapter.setCurrentYearAndMonth(year, month);
@@ -68231,7 +68195,7 @@ class OverflowListFoundation extends foundation {
       const {
         items
       } = this.getProps();
-      return index(items).reverse();
+      return fast_copy_default()(items).reverse();
     };
   }
   getOverflowItem() {
@@ -68259,7 +68223,7 @@ class OverflowListFoundation extends foundation {
     return overflowList;
   }
   handleIntersect(entries) {
-    const visibleState = index(this.getState('visibleState'));
+    const visibleState = fast_copy_default()(this.getState('visibleState'));
     const res = {};
     entries.forEach(entry => {
       const itemKey = get_default()(entry, 'target.dataset.scrollkey');
@@ -78682,7 +78646,7 @@ class TableFoundation extends foundation {
     if (defaultExpandAllRows || expandAllRows) {
       this._addNoDuplicatedItemsToArr(expandedRowKeys, this.getAllRowKeys(dataSource), groups && isMap_default()(groups) && groups.size ? Array.from(groups.keys()) : []);
     } else if (defaultExpandAllGroupRows || expandAllGroupRows) {
-      this._addNoDuplicatedItemsToArr(expandedRowKeys, groups && isMap_default()(groups) && groups.size ? Array.from(groups.keys()) : []);
+      this._addNoDuplicatedItemsToArr(expandedRowKeys, propExpandedRowKeys, groups && isMap_default()(groups) && groups.size ? Array.from(groups.keys()) : []);
     } else if (Array.isArray(defaultExpandedRowKeys) && defaultExpandedRowKeys.length) {
       this._addNoDuplicatedItemsToArr(expandedRowKeys, defaultExpandedRowKeys);
     } else if (Array.isArray(propExpandedRowKeys) && propExpandedRowKeys.length) {
@@ -78968,8 +78932,6 @@ class TableFoundation extends foundation {
   }
   /**
    * Add non-repeating elements to the array itself
-   * @param {Array} srcArr
-   * @param {Object} objArrs
    */
   _addNoDuplicatedItemsToArr() {
     let srcArr = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
@@ -96797,7 +96759,7 @@ function mergeProps(props) {
   delete rest.defaultValue;
   delete rest.checked;
   if (typeof initValue !== 'undefined') {
-    initValue = index(initValue);
+    initValue = fast_copy_default()(initValue);
   }
   const required = isRequired(rules);
   emptyValue = typeof emptyValue !== 'undefined' ? emptyValue : '';
@@ -98946,8 +98908,8 @@ class ArrayFieldComponent extends external_root_React_commonjs2_react_commonjs_r
     // whether the fields inside arrayField should use props.initValue in current render process
     this.shouldUseInitValue = !context.getArrayField(field);
     // Separate the arrays that reset and the usual add and remove modify, otherwise they will affect each other
-    const initValueCopyForFormState = index(initValue);
-    const initValueCopyForReset = index(initValue);
+    const initValueCopyForFormState = fast_copy_default()(initValue);
+    const initValueCopyForReset = fast_copy_default()(initValue);
     context.registerArrayField(field, initValueCopyForReset);
     // register ArrayField will update state.updateKey to render, So there is no need to execute forceUpdate here
     context.updateStateValue(field, initValueCopyForFormState, {