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

package/dist/umd/semi-ui.js

@@ -3062,367 +3062,6 @@ 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":
@@ -17522,7 +17161,7 @@ module.exports = exports.default;
 /******/ 		};
 /******/ 	
 /******/ 		// Execute the module function
-/******/ 		__webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);
+/******/ 		__webpack_modules__[moduleId](module, module.exports, __webpack_require__);
 /******/ 	
 /******/ 		// Flag the module as loaded
 /******/ 		module.loaded = true;
@@ -23618,7 +23257,7 @@ class Base extends external_root_React_commonjs2_react_commonjs_react_amd_react_
       copied: false,
       // ellipsis
       // if text is overflow in container
-      isOverflowed: false,
+      isOverflowed: true,
       ellipsisContent: props.children,
       expanded: false,
       // if text is truncated with js
@@ -27277,8 +26916,8 @@ class Avatar extends BaseComponent {
     }
   }
   render() {
-    var _a, _b;
-    const _c = this.props,
+    var _a;
+    const _b = this.props,
       {
         shape,
         children,
@@ -27297,8 +26936,8 @@ class Avatar extends BaseComponent {
         topSlot,
         border,
         contentMotion
-      } = _c,
-      others = avatar_rest(_c, ["shape", "children", "size", "color", "className", "hoverMask", "onClick", "imgAttr", "src", "srcSet", "style", "alt", "gap", "bottomSlot", "topSlot", "border", "contentMotion"]);
+      } = _b,
+      others = avatar_rest(_b, ["shape", "children", "size", "color", "className", "hoverMask", "onClick", "imgAttr", "src", "srcSet", "style", "alt", "gap", "bottomSlot", "topSlot", "border", "contentMotion"]);
     const {
       isImgExist,
       hoverContent,
@@ -27328,8 +26967,8 @@ class Avatar extends BaseComponent {
     }), this.getContent(), hoverRender);
     if (border) {
       const borderStyle = {};
-      if (border === null || border === void 0 ? void 0 : border.color) {
-        borderStyle['borderColor'] = border.color;
+      if (typeof border === 'object' && (border === null || border === void 0 ? void 0 : border.color)) {
+        borderStyle['borderColor'] = border === null || border === void 0 ? void 0 : border.color;
       }
       avatar = /*#__PURE__*/external_root_React_commonjs2_react_commonjs_react_amd_react_default().createElement("div", {
         style: Object.assign({
@@ -27340,11 +26979,11 @@ class Avatar extends BaseComponent {
         className: classnames_default()([`${avatar_prefixCls}-additionalBorder`, `${avatar_prefixCls}-additionalBorder-${size}`, {
           [`${avatar_prefixCls}-${shape}`]: shape
         }])
-      }), ((_a = this.props.border) === null || _a === void 0 ? void 0 : _a.motion) && /*#__PURE__*/external_root_React_commonjs2_react_commonjs_react_amd_react_default().createElement("span", {
+      }), typeof this.props.border === 'object' && this.props.border.motion && /*#__PURE__*/external_root_React_commonjs2_react_commonjs_react_amd_react_default().createElement("span", {
         style: borderStyle,
         className: classnames_default()([`${avatar_prefixCls}-additionalBorder`, `${avatar_prefixCls}-additionalBorder-${size}`, {
           [`${avatar_prefixCls}-${shape}`]: shape,
-          [`${avatar_prefixCls}-additionalBorder-animated`]: (_b = this.props.border) === null || _b === void 0 ? void 0 : _b.motion
+          [`${avatar_prefixCls}-additionalBorder-animated`]: typeof this.props.border === 'object' && ((_a = this.props.border) === null || _a === void 0 ? void 0 : _a.motion)
         }])
       }));
     }
@@ -54350,9 +53989,406 @@ function getDefaultPickerDate(options) {
     nextDate: nextDate
   };
 }
-// 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: ../../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
+
 ;// CONCATENATED MODULE: ../semi-foundation/datePicker/inputFoundation.ts
 
 
@@ -54469,7 +54505,7 @@ class inputFoundation_InputFoundation extends foundation {
       type,
       format
     });
-    const newInsetInputValue = set_default()(fast_copy_default()(insetInputValue), valuePath, value);
+    const newInsetInputValue = set_default()(index(insetInputValue), valuePath, value);
     const insetInputStr = this.concatInsetInputValue({
       insetInputValue: newInsetInputValue
     });
@@ -54503,7 +54539,7 @@ class inputFoundation_InputFoundation extends foundation {
       defaultPickerValue,
       dateFnsLocale
     } = this._adapter.getProps();
-    const insetInputValueWithTime = fast_copy_default()(insetInputValue);
+    const insetInputValueWithTime = index(insetInputValue);
     const {
       nowDate,
       nextDate
@@ -58624,7 +58660,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 = fast_copy_default()(currentYear);
+    const year = index(currentYear);
     year[panelType] = item.value;
     // make sure the right panel time is always less than the left panel time
     if (type === 'monthRange') {
@@ -58651,7 +58687,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 = fast_copy_default()(currentMonth);
+    const month = index(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]) {
@@ -58698,7 +58734,7 @@ class YearAndMonthFoundation extends foundation {
         });
       }
       if (validMonth) {
-        const month = fast_copy_default()(currentMonth);
+        const month = index(currentMonth);
         month[panelType] = validMonth.month;
         // change year and month same time
         this._adapter.setCurrentYearAndMonth(year, month);
@@ -68195,7 +68231,7 @@ class OverflowListFoundation extends foundation {
       const {
         items
       } = this.getProps();
-      return fast_copy_default()(items).reverse();
+      return index(items).reverse();
     };
   }
   getOverflowItem() {
@@ -68223,7 +68259,7 @@ class OverflowListFoundation extends foundation {
     return overflowList;
   }
   handleIntersect(entries) {
-    const visibleState = fast_copy_default()(this.getState('visibleState'));
+    const visibleState = index(this.getState('visibleState'));
     const res = {};
     entries.forEach(entry => {
       const itemKey = get_default()(entry, 'target.dataset.scrollkey');
@@ -96759,7 +96795,7 @@ function mergeProps(props) {
   delete rest.defaultValue;
   delete rest.checked;
   if (typeof initValue !== 'undefined') {
-    initValue = fast_copy_default()(initValue);
+    initValue = index(initValue);
   }
   const required = isRequired(rules);
   emptyValue = typeof emptyValue !== 'undefined' ? emptyValue : '';
@@ -98908,8 +98944,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 = fast_copy_default()(initValue);
-    const initValueCopyForReset = fast_copy_default()(initValue);
+    const initValueCopyForFormState = index(initValue);
+    const initValueCopyForReset = index(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, {