foreslash 0.2.4 → 0.3.0

package/CHANGELOG.md

@@ -1,15 +1,31 @@
 # Change Log
 
-## Version 0.2.4 - 2025-0
+## Version 0.3.0 - 2025-07-01
+
+Unstable version
+
+- Feat 🥥 Functions added: `capitalize` `deepMerge` `isBlob` and so forth
+- Feat 🥥 Function change: `deepClone` now support `Blob` and `File`
+- Other fixes and improvements
+
+不稳定版本
+
+- 功能 🥥 添加函数: `capitalize` `deepMerge` `isBlob` 等
+- 功能 🥥 变更函数: `deepClone` 现在支持 `Blob` 和 `File`
+- 其他修复与优化
+
+## Version 0.2.4 - 2025-05-29
 
 Unstable version
 
 - Feat 🥥 Functions added: `retry` `parallel`
+- Change 🥟 Dependencies change: upgrade devDependencies `rollup` `@rollup/plugin-typescript` `rollup-plugin-dts` `vitepress`
 - Other fixes and improvements
 
 不稳定版本
 
 - 功能 🥥 添加函数: `retry` `parallel`
+- 变更 🥟 依赖变更: 升级开发依赖 `rollup` `@rollup/plugin-typescript` `rollup-plugin-dts` `vitepress`
 - 其他修复与优化
 
 ## Version 0.2.3 - 2025-03-28

package/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2024 moushu
+Copyright (c) 2024-2025 moushu
 foreslash is licensed under Mulan PSL v2.
 You can use this software according to the terms and conditions of the Mulan PSL v2.
 You may obtain a copy of Mulan PSL v2 at:

package/lib/index.cmn.cjs

@@ -1,5 +1,5 @@
 /*!
-Copyright (c) 2024 moushu
+Copyright (c) 2024-2025 moushu
 foreslash is licensed under Mulan PSL v2.
 You can use this software according to the terms and conditions of the Mulan PSL v2.
 You may obtain a copy of Mulan PSL v2 at:
@@ -116,8 +116,8 @@ function getGlobalThis() {
     return Function('return this')();
 }
 
-const global$7 = getGlobalThis();
-const ArrayBuffer$1 = global$7.ArrayBuffer;
+const global$8 = getGlobalThis();
+const ArrayBuffer$1 = global$8.ArrayBuffer;
 function isArrayBuffer(val) {
     return !!ArrayBuffer$1 && val instanceof ArrayBuffer$1;
 }
@@ -134,6 +134,16 @@ function isBigInt(value) {
     return typeof value === 'bigint';
 }
 
+function isObject(value) {
+    return typeof value === 'object' && value !== null;
+}
+
+const global$7 = getGlobalThis();
+const Blob = global$7.Blob;
+function isBlob(value) {
+    return !!Blob && isObject(value) && getTag(value) === 'Blob';
+}
+
 function isBoolean(value) {
     return typeof value === 'boolean';
 }
@@ -142,10 +152,6 @@ const global$6 = getGlobalThis();
 const Buffer = global$6.Buffer;
 const isBuffer = (Buffer && Buffer.isBuffer) || (() => false);
 
-function isObject(value) {
-    return typeof value === 'object' && value !== null;
-}
-
 function isDataView(value) {
     return isObject(value) && getTag(value) === 'DataView';
 }
@@ -155,9 +161,9 @@ function isDate(value) {
 }
 
 const global$5 = getGlobalThis();
-const File = global$5.File;
+const File$1 = global$5.File;
 function isFile(value) {
-    return !!File && value instanceof File;
+    return !!File$1 && isObject(value) && getTag(value) === 'File';
 }
 
 const global$4 = getGlobalThis();
@@ -1251,6 +1257,12 @@ function titleCase(str, options) {
         : ({ code }) => code.slice(0, 1).toUpperCase() + code.slice(1).toLowerCase());
 }
 
+function capitalize(str) {
+    if (!str)
+        return str;
+    return str.charAt(0).toUpperCase() + str.slice(1);
+}
+
 function caseConvert(str, joiner = '', handler) {
     const hc = handler ? handler : (token) => token.code;
     return _caseConvert(_splitVar(str), joiner, hc);
@@ -1298,6 +1310,12 @@ function splitWords(str) {
     return _splitVar(str).map(({ code }) => code);
 }
 
+function uncapitalize(str) {
+    if (!str)
+        return str;
+    return str.charAt(0).toLowerCase() + str.slice(1);
+}
+
 function compose(...composeFunc) {
     if (composeFunc.length === 0) {
         throw new Error('Invalid composeFunc parameter: composeFunc is empty');
@@ -1539,6 +1557,16 @@ function _cloneArrayBuffer(obj, map) {
     new Uint8Array(res).set(new Uint8Array(obj));
     return res;
 }
+function _cloneBlob(obj, map) {
+    const res = obj.slice(0, obj.size, obj.type);
+    map.set(obj, res);
+    return res;
+}
+function _cloneFile(obj, map) {
+    const res = new File([obj], obj.name, { type: obj.type, lastModified: obj.lastModified });
+    map.set(obj, res);
+    return res;
+}
 
 function _deepClone(obj, map, options) {
     if (map.has(obj))
@@ -1583,6 +1611,12 @@ function _deepClone(obj, map, options) {
         res = new DataView(map.has(obj.buffer) ? map.get(obj.buffer) : _cloneArrayBuffer(obj.buffer, map), obj.byteOffset, obj.byteLength);
         map.set(obj, res);
     }
+    else if (isFile(obj)) {
+        res = _cloneFile(obj, map);
+    }
+    else if (isBlob(obj)) {
+        res = _cloneBlob(obj, map);
+    }
     else if (isWrapperObject(obj)) {
         res = Object(obj.valueOf());
         map.set(obj, res);
@@ -1617,6 +1651,201 @@ function deepClone(obj, options, map) {
     return res;
 }
 
+const $$Empty = Object.freeze({ '@@merge/placeholder': true });
+function getMergeStrategy(targetType, sourceType, strategy) {
+    return (strategy[`${sourceType}2${targetType}`] ||
+        strategy[`${sourceType}2Any`] ||
+        strategy[`Any2${targetType}`] ||
+        strategy[`Any2Any`] ||
+        'override');
+}
+function getBaseMargeType(obj) {
+    if (isMergeEmptyPlaceholder(obj))
+        return 'Empty';
+    const _tag = getTag(obj);
+    if (/Function/.test(_tag))
+        return 'Function';
+    if (/Iterator/.test(_tag))
+        return 'Iterator';
+    if (/(?:8|16|32|64)Array/.test(_tag))
+        return 'TypedArray';
+    if (/Error/.test(_tag))
+        return 'Error';
+    return _tag;
+}
+function isMergeEmptyPlaceholder(arg) {
+    return typeof arg === 'object' && Boolean(arg) && arg['@@merge/placeholder'] === true;
+}
+
+function _deepMergeBase(target, source, option, map, path, cloner) {
+    const targetType = getBaseMargeType(target);
+    const sourceType = getBaseMargeType(source);
+    const strategy = getMergeStrategy(targetType, sourceType, option.typeStrategy);
+    if (isFunction(strategy)) {
+        const merger = _curryMore(_deepMergeBase)(_, _, option, map, _, cloner);
+        const mergeRes = strategy({
+            target,
+            source,
+            cloner,
+            merger,
+            path,
+            typeStrategy: option.typeStrategy,
+            unhandledValue: $$Empty,
+            map,
+        });
+        if (!isMergeEmptyPlaceholder(mergeRes))
+            return mergeRes;
+    }
+    if (strategy === 'keep') {
+        if (isMergeEmptyPlaceholder(target))
+            return $$Empty;
+        return cloner(target);
+    }
+    else if (strategy === 'override') {
+        return cloner(source);
+    }
+    else {
+        return cloner(source);
+    }
+}
+const defaultMergeStrategy = {
+    Any2Any: 'override',
+    Any2Empty: 'override',
+    Any2Null: 'override',
+    Any2Undefined: 'override',
+    Null2Any: 'keep',
+    Undefined2Any: 'keep',
+    Null2Empty: 'override',
+    Undefined2Empty: 'override',
+    Number2Any: 'keep',
+    Number2Number: 'override',
+    String2Any: 'keep',
+    String2String: 'override',
+    Boolean2Any: 'keep',
+    Boolean2Boolean: 'override',
+    Symbol2Any: 'keep',
+    Symbol2Symbol: 'override',
+    BigInt2Any: 'keep',
+    BigInt2BigInt: 'override',
+    Number2Empty: 'override',
+    String2Empty: 'override',
+    Boolean2Empty: 'override',
+    Symbol2Empty: 'override',
+    BigInt2Empty: 'override',
+    Number2Null: 'override',
+    String2Null: 'override',
+    Boolean2Null: 'override',
+    Symbol2Null: 'override',
+    BigInt2Null: 'override',
+    Number2Undefined: 'override',
+    String2Undefined: 'override',
+    Boolean2Undefined: 'override',
+    Symbol2Undefined: 'override',
+    BigInt2Undefined: 'override',
+    Object2Object: (({ target, source, cloner, path, merger }) => {
+        const res = cloner(target);
+        Reflect.ownKeys(source).forEach((key) => {
+            const newPath = [...path, key];
+            if (key in res) {
+                res[key] = merger(res[key], source[key], newPath);
+            }
+            else {
+                const mergeRes = merger($$Empty, source[key], newPath);
+                if (!isMergeEmptyPlaceholder(mergeRes))
+                    res[key] = mergeRes;
+            }
+        });
+        return res;
+    }),
+    Object2FormData: (({ target, source, cloner, path, merger }) => {
+        const res = cloner(target);
+        Reflect.ownKeys(source).forEach((key) => {
+            if (isSymbol(key))
+                return;
+            const newPath = [...path, key];
+            if (res.has(key)) {
+                res.set(key, merger(res.get(key), source[key], newPath));
+            }
+            else {
+                const mergeRes = merger($$Empty, source[key], newPath);
+                if (!isMergeEmptyPlaceholder(mergeRes))
+                    res.set(key, mergeRes);
+            }
+        });
+        return res;
+    }),
+    FormData2Object: (({ target, source, cloner, path, merger }) => {
+        const res = cloner(target);
+        source.forEach((val, key) => {
+            const newPath = [...path, key];
+            if (key in res) {
+                res[key] = merger(res[key], val, newPath);
+            }
+            else {
+                const mergeRes = merger($$Empty, val, newPath);
+                if (!isMergeEmptyPlaceholder(mergeRes))
+                    res[key] = mergeRes;
+            }
+        });
+        return res;
+    }),
+    FormData2FormData: (({ target, source, cloner, path, merger }) => {
+        const res = cloner(target);
+        source.forEach((val, key) => {
+            const newPath = [...path, key];
+            if (res.has(key)) {
+                res.set(key, merger(res.get(key), val, newPath));
+            }
+            else {
+                const mergeRes = merger($$Empty, val, newPath);
+                if (!isMergeEmptyPlaceholder(mergeRes))
+                    res.set(key, mergeRes);
+            }
+        });
+        return res;
+    }),
+    Set2Set: (({ target, source, cloner }) => {
+        const res = cloner(target);
+        for (const item of source)
+            res.add(cloner(item));
+        return res;
+    }),
+    Map2Map: (({ target, source, cloner }) => {
+        const res = cloner(target);
+        for (const [key, val] of source)
+            res.set(cloner(key), cloner(val));
+        return res;
+    }),
+    Array2Array: (({ target, source, cloner }) => {
+        const res = cloner(target);
+        for (const item of source)
+            res.push(cloner(item));
+        return res;
+    }),
+    Set2Array: (({ target, source, cloner }) => {
+        const res = cloner(target);
+        for (const item of source)
+            res.push(cloner(item));
+        return res;
+    }),
+    Array2Set: (({ target, source, cloner }) => {
+        const res = cloner(target);
+        for (const item of source)
+            res.add(cloner(item));
+        return res;
+    }),
+};
+
+function deepMerge(target, source, option) {
+    const typeStrategy = Object.assign(Object.assign({}, defaultMergeStrategy), ((option === null || option === void 0 ? void 0 : option.typeStrategy) || {}));
+    const cloneOptions = Object.assign({ cloneSymbol: true, clonePrototype: false, cloneDescriptor: false, customCloner: [] }, ((option === null || option === void 0 ? void 0 : option.cloneOptions) || {}));
+    const map = new Map();
+    const cloner = _curryMore(_deepClone)(_, map, cloneOptions);
+    const res = _deepMergeBase(target, source, { typeStrategy, cloneOptions }, map, [], cloner);
+    map.clear();
+    return res;
+}
+
 function _fastClone(obj, map) {
     if (map.has(obj))
         return map.get(obj);
@@ -1774,10 +2003,12 @@ function throttle(fn, delay, options) {
     return _throttle(fn, delay, Object.assign({ trailing: false, leading: true }, options));
 }
 
+exports.$$Empty = $$Empty;
 exports._ = _;
 exports.acceptableFileName = acceptableFileName;
 exports.acceptableFileType = acceptableFileType;
 exports.camelCase = camelCase;
+exports.capitalize = capitalize;
 exports.caseCamel = caseCamel;
 exports.caseConvert = caseConvert;
 exports.caseKebab = caseKebab;
@@ -1788,6 +2019,7 @@ exports.compose = compose;
 exports.curry = _curryMore;
 exports.debounce = debounce;
 exports.deepClone = deepClone;
+exports.deepMerge = deepMerge;
 exports.defer = defer;
 exports.fastClone = fastClone;
 exports.getAcceptableExtByMIME = getAcceptableExtByMIME;
@@ -1800,6 +2032,7 @@ exports.isArrayLike = isArrayLike;
 exports.isBigInt = isBigInt;
 exports.isBigInt64Array = isBigInt64Array;
 exports.isBigUint64Array = isBigUint64Array;
+exports.isBlob = isBlob;
 exports.isBoolean = isBoolean;
 exports.isBuffer = isBuffer;
 exports.isDataView = isDataView;
@@ -1816,6 +2049,7 @@ exports.isInt8Array = isInt8Array;
 exports.isInteger = isInteger;
 exports.isIterable = isIterable;
 exports.isMap = isMap;
+exports.isMergeEmptyPlaceholder = isMergeEmptyPlaceholder;
 exports.isNil = isNil;
 exports.isNull = isNull;
 exports.isNumber = isNumber;
@@ -1868,6 +2102,7 @@ exports.throttle = throttle;
 exports.titleCase = titleCase;
 exports.tryit = tryit;
 exports.ulid = ulid;
+exports.uncapitalize = uncapitalize;
 exports.uuidNil = uuidNil;
 exports.uuidV4 = uuidV4;
 exports.withResolvers = withResolvers;

package/lib/index.d.ts

@@ -169,7 +169,7 @@ type RetryOption = {
  * ```js
  * // 基本用法, 默认重试 3 次, 每次失败后会立即重新调用
  * const res = await retry(() => fetch(url, params))
- * // 重试 10 次
+ * // 重试 10 次, 最多会调用传入的函数 10 次
  * const res = await retry(() => fetch(url, params), { times: 10 })
  * // 延迟模式, 每次失败后会等待 1 秒再重新调用
  * const res = await retry(() => fetch(url, params), { delay: 1000 })
@@ -308,6 +308,19 @@ declare function isArrayLike(value: unknown): value is ArrayLike<any>;
  */
 declare function isBigInt(value: unknown): value is bigint;
 
+/**
+ * 类型守卫，判断给定的值是否为 `Blob` 对象
+ * @param value 要判断的值
+ * @example
+ * ```js
+ * isBlob(new Blob()) // true
+ * isBlob(new ArrayBuffer(8)) // false
+ * isBlob([1, 2, 3]) // false
+ * ```
+ * @version 0.3.0
+ */
+declare function isBlob(value: any): value is Blob;
+
 /**
  * 类型守卫，判断给定的值是否为布尔类型
  * @param value 要判断的值
@@ -1153,6 +1166,18 @@ declare function titleCase(str: string, options?: {
     keepNumber?: boolean;
 }): string;
 
+/**
+ * 将字符串的首字母大写
+ * @param str 字符串
+ * @returns 首字母大写后的字符串
+ * @example
+ * ```js
+ * capitalize('hello world') // 'Hello world'
+ * ```
+ * @version 0.3.0
+ */
+declare function capitalize(str: string): string;
+
 type VarCase = {
     code: string;
     /** 是否为全大写 */
@@ -1253,6 +1278,18 @@ declare function caseSnake(str: string, keepLetterCase?: boolean, keepNumber?: b
  */
 declare function splitWords(str: string): string[];
 
+/**
+ * 将字符串的首字母小写
+ * @param str 字符串
+ * @returns 首字母小写后的字符串
+ * @example
+ * ```js
+ * uncapitalize('Hello world') // 'hello world'
+ * ```
+ * @version 0.3.0
+ */
+declare function uncapitalize(str: string): string;
+
 /**
  * 调用`Object.prototype.toString`获取对象类型名称
  * @param value 要判断的类型
@@ -1490,6 +1527,130 @@ type CloneOptions = {
  */
 declare function deepClone<T>(obj: T, options?: Partial<CloneOptions>, map?: Map<any, any>): T;
 
+/**
+ * 合并策略, 可以是 `'keep'` `'override'` `'merge'` 或者一个方法
+ * - `'keep'` 表示保留原值
+ * - `'override'` 表示覆盖为新值
+ * - 如果是自定义合并方法, 那么你的方法接收的第一个参数是需要合并的值以及其路径
+ *   - `{ target: 原值; source: 新值; path: 路径数组; unhandledValue: 如果无法处理则返回这个 }`
+ */
+type MergeStrategy = 'keep' | 'override' | MergeStrategyFunction;
+type MergeStrategyFunction<T = any, S = any, Res = any> = (param: {
+    target: T;
+    source: S;
+    path: (string | symbol)[];
+    unhandledValue: any;
+    map: Map<any, any>;
+    typeStrategy: MergeTypeStrategy;
+    /** 深拷贝, 直接传值即可, 参数已经预设好了 */
+    cloner: <T>(obj: T) => T;
+    /** 深合并, 直接传值即可, 参数已经预设好了 */
+    merger: (target: any, source: any, path: (string | symbol)[]) => any;
+}) => Res;
+/** 所有内部识别的值类型 */
+type BaseMargeType = 'Number' | 'String' | 'Boolean' | 'Symbol' | 'BigInt' | 'Null' | 'Undefined' | 'Object' | 'Array' | 'Set' | 'Map' | 'FormData' | 'Date' | 'RegExp' | 'Promise' | 'Function' | 'Generator' | 'Iterator' | 'ArrayBuffer' | 'Buffer' | 'DataView' | 'Blob' | 'File' | 'TypedArray' | 'WeakSet' | 'WeakMap' | 'WeakRef' | 'Error';
+/** 来源对象上的值类型, 不会有 `'Empty'` */
+type SourceMergeType = BaseMargeType | 'Any';
+/** 目标对象上的值类型, 如果某个字段目标上没有而来源上有, 那么就为 `"Empty"` */
+type TargetMergeType = BaseMargeType | 'Empty' | 'Any';
+/** 合并类型, 其中来源对象上不会有 `'Empty'` */
+type MergeType = `${SourceMergeType}2${TargetMergeType}`;
+/** 根据目标对象类型和来源对象类型获取合并策略 */
+type MergeTypeStrategy = {
+    [mergeType in MergeType]?: MergeStrategy;
+};
+type MergeEmptyPlaceholder = A.x & {
+    '@@merge/placeholder': true;
+};
+/** `deepMerge` 深合并的空值占位符 */
+declare const $$Empty: Readonly<{
+    '@@merge/placeholder': true;
+}>;
+/**
+ * 判断给定的参数是否为 `deepMerge` 深合并的空值占位符
+ * @param arg 需要判定的参数
+ * @returns 是否为空值占位符
+ */
+declare function isMergeEmptyPlaceholder(arg: any): arg is MergeEmptyPlaceholder;
+
+/** `deepMerge` 深合并方法的配置参数 */
+type MergeOption = {
+    /** 针对不同的类型设置不同的合并方法 */
+    typeStrategy?: Partial<MergeTypeStrategy>;
+    /** `deepMerge` 内部使用 `deepClone` 拷贝对象之类的值 */
+    cloneOptions?: CloneOptions;
+};
+
+/**
+ * 深合并, 作为基底的对象称为目标对象(target), 往之合并内容的对象称为来源对象(source)
+ * - 不能处理循环引用等特殊场景
+ * - 满足基本的合并功能, 以下行为是其默认行为
+ *   - 普通对象、FormData 这类对象会递归合并
+ *   - 数组会以拼接的方式合并
+ *     - `{ a: [1, 2] }` 和 `{ a: [3, 4] }` 会合并为 `{ a: [1, 2, 3, 4] }`
+ *   - Set、Map 会直接合并, 其中 Map 合并时来源对象会覆盖目标对象相同 Key 的值
+ *     - Set 和 Map 视为不同类型, 会用来源对象的值覆盖
+ *   - Set 和数组会互相合并
+ *     - `{ a: [1, 2] }` 和 `{ a: Set([3, 4]) }` 会合并为 `{ a: [1, 2, 3, 4] }`
+ *     - `{ a: Set([1, 2]) }` 和 `{ a: [3, 4] }` 会合并为 `{ a: Set([1, 2, 3, 4]) }`
+ *   - 来源对象的基本类型值不会覆盖对象
+ *   - 来源对象的空值(null、undefined)不会覆盖其他类型的值
+ *   - 来源对象的非空值会覆盖目标对象的空值(目标对象不存在某个键时也视为空值)
+ *   - 其他情况: 不同类型、原始类型、其他不能合并/拼接的值会以来源对象的为准作覆盖
+ * - 可以根据类型配置不同的策略, 策略可以是 `"keep"` `"override"` 或者一个方法
+ *   - `"keep"` 保留目标对象的值
+ *   - `"override"` 保留来源对象的值
+ *   - 传入方法:
+ *     - 类型 `(param: { target: any; source: any; path: (string | symbol)[]; unhandledValue: any; map: Map<any, any> }) => any`
+ *     - `target` 当前目标对象上这个位置的值
+ *     - `source` 当前来源对象上这个位置的值
+ *     - `path` 当前处理的值在对象上的位置
+ *     - `map` 用于处理循环引用等情况的 Map 对象
+ *     - `unhandledValue` 将这个值返回, 可以跳过处理, 交给兜底逻辑
+ *     - 返回值: 合并后的对象
+ *   - 合并类型: 一个字符串 `${来源对象值类型}2${目标对象值类型}`, 常见类型见下
+ *     - 基本类型 `"Number"` `"String"` `"Boolean"` `"Symbol"` `"BigInt"` `"Null"` `"Undefined"`
+ *     - 常见对象 `"Object"` `"Array"` `"Set"` `"Map"` `"FormData"` `"Date"` `"RegExp"` `"Promise"`
+ *     - 函数 `"Function"`
+ *       - 这些均视为函数 `"AsyncFunction"` `"GeneratorFunction"`, 不能拿来用
+ *     - 生成器函数运行后得到生成器 `"Generator"`
+ *     - 迭代器 `"Iterator"`
+ *       - 这些均视为迭代器, 不能拿来用
+ *       - `"String Iterator"` `"Array Iterator"` `"RegExp String Iterator"`
+ *       - `"Map Iterator"` `"Set Iterator"` `"Segmenter String Iterator"`
+ *       - `"Iterator Helper"`
+ *     - 二进制流&文件 `"ArrayBuffer"` `"Buffer"` `"DataView"` `"Blob"` `"File"`
+ *     - 类型数组 `"TypedArray"`
+ *       - 这些均视为类型数组, 不能拿来用
+ *       - `"Int8Array"` `"Int16Array"` `"Int32Array"`
+ *       - `"Uint8Array"` `"Uint8ClampedArray"` `"Uint16Array"` `"Uint32Array"`
+ *       - `"Float32Array"` `"Float64Array"`
+ *       - `"BigInt64Array"` `"BigUint64Array"`
+ *     - 弱引用 `"WeakSet"` `"WeakMap"` `"WeakRef"`
+ *     - 报错信息 `"Error"`
+ *       - 任意类型的错误视为报错信息
+ *     - 其他类型 `"Any"` 表示所有类型(用于兜底), 空类型 `"Empty"` 表示目标对象上没有这个键
+ *       - `"Empty"` 不会出现在来源对象上, 因此只会有 `"Any2Empty"`, 而不会有 `"Empty2Any"`
+ *   - 策略优先级是:
+ *     - 精确指定优先级最高: 如 `"Object2Object"` 优先于 `"Object2Any"`
+ *     - 来源对象精确指定优先级高: 如 `"Object2Any"` 优先于 `"Any2Object"`
+ *     - 空类型 `"Empty"` 视为精确指定
+ * @param target 目标对象
+ * @param source 来源对象, 往目标对象合并内容
+ * @param option 配置
+ * - `option.typeStrategy`: 针对不同的类型设置不同的合并方法
+ * - `option.cloneOptions`: `deepMerge` 内部使用 `deepClone` 拷贝对象之类的值
+ * @example
+ * ```js
+ * const obj1 = { arr: [1, 2], obj: { a: [1], b: { c: 2 } }, p: '1' }
+ * const obj2 = { arr: [3], obj: { a: [2], b: { c: 4, d: 3 } }, p: '2' }
+ * const obj3 = deepMerge(obj1, obj2)
+ * obj3 // { arr: [1, 2, 3], obj: { a: [1, 2], b: { c: 4, d: 3 } }, p: '2' }
+ * ```
+ * @version 0.3.0
+ */
+declare function deepMerge<Target, Source, Result = Target & Source>(target: Target, source: Source, option?: MergeOption): Result;
+
 /**
  * 快速深拷贝
  * - 功能较为齐全, 相对 `deepClone` 而言运行更快
@@ -1549,7 +1710,15 @@ declare function isEmpty(value: unknown): boolean;
  * - `getKey` 自定义 key 的生成规则, 默认使用内部方法生成 key
  * - `ttl` 缓存的过期时间, 单位毫秒, 为 0 表示不过期, 默认不过期
  * - `count` 缓存最大使用次数, 为 0 表示不限次数, 默认不限次数
- * @returns
+ * @returns 记忆化的函数, 输入相同参数再次调用时会直接返回之前的结果而不会调用原函数
+ * @example
+ * ```js
+ * // 计算斐波那契数列
+ * const fib = memo(function (n) {
+ *   if (n < 2) return n
+ *   return fib(n - 1) + fib(n - 2)
+ * })
+ * ```
  */
 declare function memo<TArgs extends any[], TRes>(fn: (...args: TArgs) => TRes, options?: {
     getKey?: (...args: TArgs) => string | number;
@@ -1737,4 +1906,5 @@ declare function throttle<T extends any[]>(fn: (...args: T) => any, delay: numbe
     reset: () => void;
 };
 
-export { type CloneOptions, type CustomCloner, type RangeOptions, type TypedArray, _, acceptableFileName, acceptableFileType, camelCase, caseCamel, caseConvert, caseKebab, casePascal, caseSnake, clamp, compose, _curryMore as curry, debounce, deepClone, defer, fastClone, getAcceptableExtByMIME, getAcceptableMIMEByExt, getGlobalThis, getTag, isArray, isArrayBuffer, isArrayLike, isBigInt, isBigInt64Array, isBigUint64Array, isBoolean, isBuffer, isDataView, isDate, isEmpty, isFile, isFloat32Array, isFloat64Array, isFormData, isFunction, isInt16Array, isInt32Array, isInt8Array, isInteger, isIterable, isMap, isNil, isNull, isNumber, isObject, isPlaceholder, isPrimitive, isPromise, isPromiseLike, isRegExp, isSet, isString, isSymbol, isTypedArray, isUint16Array, isUint32Array, isUint8Array, isUint8ClampedArray, isUndefined, isWeakMap, isWeakSet, isWrapperBigInt, isWrapperBoolean, isWrapperNumber, isWrapperObject, isWrapperString, isWrapperSymbol, kebabCase, memo, noop, not, parallel, pascalCase, pass, passWith, pipe, randomBase32String, randomChoice, randomHexString, randomInt, randomIntFloor, randomString, range, remove, retry, shuffle, sleep, snakeCase, splitWords, throttle, titleCase, tryit, ulid, uuidNil, uuidV4, withResolvers };
+export { $$Empty, _, acceptableFileName, acceptableFileType, camelCase, capitalize, caseCamel, caseConvert, caseKebab, casePascal, caseSnake, clamp, compose, _curryMore as curry, debounce, deepClone, deepMerge, defer, fastClone, getAcceptableExtByMIME, getAcceptableMIMEByExt, getGlobalThis, getTag, isArray, isArrayBuffer, isArrayLike, isBigInt, isBigInt64Array, isBigUint64Array, isBlob, isBoolean, isBuffer, isDataView, isDate, isEmpty, isFile, isFloat32Array, isFloat64Array, isFormData, isFunction, isInt16Array, isInt32Array, isInt8Array, isInteger, isIterable, isMap, isMergeEmptyPlaceholder, isNil, isNull, isNumber, isObject, isPlaceholder, isPrimitive, isPromise, isPromiseLike, isRegExp, isSet, isString, isSymbol, isTypedArray, isUint16Array, isUint32Array, isUint8Array, isUint8ClampedArray, isUndefined, isWeakMap, isWeakSet, isWrapperBigInt, isWrapperBoolean, isWrapperNumber, isWrapperObject, isWrapperString, isWrapperSymbol, kebabCase, memo, noop, not, parallel, pascalCase, pass, passWith, pipe, randomBase32String, randomChoice, randomHexString, randomInt, randomIntFloor, randomString, range, remove, retry, shuffle, sleep, snakeCase, splitWords, throttle, titleCase, tryit, ulid, uncapitalize, uuidNil, uuidV4, withResolvers };
+export type { BaseMargeType, CloneOptions, CustomCloner, MergeOption, MergeStrategy, MergeStrategyFunction, MergeType, MergeTypeStrategy, RangeOptions, SourceMergeType, TargetMergeType, TypedArray };