@codady/utils 0.0.10 → 0.0.11

package/dist/utils.umd - /345/211/257/346/234/254.js"

@@ -0,0 +1,749 @@
+
+/*!
+ * @since Last modified: 2025-12-24 17:11:26
+ * @name Utils for web front-end.
+ * @version 0.0.10
+ * @author AXUI development team <3217728223@qq.com>
+ * @description This is a set of general-purpose JavaScript utility functions developed by the AXUI team. All functions are pure and do not involve CSS or other third-party libraries. They are suitable for any web front-end environment.
+ * @see {@link https://www.axui.cn|Official website}
+ * @see {@link https://github.com/codady/utils/issues|github issues}
+ * @see {@link https://gitee.com/codady/utils/issues|Gitee issues}
+ * @see {@link https://www.npmjs.com/package/@codady/utils|NPM}
+ * @issue QQ Group No.1:952502085
+ * @copyright This software supports the MIT License, allowing free learning and commercial use, but please retain the terms 'ax,' 'axui,' 'AX,' and 'AXUI' within the software.
+ * @license MIT license
+ */
+
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory(require('assert')) :
+    typeof define === 'function' && define.amd ? define(['assert'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.utils = factory(global.assert));
+})(this, (function (assert) { 'use strict';
+
+    const getDataType = (obj) => {
+        let tmp = Object.prototype.toString.call(obj).slice(8, -1), result;
+        if (tmp === 'Function' && /^\s*class\s+/.test(obj.toString())) {
+            result = 'Class';
+        }
+        else if (tmp === 'Object' && Object.getPrototypeOf(obj) !== Object.prototype) {
+            result = 'Instance';
+        }
+        else {
+            result = tmp;
+        }
+        return result;
+        //document.createElement -> HTMLxxxElement
+        //document.createDocumentFragment() -> DocumentFragment
+        //document.createComment() -> Comment
+        //document.createTextNode -> Text
+        //document.createCDATASection() -> XMLDocument
+        //document.createProcessingInstruction() -> ProcessingInstruction
+        //document.createRange() -> Range
+        //document.createTreeWalker() -> TreeWalker
+        //document.createNodeIterator() -> NodeIterator
+        //document.createElementNS('http://www.w3.org/2000/svg', 'svg'); -> SVGSVGElement
+        //document.createElementNS('http://www.w3.org/1998/Math/MathML', 'math'); -> MathMLElement
+    };
+
+    //支持原始值的复制，包括Number、String、Boolean、Null
+    //支持Date和Regex对象值复制（值转换）
+    //支持{},[],Set和Map的遍历
+    const deepClone = (data, options = {}) => {
+        const dataType = getDataType(data), 
+        // Default options
+        opts = Object.assign({
+            cloneSet: true,
+            cloneMap: true,
+            cloneObject: true,
+            cloneArray: true,
+            //可重新构建
+            cloneDate: true,
+            cloneRegex: true,
+            //节点默认不复制
+            //cloneElement: false,
+            //cloneFragment: false,
+        }, options);
+        // Check interceptor - if it returns a value (not null/undefined), use it directly
+        if (opts.interceptor && typeof opts.interceptor === 'function') {
+            let result = opts.interceptor(data, dataType);
+            if ((result ?? false)) {
+                // Call onAfterClone if set
+                opts.onAfterClone?.({
+                    output: result,
+                    input: data,
+                    type: dataType,
+                    cloned: result !== data,
+                });
+                return result;
+            }
+            // If interceptor returns null/undefined, continue with normal cloning process
+        }
+        // Callback before cloning
+        opts.onBeforeClone?.(data, dataType);
+        let newData, cloned = true;
+        if (dataType === 'Object' && opts.cloneObject) {
+            const newObj = {}, symbols = Object.getOwnPropertySymbols(data);
+            // Clone regular properties
+            for (const key in data) {
+                newObj[key] = deepClone(data[key], opts);
+            }
+            // Clone Symbol properties
+            if (symbols.length > 0) {
+                for (const symbol of symbols) {
+                    newObj[symbol] = deepClone(data[symbol], opts);
+                }
+            }
+            newData = newObj;
+        }
+        else if (dataType === 'Array' && opts.cloneArray) {
+            newData = data.map(item => deepClone(item, opts));
+        }
+        else if (dataType === 'Map' && opts.cloneMap) {
+            const newMap = new Map();
+            for (const [key, value] of data) {
+                // Both Map keys and values need deep cloning
+                newMap.set(deepClone(key, opts), deepClone(value, opts));
+            }
+            newData = newMap;
+        }
+        else if (dataType === 'Set' && opts.cloneSet) {
+            const newSet = new Set();
+            for (const value of data) {
+                // Set values need deep cloning
+                newSet.add(deepClone(value, opts));
+            }
+            newData = newSet;
+        }
+        else if (dataType === 'Date' && opts.cloneDate) {
+            newData = new Date(data.getTime());
+        }
+        else if (dataType === 'RegExp' && opts.cloneRegex) {
+            const regex = data;
+            newData = new RegExp(regex.source, regex.flags);
+            // } else if ((dataType.includes('HTML') && opts.cloneElement) ||
+            //    (dataType === 'DocumentFragment' && opts.cloneFragment)
+            //) {
+            //Text,Comment,HTML*Element,DocumentFragment,Attr
+            //     newData = (data as any).cloneNode(true) as T;
+        }
+        else {
+            // Number, String, Boolean, Symbol, Function,Error,Promise,ArrayBuffer,Blob,File, return directly
+            newData = data;
+            cloned = false;
+        }
+        // Callback after cloning
+        opts.onAfterClone?.({
+            output: newData,
+            input: data,
+            type: dataType,
+            cloned,
+        });
+        return newData;
+    };
+
+    const deepCloneToJSON = (data) => {
+        const dataType = getDataType(data);
+        // Handle objects
+        if (dataType === 'Object') {
+            const newObj = {};
+            // Clone regular properties
+            for (const key in data) {
+                newObj[key] = deepCloneToJSON(data[key]);
+            }
+            for (const key in newObj) {
+                newObj[key] === undefined && Reflect.deleteProperty(newObj, key);
+            }
+            return newObj;
+            // Handle arrays
+        }
+        else if (dataType === 'Array') {
+            let tmp = data.map((item, index) => deepCloneToJSON(item)).filter(item => item !== undefined);
+            return tmp;
+            // Handle Date objects
+        }
+        else if (!['Number', 'String', 'Boolean', 'Null'].includes(dataType)) {
+            return undefined;
+        }
+        else {
+            return data;
+        }
+    };
+
+    const arrayMutableMethods = [
+        'push', 'pop', 'shift', 'unshift', 'splice',
+        'sort', 'reverse', 'copyWithin', 'fill'
+    ];
+
+    const wrapArrayMethods = ({ target, onBeforeMutate = () => { }, onAfterMutate = () => { }, allowList, props = {}, }) => {
+        // Validation: Ensure target is an array and method is allowed
+        if (!Array.isArray(target)) {
+            throw new TypeError("The 'target' parameter must be an array.");
+        }
+        //使用默认
+        if (!allowList || allowList?.length) {
+            allowList = arrayMutableMethods;
+        }
+        const methods = {};
+        for (let method of allowList) {
+            methods[method] = function (...args) {
+                const context = {}, len = target.length;
+                // Capture "Pre-mutation" context for Undo/Redo/Tracking purposes
+                switch (method) {
+                    // 'push' and 'unshift' are add operations, in undo/redo, 
+                    // we can determine the original data structure from result.length and args.length
+                    // but methods that involve deletion need to record the deleted items to ensure the patch can restore the data structure during undo
+                    case 'push':
+                    case 'unshift':
+                        context.addedItems = [...args];
+                        break;
+                    case 'pop':
+                        context.poppedItem = target[len - 1];
+                        break;
+                    case 'shift':
+                        context.shiftedItem = target[0];
+                        break;
+                    case 'splice':
+                        const [s, d] = args, 
+                        // Calculate actual start index (handling negative values)
+                        start = s < 0 ? Math.max(len + s, 0) : Math.min(s, len), 
+                        // Handle deleteCount defaults
+                        deleteCount = d === undefined ? len - start : d;
+                        context.deletedItems = target.slice(start, start + deleteCount);
+                        break;
+                    case 'sort':
+                    case 'reverse':
+                        // These methods reorder the whole array; requires a full shallow copy
+                        context.oldSnapshot = [...target];
+                        break;
+                    case 'fill':
+                    case 'copyWithin':
+                        const startIdx = args[1] || 0, endIdx = args[2] === undefined ? len : args[2];
+                        // Overwritten values
+                        context.oldItems = target.slice(startIdx, endIdx);
+                        context.start = startIdx;
+                        context.end = endIdx;
+                        break;
+                }
+                // Execute the "onBeforeMutate" callback before mutation
+                onBeforeMutate?.(context);
+                // Execute the native array mutation
+                const value = Array.prototype[method].apply(target, args), patch = {
+                    value,
+                    key: method,
+                    args,
+                    context,
+                    target,
+                    ...props
+                };
+                // Construct and trigger the patch callback
+                onAfterMutate?.(patch);
+                return value;
+            };
+        }
+        return methods;
+    };
+
+    const requireTypes = (data, require, cb) => {
+        // Normalize the input types (convert to array if it's a single type)
+        let requiredTypes = Array.isArray(require) ? require : [require], dataType = getDataType(data), typeLower = dataType.toLowerCase(), 
+        // Normalize the type names (to lower case)
+        normalizedTypes = requiredTypes.map((type) => type.toLowerCase()), 
+        // Check if the type is an HTML element (more specific than just 'html')
+        normalizedDataType = typeLower.includes('html') ? 'element' : typeLower;
+        // If callback exists, handle error through callback
+        if (cb) {
+            try {
+                if (!normalizedTypes.includes(normalizedDataType)) {
+                    throw new TypeError(`Expected data type(s): [${normalizedTypes.join(', ')}], but got: ${normalizedDataType}`);
+                }
+            }
+            catch (error) {
+                cb(error, dataType);
+            }
+        }
+        else {
+            // If no callback is provided, throw an error directly
+            if (!normalizedTypes.includes(normalizedDataType)) {
+                throw new TypeError(`Expected data type(s): [${normalizedTypes.join(', ')}], but got: ${normalizedDataType}`);
+            }
+        }
+        return dataType;
+    };
+
+    const getUniqueId = (options = {}) => {
+        const prefix = options.prefix, suffix = options.suffix, base10 = options.base10, base36 = options.base36;
+        // Current timestamp in milliseconds (since Unix epoch)
+        // This provides the primary uniqueness guarantee
+        const timestamp = Date.now(), 
+        // Generate a base-36 random string (0-9, a-z)
+        // Math.random() returns a number in [0, 1), converting to base-36 gives a compact representation
+        // substring(2, 11) extracts 9 characters starting from index 2
+        //0.259854635->0.9crs03e8v2
+        base36Random = base36 ? '-' + Math.random().toString(36).substring(2, 11) : '', 
+        // Additional 4-digit random number for extra randomness
+        // This helps avoid collisions in high-frequency generation scenarios
+        base10Random = base10 ? '-' + Math.floor(Math.random() * 10000).toString().padStart(4, '0') : '', prefixString = prefix ? prefix + '-' : '', suffixString = suffix ? '-' + suffix : '';
+        // Construct the final ID string
+        // Format: [prefix_]timestamp_randomBase36_extraRandom
+        return `${prefixString}${timestamp}${base36Random}${base10Random}${suffixString}`;
+    };
+
+    const setMutableMethods = ['add', 'delete', 'clear'];
+
+    const mapMutableMethods = ['set', 'delete', 'clear'];
+
+    const wrapSetMethods = ({ target, onBeforeMutate = () => { }, onAfterMutate = () => { }, allowList = setMutableMethods, props = {}, }) => {
+        // Validation: Ensure target is a Set
+        if (!(target instanceof Set)) {
+            throw new TypeError("The 'target' parameter must be a Set.");
+        }
+        // Create method wrappers
+        const methods = {};
+        // Helper to create wrapped method
+        const createWrappedMethod = (method) => {
+            return function (...args) {
+                const context = {};
+                // Capture pre-mutation context based on method
+                switch (method) {
+                    case 'add': {
+                        const [value] = args;
+                        context.addedItem = value;
+                        //context.existed=true，说明值重复
+                        context.existed = target.has(value);
+                        break;
+                    }
+                    case 'delete': {
+                        const [value] = args;
+                        context.existed = target.has(value);
+                        context.deletedItem = context.existed ? value : undefined;
+                        break;
+                    }
+                    case 'clear': {
+                        context.clearedItems = Array.from(target);
+                        //用来做验证
+                        context.previousSize = target.size;
+                        break;
+                    }
+                }
+                // Execute before mutation callback
+                onBeforeMutate(context);
+                // Execute the native Set method
+                const result = target[method].apply(target, args);
+                // Construct patch object
+                const patch = {
+                    method,
+                    result,
+                    args,
+                    context,
+                    target,
+                    ...props
+                };
+                // Execute after mutation callback
+                onAfterMutate(patch);
+                return result;
+            };
+        };
+        // Wrap allowed methods
+        for (const method of allowList) {
+            if (setMutableMethods.includes(method)) {
+                methods[method] = createWrappedMethod(method);
+            }
+        }
+        // Add target reference
+        Object.defineProperty(methods, 'target', {
+            get: () => target,
+            enumerable: false,
+            configurable: false
+        });
+        return methods;
+    };
+
+    const wrapMapMethods = ({ target, onBeforeMutate = () => { }, onAfterMutate = () => { }, allowList = mapMutableMethods, props = {}, }) => {
+        // Validation: Ensure target is a Map
+        if (!(target instanceof Map)) {
+            throw new TypeError("The 'target' parameter must be a Map.");
+        }
+        // Create method wrappers
+        const methods = {};
+        // Helper to create wrapped method
+        const createWrappedMethod = (method) => {
+            return function (...args) {
+                const context = {};
+                // Capture pre-mutation context based on method
+                switch (method) {
+                    case 'set': {
+                        const [key, newValue] = args;
+                        context.key = key;
+                        context.newValue = newValue;
+                        context.existed = target.has(key);
+                        context.oldValue = context.existed ? target.get(key) : undefined;
+                        break;
+                    }
+                    case 'delete': {
+                        const [key] = args;
+                        context.key = key;
+                        context.existed = target.has(key);
+                        context.value = context.existed ? target.get(key) : undefined;
+                        break;
+                    }
+                    case 'clear': {
+                        context.clearedItems = Array.from(target.entries());
+                        //用来做验证
+                        context.previousSize = target.size;
+                        break;
+                    }
+                }
+                // Execute before mutation callback
+                onBeforeMutate(context);
+                // Execute the native Map method
+                const result = target[method].apply(target, args);
+                // Construct patch object
+                const patch = {
+                    method,
+                    result,
+                    args,
+                    context,
+                    target,
+                    ...props
+                };
+                // Execute after mutation callback
+                onAfterMutate(patch);
+                return result;
+            };
+        };
+        // Wrap allowed methods
+        for (const method of allowList) {
+            if (mapMutableMethods.includes(method)) {
+                methods[method] = createWrappedMethod(method);
+            }
+        }
+        // Add target reference
+        Object.defineProperty(methods, 'target', {
+            get: () => target,
+            enumerable: false,
+            configurable: false
+        });
+        return methods;
+    };
+
+    const deepEqual = (a, b) => {
+        // If both are equal by reference
+        if (a === b)
+            return true;
+        // If both are arrays, check equality recursively
+        if (Array.isArray(a) && Array.isArray(b)) {
+            if (a.length !== b.length)
+                return false;
+            for (let i = 0; i < a.length; i++) {
+                if (!deepEqual(a[i], b[i]))
+                    return false;
+            }
+            return true;
+        }
+        // If both are objects, check equality recursively
+        if (typeof a === 'object' && typeof b === 'object') {
+            const keysA = Object.keys(a), keysB = Object.keys(b);
+            if (keysA.length !== keysB.length)
+                return false;
+            for (let key of keysA) {
+                if (!keysB.includes(key) || !deepEqual(a[key], b[key]))
+                    return false;
+            }
+            return true;
+        }
+        // For other types, direct comparison
+        return a === b;
+    };
+
+    const deepMergeMaps = (target, source, options = { itemMode: 'merge', propAppend: true, targetClone: false, useEnable: true }) => {
+        // Ensure both target and source are Maps
+        if (!(target instanceof Map) || !(source instanceof Map))
+            return target;
+        // Merge options, with default values
+        const opts = Object.assign({ itemMode: 'merge', propAppend: true, targetClone: false, useEnable: true }, options), 
+        // If cloning is enabled, create a deep copy of the target Map
+        result = opts.targetClone ? new Map(target) : target;
+        // Handle different merge strategies based on itemMode
+        if (opts.itemMode === 'replace') {
+            // Replace mode: clear the target Map and add all entries from the source Map
+            result.clear();
+            source.forEach((value, key) => result.set(key, value));
+            return result;
+        }
+        else if (opts.itemMode === 'concat') {
+            // Concatenate mode: add all entries from the source Map to the target Map
+            source.forEach((value, key) => result.set(key, value));
+            return result;
+        }
+        else {
+            // Default "merge" mode: recursively merge entries in the Maps
+            source.forEach((value, key) => {
+                // Check if the key already exists in the target Map
+                if (result.has(key)) {
+                    const targetValue = result.get(key), sourceValue = value;
+                    const targetType = getDataType(targetValue), sourceType = getDataType(sourceValue);
+                    // If both target and source values are of the same type, merge them
+                    if (targetType === sourceType) {
+                        if (targetType === 'Object') {
+                            // If both target and source are objects, merge them recursively
+                            result.set(key, deepMergeObjects(targetValue, sourceValue, opts));
+                        }
+                        else if (targetType === 'Array') {
+                            // If both target and source are arrays, merge them recursively
+                            deepMergeArrays(targetValue, sourceValue, opts);
+                        }
+                        else if (targetType === 'Map') {
+                            // If both target and source are Maps, merge them recursively
+                            deepMergeMaps(targetValue, sourceValue, opts);
+                        }
+                        else if (targetType === 'Set') {
+                            // If both target and source are Sets, merge them recursively
+                            deepMergeSets(targetValue, sourceValue, opts);
+                        }
+                        else {
+                            // For simple values, overwrite the target value with the source value
+                            result.set(key, sourceValue);
+                        }
+                    }
+                    else {
+                        // If types don't match, overwrite the target value with the source value
+                        result.set(key, sourceValue);
+                    }
+                }
+                else {
+                    // If the key doesn't exist in the target, add the entry from the source Map
+                    result.set(key, value);
+                }
+            });
+            return result;
+        }
+    };
+
+    const deepMergeSets = (target, source, options = { itemMode: 'merge', propAppend: true, targetClone: false, useEnable: true }) => {
+        // Ensure both target and source are Sets
+        if (!(target instanceof Set) || !(source instanceof Set))
+            return target;
+        // Merge options, with default values
+        const opts = Object.assign({ itemMode: 'merge', propAppend: true, targetClone: false, useEnable: true }, options), 
+        // If cloning is enabled, create a deep copy of the target Set
+        result = opts.targetClone ? new Set(target) : target;
+        // Handle different merge strategies based on itemMode
+        if (opts.itemMode === 'replace') {
+            // Replace mode: clear the target Set and add all items from the source Set
+            result.clear();
+            for (let item of source)
+                result.add(item);
+            return result;
+        }
+        else if (opts.itemMode === 'concat') {
+            // Concatenate mode: add all items from the source Set to the target Set
+            for (let item of source)
+                result.add(item);
+            return result;
+        }
+        else {
+            // Default "merge" mode: recursively merge items in the Sets
+            for (let item of source) {
+                // Check the type of the target and source items
+                const _target = [...result].find(val => deepEqual(val, item)), _targetType = getDataType(_target), // Find existing value in the target Set
+                _sourceType = getDataType(item);
+                // If both target and source are arrays, merge them recursively
+                if (_targetType === 'Array' && _sourceType === 'Array') {
+                    deepMergeArrays(_target, item, opts);
+                    // If both target and source are objects, merge them recursively
+                }
+                else if (_targetType === 'Object' && _sourceType === 'Object') {
+                    deepMergeObjects(_target, item, opts);
+                    // If both target and source are Maps, merge them recursively
+                }
+                else if (_targetType === 'Map' && _sourceType === 'Map') {
+                    deepMergeMaps(_target, item, opts);
+                    // If both target and source are Sets, merge them recursively
+                }
+                else if (_targetType === 'Set' && _sourceType === 'Set') {
+                    deepMergeSets(_target, item, opts);
+                    // If the items are simple values, add them directly
+                }
+                else {
+                    result.add(item);
+                }
+            }
+            return result;
+        }
+    };
+
+    const deepMergeArrays = (target, source, options = { itemMode: 'merge', propAppend: true, targetClone: false, useEnable: true }) => {
+        // Ensure both target and source are arrays
+        if (!Array.isArray(target) || !Array.isArray(source))
+            return target;
+        // Merge options, with default values
+        const opts = Object.assign({ itemMode: 'merge', propAppend: true, targetClone: false }, options), 
+        // If cloning is enabled, create a deep copy of the target array
+        result = opts.targetClone ? [...target] : target;
+        // Handle different merge strategies based on itemMode
+        if (opts.itemMode === 'replace') {
+            // Replace mode: clear the target array and push all items from the source array
+            result.length = 0;
+            result.push(...source);
+            return result;
+        }
+        else if (opts.itemMode === 'concat') {
+            // Concatenate mode: append all items from the source array to the target array
+            result.push(...source);
+            return result;
+        }
+        else {
+            // Default "merge" mode: recursively merge items in the arrays
+            for (let i = 0; i < source.length; i++) {
+                const _targetType = getDataType(result[i]), _sourceType = getDataType(source[i]);
+                // If both target and source are arrays, merge them recursively
+                if (_targetType === 'Array' && _sourceType === 'Array') {
+                    deepMergeArrays(result[i], source[i], opts);
+                    // If both target and source are objects, merge them recursively
+                }
+                else if (_targetType === 'Object' && _sourceType === 'Object') {
+                    deepMergeObjects(result[i], source[i], opts);
+                    // If both target and source are Maps, merge them recursively
+                }
+                else if (_targetType === 'Map' && _sourceType === 'Map') {
+                    deepMergeMaps(result[i], source[i], opts);
+                    // If both target and source are Sets, merge them recursively
+                }
+                else if (_targetType === 'Set' && _sourceType === 'Set') {
+                    deepMergeSets(result[i], source[i], opts);
+                    // If the items are simple values, replace them directly
+                }
+                else {
+                    result[i] = source[i];
+                }
+            }
+            return result;
+        }
+    };
+
+    const deepMergeObjects = (target, source, opts = {}) => {
+        let targetType = getDataType(target), sourceType = getDataType(source);
+        //target不是对象或者source为空则直接返回
+        if (targetType !== 'Object' || sourceType !== 'Object') {
+            return target;
+        }
+        const options = Object.assign({ itemMode: 'merge', propAppend: true, targetClone: false, useEnable: true }, opts), 
+        //如果是复制方法，则先复制target
+        result = options.targetClone ? deepClone(target) : target;
+        for (let k in source) {
+            if (source.hasOwnProperty(k) && result.hasOwnProperty(k)) {
+                let _resultType = getDataType(result[k]), _sourceType = getDataType(source[k]);
+                if (_resultType !== _sourceType) {
+                    //类型不同则直接覆盖
+                    if (options.useEnable && result.hasOwnProperty(k) && result[k]?.hasOwnProperty('enable') && typeof source[k] === 'boolean') {
+                        //部分替换，仅针对result={enable:true/false,a:''}，source=false/true这种情况和相反的情况，因为这种情况再笨框架比较多见  
+                        if (result[k]?.hasOwnProperty('enable') && typeof source[k] === 'boolean') {
+                            //result={enable:true,a:'',b:''},source[k]=false=>result={enable:false,a:'',b:''}
+                            result[k].enable = source[k];
+                        }
+                        else if (source[k]?.hasOwnProperty('enable') && typeof result[k] === 'boolean') {
+                            //source={enable:true,a:'',b:''},(result as any)[k]=false=>result={enable:false,a:'',b:''}
+                            result = Object.assign({ enable: result[k] }, source[k]);
+                        }
+                        else {
+                            //完全替换
+                            result[k] = source[k];
+                        }
+                    }
+                    else {
+                        //完全替换
+                        result[k] = source[k];
+                    }
+                }
+                else {
+                    //类型相同
+                    if (_sourceType === 'Object') {
+                        //如果遇上对象则深度复制
+                        result[k] = deepMergeObjects(result[k], source[k], options);
+                    }
+                    else if (_sourceType === 'Array') {
+                        //如果遇上数组，且arrAppend为true追加模式，则在尾部追加数组
+                        deepMergeArrays(result[k], source[k], options);
+                    }
+                    else if (_sourceType === 'Map') {
+                        //如果遇上数组，且arrAppend为true追加模式，则在尾部追加数组
+                        deepMergeMaps(result[k], source[k], options);
+                    }
+                    else if (_sourceType === 'Set') {
+                        //如果遇上数组，且arrAppend为true追加模式，则在尾部追加数组
+                        deepMergeSets(result[k], source[k], options);
+                    }
+                    else {
+                        //其他清空则直接覆盖
+                        result[k] = source[k];
+                    }
+                }
+            }
+            else if (source.hasOwnProperty(k) && !result.hasOwnProperty(k) && options.propAppend) {
+                //如果source有属性，result没有该属性，但是options允许追加属性则直接赋值
+                result[k] = source[k];
+            }
+        }
+        //Symbol键直接追加，因为Symbol是唯一，结果同Object.assign
+        if (options.useSymbol) {
+            let symbols = Object.getOwnPropertySymbols(source);
+            if (symbols.length > 0) {
+                for (let k of symbols) {
+                    result[k] = source[k];
+                }
+            }
+        }
+        return result;
+    };
+
+    const deepMerge = (target, source, opts = {}) => {
+        // Get the data types of the target and source
+        let targetType = getDataType(target), sourceType = getDataType(source), options = Object.assign({
+            itemMode: 'merge', // Default merge mode
+            propAppend: true, // Default to appending properties from source to target
+            targetClone: false, // Do not clone target by default
+            useEnable: true // Enable special handling for objects with an `enable` property
+        }, opts);
+        if (targetType === 'Object' && sourceType === 'Object') {
+            return deepMergeObjects(target, source, options);
+        }
+        else if (targetType === 'Array' && sourceType === 'Array') {
+            return deepMergeArrays(target, source, options);
+        }
+        else if (targetType === 'Set' && sourceType === 'Set') {
+            return deepMergeSets(target, source, options);
+        }
+        else if (targetType === 'Map' && sourceType === 'Map') {
+            return deepMergeMaps(target, source, options);
+        }
+        else {
+            return target;
+        }
+    };
+
+    const utils = {
+        //executeStr,
+        getDataType,
+        requireTypes,
+        //renderTpl,
+        //parseStr,
+        deepClone,
+        deepCloneToJSON,
+        wrapArrayMethods,
+        arrayMutableMethods,
+        setMutableMethods,
+        mapMutableMethods,
+        wrapSetMethods,
+        wrapMapMethods,
+        getUniqueId,
+        deepEqual: assert.deepEqual,
+        deepMerge,
+        deepMergeArrays,
+        deepMergeMaps,
+        deepMergeObjects,
+        deepMergeSets,
+    };
+
+    return utils;
+
+}));