foreslash 0.1.2 → 0.2.1

package/lib/index.d.ts

@@ -1,5 +1,141 @@
 import { A, F } from 'ts-toolbelt';
 
+type RangeOptions<T> = {
+    step?: number;
+    value?: T;
+    getter?: (index: number, existList: T[]) => T;
+};
+/**
+ * 根据起止值生成一个数组, 步长默认为 1
+ * @param start 开始值
+ * @param end 结束值
+ * @example
+ * ```js
+ * range(1, 10) // [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+ * range(10, 1) // [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
+ * ```
+ * @version 0.2.0
+ */
+declare function range(start: number, end: number): number[];
+/**
+ * 根据目标值生成一个数组, 步长默认为 1
+ * @param target 目标值
+ * @example
+ * ```js
+ * range(10) // [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
+ * range(-10) // [0, -1, -2, -3, -4, -5, -6, -7, -8, -9, -10]
+ * ```
+ * @version 0.2.1
+ */
+declare function range(target: number): number[];
+/**
+ * 根据起止值生成一个数组, 步长默认为 1
+ * @param start 开始值
+ * @param end 结束值
+ * @param step 步长, 默认为 1
+ * @example
+ * ```js
+ * range(1, 10, 2) // [1, 3, 5, 7, 9]
+ * range(10, 0, 2) // [10, 8, 6, 4, 2, 0]
+ * ```
+ * @version 0.2.0
+ */
+declare function range(start: number, end: number, step?: number): number[];
+/**
+ * 根据起止值生成一个数组, 步长默认为 1
+ * @param start 开始值
+ * @param end 结束值
+ * @param options 详细配置项, 用法见下
+ * @example
+ * ```js
+ * range(1, 5, { step: 2 }) // [1, 3, 5]
+ * range(0, 6, { step: 2 }) // [0, 2, 4, 6]
+ * range(0, 6, { step: 2, value: 'test' }) // ['test', 'test', 'test', 'test']
+ * range(0, 6, { step: 2, getter: (i) => i * 10 }) // [0, 20, 40, 60]
+ * ```
+ * @version 0.2.0
+ */
+declare function range<T = number>(start: number, end: number, options?: RangeOptions<T>): T[];
+
+/**
+ * 延迟一定时间
+ * @param time 延迟时间, 单位为毫秒(ms), 默认为 `1000` (即 1 秒)
+ * @returns 一个 `Promise`, 到指定时间后会变为 `fulfilled` 状态
+ * @example
+ * ```js
+ * sleep().then(() => {
+ *   // do something 1s later
+ * })
+ *
+ * await sleep(2500) // do something 2.5s later
+ * ```
+ * @version 0.2.0
+ */
+declare function sleep(time?: number): Promise<unknown>;
+
+type TryitResultType<Res, Err> = [undefined, Res] | [Err, undefined];
+type TryitResult<Res, Err extends Error> = Res extends Promise<infer R> ? Promise<TryitResultType<R, Err>> : TryitResultType<Res, Err>;
+/**
+ * 将一个函数处理为 `error-first` 的函数
+ * @param fn 需要处理的函数, 可以是异步函数
+ * @returns 处理过的函数, 调用后返回一个 `error-first` 的元组 `[error, result]`;\
+ * 如果原函数是异步函数, 则返回值会是 `Promise<[error, result]>`;\
+ * 如果运行正常则 `result` 是原函数的返回值, `error` 为 `undefined`;\
+ * 如果出现异常则 `result` 为 `undefined`, `error` 是原函数抛出的错误
+ * @example
+ * ```js
+ * // Sync Function
+ * const normalFn = () => { return 1 }
+ * const errorFn = () => { throw new Error('1') }
+ * tryit(normalFn)() // [undefined, 1]
+ * tryit(errorFn)() // [Error('1'), undefined]
+ * // Async Function
+ * const normalAsyncFn = () => { return Promise.resolve(1) }
+ * const errorAsyncFn = () => { return Promise.reject('1') }
+ * tryit(normalAsyncFn)() // Promise<[undefined, 1]>
+ * tryit(errorAsyncFn)() // Promise<[Error('1'), undefined]>
+ * ```
+ * @version 0.2.0
+ */
+declare function tryit<Args extends any[], Res, Err extends Error>(fn: (...args: Args) => Res): (...args: Args) => TryitResult<Res, Err>;
+
+interface PromiseLikeConstructor {
+    new <T>(executor: (resolve: (value: T | PromiseLike<T>) => void, reject: (reason?: any) => void) => void): PromiseLike<T>;
+}
+/**
+ * 实现了 ES2024 引入 `Promise.withResolvers` 的 ponyfill
+ * @param PromiseLike 任何与 `Promise` 构造函数相同签名的构造函数
+ * @returns 返回一个对象, 其中 `promise` 是一个 `Promise` 实例, `resolve` 和 `reject` 是两个 `Promise` 中 `executor` 接收的方法
+ * @example
+ * ```js
+ * function readFileAsBase64(file: File) {
+ *   const { promise, resolve, reject } = withResolvers<string>()
+ *   const reader = new FileReader()
+ *   reader.readAsDataURL(file)
+ *   reader.onload = function () {
+ *     resolve(reader.result as string)
+ *   }
+ *   reader.onerror = function () {
+ *     reject()
+ *   }
+ *   return promise
+ * }
+ *
+ * const fileBase64 = await readFileAsBase64(someFile)
+ * ```
+ * @version 0.2.0
+ */
+declare function withResolvers<T>(): {
+    promise: Promise<T>;
+    resolve: (value: T | PromiseLike<T>) => void;
+    reject: (reason?: any) => void;
+};
+declare function withResolvers<T>(PromiseLike: PromiseLikeConstructor): {
+    promise: PromiseLike<T>;
+    resolve: (value: T | PromiseLike<T>) => void;
+    reject: (reason?: any) => void;
+};
+
 /**
  * 类型守卫，判断给定的值是否为数组(使用内置的 `Array.isArray` 方法)
  * @param value 要判断的值
@@ -63,11 +199,71 @@ declare function isBigInt(value: unknown): value is bigint;
 declare function isBoolean(value: unknown): value is boolean;
 
 /**
- * 类型守卫，判断给定的值是否为`Buffer`(node 专用，使用内置的 `Buffer.isBuffer` 方法)
+ * 类型守卫，判断给定的值是否为`Buffer`(使用内置的 `Buffer.isBuffer` 方法)
+ * - 非 Node.js 环境会使用当前环境的 `Buffer` 全局对象
  * @param value 要判断的值
  */
 declare const isBuffer: (obj: any) => obj is Buffer;
 
+/**
+ * 类型守卫，判断给定的值是否为 `DataView` 类型
+ * @param value 要判断的值
+ * @example
+ * ```js
+ * isDataView(new DataView(new ArrayBuffer(8))) // true
+ * isDataView(new ArrayBuffer(8)) // false
+ * isDataView([1, 2, 3]) // false
+ * ```
+ * @version 0.2.0
+ */
+declare function isDataView(value: unknown): value is DataView;
+
+/**
+ * 类型守卫，判断给定的值是否为 `Date`
+ * @param value 要判断的值
+ * @example
+ * ```js
+ * isDate(new Date()) // true
+ * isDate(new Date(123456789)) // true
+ * isDate(Date.now()) // false
+ * isDate(Date) // false
+ * isDate({}) // false
+ * ```
+ * @version 0.2.0
+ */
+declare function isDate(value: unknown): value is Date;
+
+/**
+ * 类型守卫，判断给定的值是否为`File`
+ * - 非 Web 环境会使用当前环境的 `File` 全局对象
+ * - Node.js 18+ 才引入了此 API, Node.js 20+ 实现了完全支持
+ * @param value 要判断的值
+ * @example
+ * ```js
+ * isFile(new File([new ArrayBuffer(8)], 'fileName')) // true
+ * isFile(new ArrayBuffer(8)) // false
+ * isFile([1, 2, 3]) // false
+ * ```
+ * @version 0.2.0
+ */
+declare function isFile(value: unknown): value is File;
+
+/**
+ * 类型守卫，判断给定的值是否为`FormData`
+ * - 非 Web 环境会使用当前环境的 `FormData` 全局对象
+ * - Node.js 18+ 才引入了此 API
+ * @param value 要判断的值
+ * @example
+ * ```js
+ * isFormData(new FormData()) // true
+ * isFormData({}) // false
+ * isFormData([]) // false
+ * isFormData(null) // false
+ * ```
+ * @version 0.2.0
+ */
+declare function isFormData(value: unknown): value is FormData;
+
 /**
  * 类型守卫，判断给定的值是否为函数
  * - 会将构造函数也视为函数
@@ -98,6 +294,23 @@ declare function isFunction(value: unknown): value is Function;
  */
 declare function isInteger(value: unknown): value is number;
 
+/**
+ * 类型守卫，判断给定的值是否可迭代 `Iterable`
+ * @param value 要判断的值
+ * @example
+ * ```js
+ * isIterable([]) // true
+ * isIterable("1") // true
+ * isIterable(new Map()) // true
+ * isIterable(new Set()) // true
+ * isIterable({}) // false
+ * isIterable(null) // false
+ * isIterable(1234) // false
+ * ```
+ * @version 0.2.0
+ */
+declare function isIterable(value: unknown): value is Iterable<unknown>;
+
 /**
  * 类型守卫，判断给定的值是否为`Map`
  * @param value 要判断的值
@@ -226,6 +439,19 @@ declare function isPromise(value: unknown): value is Promise<any>;
  */
 declare function isPromiseLike(value: unknown): value is Promise<any>;
 
+/**
+ * 类型守卫，判断给定的值是否为正则表达式 `RegExp`
+ * @param value 要判断的值
+ * @example
+ * ```js
+ * isRegExp(/123/) // true
+ * isRegExp(new RegExp("123")) // true
+ * isRegExp("123") // false
+ * ```
+ * @version 0.2.0
+ */
+declare function isRegExp(value: unknown): value is RegExp;
+
 /**
  * 类型守卫，判断给定的值是否为`Set`
  * @param value 要判断的值
@@ -263,6 +489,153 @@ declare function isString(value: unknown): value is string;
  */
 declare function isSymbol(value: unknown): value is symbol;
 
+type TypedArray = Int8Array | Int16Array | Int32Array | Uint8Array | Uint8ClampedArray | Uint16Array | Uint32Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array;
+/**
+ * 类型守卫，判断给定的值是否为 `TypedArray` 类型
+ * @param value 要判断的值
+ * @example
+ * ```js
+ * isTypedArray(new Int8Array([1, 2, 3])) // true
+ * isTypedArray(new Uint8Array([1, 2, 3])) // true
+ * isTypedArray([1, 2, 3]) // false
+ * isTypedArray(new ArrayBuffer(8)) // false
+ * ```
+ */
+declare function isTypedArray(value: unknown): value is TypedArray;
+/**
+ * 类型守卫，判断给定的值是否为 `Int8Array` 类型
+ * @param value 要判断的值
+ * @example
+ * ```js
+ * isInt8Array(new Int8Array([1, 2, 3])) // true
+ * isInt8Array(new Uint8Array([1, 2, 3])) // false
+ * isInt8Array([1, 2, 3]) // false
+ * isInt8Array(new ArrayBuffer(8)) // false
+ * ```
+ */
+declare function isInt8Array(value: unknown): value is Int8Array;
+/**
+ * 类型守卫，判断给定的值是否为 `Int16Array` 类型
+ * @param value 要判断的值
+ * @example
+ * ```js
+ * isInt16Array(new Int16Array([1, 2, 3])) // true
+ * isInt16Array(new Uint8Array([1, 2, 3])) // false
+ * isInt16Array([1, 2, 3]) // false
+ * isInt16Array(new ArrayBuffer(8)) // false
+ * ```
+ */
+declare function isInt16Array(value: unknown): value is Int16Array;
+/**
+ * 类型守卫，判断给定的值是否为 `Int32Array` 类型
+ * @param value 要判断的值
+ * @example
+ * ```js
+ * isInt32Array(new Int32Array([1, 2, 3])) // true
+ * isInt32Array(new Uint8Array([1, 2, 3])) // false
+ * isInt32Array([1, 2, 3]) // false
+ * isInt32Array(new ArrayBuffer(8)) // false
+ * ```
+ */
+declare function isInt32Array(value: unknown): value is Int32Array;
+/**
+ * 类型守卫，判断给定的值是否为 `Uint8Array` 类型
+ * @param value 要判断的值
+ * @example
+ * ```js
+ * isUint8Array(new Uint8Array([1, 2, 3])) // true
+ * isUint8Array(new Int8Array([1, 2, 3])) // false
+ * isUint8Array([1, 2, 3]) // false
+ * isUint8Array(new ArrayBuffer(8)) // false
+ * ```
+ */
+declare function isUint8Array(value: unknown): value is Uint8Array;
+/**
+ * 类型守卫，判断给定的值是否为 `Uint8ClampedArray` 类型
+ * @param value 要判断的值
+ * @example
+ * ```js
+ * isUint8ClampedArray(new Uint8ClampedArray([1, 2, 3])) // true
+ * isUint8ClampedArray(new Uint8Array([1, 2, 3])) // false
+ * isUint8ClampedArray([1, 2, 3]) // false
+ * isUint8ClampedArray(new ArrayBuffer(8)) // false
+ * ```
+ */
+declare function isUint8ClampedArray(value: unknown): value is Uint8ClampedArray;
+/**
+ * 类型守卫，判断给定的值是否为 `Uint16Array` 类型
+ * @param value 要判断的值
+ * @example
+ * ```js
+ * isUint16Array(new Uint16Array([1, 2, 3])) // true
+ * isUint16Array(new Uint8Array([1, 2, 3])) // false
+ * isUint16Array([1, 2, 3]) // false
+ * isUint16Array(new ArrayBuffer(8)) // false
+ * ```
+ */
+declare function isUint16Array(value: unknown): value is Uint16Array;
+/**
+ * 类型守卫，判断给定的值是否为 `Uint32Array` 类型
+ * @param value 要判断的值
+ * @example
+ * ```js
+ * isUint32Array(new Uint32Array([1, 2, 3])) // true
+ * isUint32Array(new Uint8Array([1, 2, 3])) // false
+ * isUint32Array([1, 2, 3]) // false
+ * isUint32Array(new ArrayBuffer(8)) // false
+ * ```
+ */
+declare function isUint32Array(value: unknown): value is Uint32Array;
+/**
+ * 类型守卫，判断给定的值是否为 `Float32Array` 类型
+ * @param value 要判断的值
+ * @example
+ * ```js
+ * isFloat32Array(new Float32Array([1, 2, 3])) // true
+ * isFloat32Array(new Uint8Array([1, 2, 3])) // false
+ * isFloat32Array([1, 2, 3]) // false
+ * isFloat32Array(new ArrayBuffer(8)) // false
+ * ```
+ */
+declare function isFloat32Array(value: unknown): value is Float32Array;
+/**
+ * 类型守卫，判断给定的值是否为 `Float64Array` 类型
+ * @param value 要判断的值
+ * @example
+ * ```js
+ * isFloat64Array(new Float64Array([1, 2, 3])) // true
+ * isFloat64Array(new Uint8Array([1, 2, 3])) // false
+ * isFloat64Array([1, 2, 3]) // false
+ * isFloat64Array(new ArrayBuffer(8)) // false
+ * ```
+ */
+declare function isFloat64Array(value: unknown): value is Float64Array;
+/**
+ * 类型守卫，判断给定的值是否为 `BigInt64Array` 类型
+ * @param value 要判断的值
+ * @example
+ * ```js
+ * isBigInt64Array(new BigInt64Array([1n, 2n, 3n])) // true
+ * isBigInt64Array(new Uint8Array([1, 2, 3])) // false
+ * isBigInt64Array([1, 2, 3]) // false
+ * isBigInt64Array(new ArrayBuffer(8)) // false
+ * ```
+ */
+declare function isBigInt64Array(value: unknown): value is BigInt64Array;
+/**
+ * 类型守卫，判断给定的值是否为 `BigUint64Array` 类型
+ * @param value 要判断的值
+ * @example
+ * ```js
+ * isBigUint64Array(new BigUint64Array([1n, 2n, 3n])) // true
+ * isBigUint64Array(new Uint8Array([1, 2, 3])) // false
+ * isBigUint64Array([1, 2, 3]) // false
+ * isBigUint64Array(new ArrayBuffer(8)) // false
+ * ```
+ * @version 0.2.0
+ */
+declare function isBigUint64Array(value: unknown): value is BigUint64Array;
+
 /**
  * 类型守卫，判断给定的值是否为包装对象(可能是数字、字符串、`Symbol`、布尔、`BigInt`)
  * @param value 要判断的值
@@ -521,16 +894,114 @@ declare const uuidNil = "00000000-0000-0000-0000-000000000000";
 declare function uuidV4(): string;
 
 /**
- * 调用`Object.prototype.toString`获取对象类型名称
- * @param value 要判断的类型
+ * 将输入的字符串处理成小驼峰格式
+ * @param str 想要转换的字符串
+ * @param options.keepLetterCase 是否保留原来的大小写, 默认不保留
+ * @param options.keepNumber 是否保留数字, 默认保留
+ * @returns 转换为小驼峰格式的字符串
+ * @example
+ * ```js
+ * // 默认情况 不保留大小写 保留数字
+ * camelCase("get-Test-UUID-1234") // "getTestUuid1234"
+ * // 保留大小写 保留数字
+ * camelCase("get-Test-UUID-1234", { keepLetterCase: true }) // "getTestUUID1234"
+ * // 保留大小写 不保留数字
+ * camelCase("get-Test-UUID-1234", { keepLetterCase: true, keepNumber: false }) // "getTestUUID"
+ * ```
+ * @version 0.2.0
  */
-declare function getTag(value: unknown): string;
+declare function camelCase(str: string, options?: {
+    keepLetterCase?: boolean;
+    keepNumber?: boolean;
+}): string;
 
 /**
- * 获取全局对象，浏览器环境返回 `window`，node 环境返回 `global`
- * @returns 全局对象
+ * 将输入的字符串处理成串行格式(短横线分割)
+ * @param str 想要转换的字符串
+ * @param options.keepLetterCase 是否保留原来的大小写, 默认不保留
+ * @param options.keepNumber 是否保留数字, 默认保留
+ * @returns 转换为串行格式的字符串
+ * @example
+ * ```js
+ * // 默认情况 不保留大小写 保留数字
+ * kebabCase("getTestUuid1234") // "get-test-uuid-1234"
+ * // 保留大小写 保留数字
+ * kebabCase("getTestUuid1234", { keepLetterCase: true }) // "get-Test-UUID-1234"
+ * // 保留大小写 不保留数字
+ * kebabCase("getTestUuid1234", { keepLetterCase: true, keepNumber: false }) // "get-Test-UUID"
+ * ```
+ * @version 0.2.0
  */
-declare function getGlobalThis(): typeof globalThis;
+declare function kebabCase(str: string, options?: {
+    keepLetterCase?: boolean;
+    keepNumber?: boolean;
+}): string;
+
+/**
+ * 将输入的字符串处理成大驼峰格式
+ * @param str 想要转换的字符串
+ * @param options.keepLetterCase 是否保留原来的大小写, 默认不保留
+ * @param options.keepNumber 是否保留数字, 默认保留
+ * @returns 转换为大驼峰格式的字符串
+ * @example
+ * ```js
+ * // 默认情况 不保留大小写 保留数字
+ * pascalCase("get-Test-UUID-1234") // "GetTestUuid1234"
+ * // 保留大小写 保留数字
+ * pascalCase("get-Test-UUID-1234", { keepLetterCase: true }) // "GetTestUUID1234"
+ * // 保留大小写 不保留数字
+ * pascalCase("get-Test-UUID-1234", { keepLetterCase: true, keepNumber: false }) // "GetTestUUID"
+ * ```
+ * @version 0.2.0
+ */
+declare function pascalCase(str: string, options?: {
+    keepLetterCase?: boolean;
+    keepNumber?: boolean;
+}): string;
+
+/**
+ * 将输入的字符串处理成蛇行格式(下划线分割)
+ * @param str 想要转换的字符串
+ * @param options.keepLetterCase 是否保留原来的大小写
+ * @param options.keepNumber 是否保留数字, 默认保留
+ * @returns 转换为蛇行格式的字符串
+ * @example
+ * ```js
+ * // 默认情况 不保留大小写 保留数字
+ * snakeCase("getTestUuid1234") // "get_test_uuid_1234"
+ * // 保留大小写 保留数字
+ * snakeCase("getTestUuid1234", { keepLetterCase: true }) // "get_Test_UUID_1234"
+ * // 保留大小写 不保留数字
+ * snakeCase("getTestUuid1234", { keepLetterCase: true, keepNumber: false }) // "get_Test_UUID"
+ * ```
+ * @version 0.2.0
+ */
+declare function snakeCase(str: string, options?: {
+    keepLetterCase?: boolean;
+    keepNumber?: boolean;
+}): string;
+
+/**
+ * 将输入的字符串处理成标题格式(类似大驼峰, 不过有空格分割)
+ * @param str 想要转换的字符串
+ * @param options.keepLetterCase 是否保留原来的大小写
+ * @param options.keepNumber 是否保留数字, 默认保留
+ * @returns 转换为标题格式的字符串
+ * @example
+ * ```js
+ * // 默认情况 不保留大小写 保留数字
+ * titleCase("getTestUuid1234") // "Get Test Uuid 1234"
+ * // 保留大小写 保留数字
+ * titleCase("getTestUuid1234", { keepLetterCase: true }) // "Get Test UUID 1234"
+ * // 保留大小写 不保留数字
+ * titleCase("getTestUuid1234", { keepLetterCase: true, keepNumber: false }) // "Get Test UUID"
+ * ```
+ * @version 0.2.0
+ */
+declare function titleCase(str: string, options?: {
+    keepLetterCase?: boolean;
+    keepNumber?: boolean;
+}): string;
 
 type VarCase = {
     code: string;
@@ -559,20 +1030,22 @@ type VarCase = {
 declare function caseConvert(str: string, joiner?: string, handler?: (token: VarCase, index: number) => string): string;
 /**
  * 将输入的字符串处理成小驼峰格式
+ * @deprecated 推荐使用 `camelCase` 替代
  * @param str 想要转换的字符串
  * @param keepLetterCase 是否保留原来的大小写, 默认不保留
  * @param keepNumber 是否保留数字, 默认保留
  * @returns 转换为小驼峰格式的字符串
  * @example
  * ```js
- * caseCamel("get-Test-UUID-1234") // "getTestUuid1234" 默认情况 不保留大小写 保留数字
- * caseCamel("get-Test-UUID-1234", true) // "getTestUUID1234" 保留大小写 保留数字
- * caseCamel("get-Test-UUID-1234", true, false) // "getTestUUID" 保留大小写 不保留数字
+ * caseCamel("get-Test-UUID-1234") // "getTestUuid1234"
+ * caseCamel("get-Test-UUID-1234", true) // "getTestUUID1234"
+ * caseCamel("get-Test-UUID-1234", true, false) // "getTestUUID"
  * ```
  */
 declare function caseCamel(str: string, keepLetterCase?: boolean, keepNumber?: boolean): string;
 /**
  * 将输入的字符串处理成大驼峰格式
+ * @deprecated 推荐使用 `pascalCase` 替代
  * @param str 想要转换的字符串
  * @param keepLetterCase 是否保留原来的大小写
  * @param keepNumber 是否保留数字, 默认保留
@@ -587,6 +1060,7 @@ declare function caseCamel(str: string, keepLetterCase?: boolean, keepNumber?: b
 declare function casePascal(str: string, keepLetterCase?: boolean, keepNumber?: boolean): string;
 /**
  * 将输入的字符串处理成串行格式
+ * @deprecated 推荐使用 `kebabCase` 替代
  * @param str 想要转换的字符串
  * @param keepLetterCase 是否保留原来的大小写
  * @param keepNumber 是否保留数字, 默认保留
@@ -601,6 +1075,7 @@ declare function casePascal(str: string, keepLetterCase?: boolean, keepNumber?:
 declare function caseKebab(str: string, keepLetterCase?: boolean, keepNumber?: boolean): string;
 /**
  * 将输入的字符串处理成蛇行格式
+ * @deprecated 推荐使用 `snakeCase` 替代
  * @param str 想要转换的字符串
  * @param keepLetterCase 是否保留原来的大小写
  * @param keepNumber 是否保留数字, 默认保留
@@ -614,6 +1089,32 @@ declare function caseKebab(str: string, keepLetterCase?: boolean, keepNumber?: b
  */
 declare function caseSnake(str: string, keepLetterCase?: boolean, keepNumber?: boolean): string;
 
+/**
+ * 分割单词, 适用于分割、转换变量名的场景
+ * - 任何非英文字母、数字的字符均会视为分割符
+ * @param str 需要分割的字符串
+ * @returns 分割后的字符串
+ * @example
+ * ```js
+ * splitWords("getTestUUID1234") // ["get", "Test", "UUID", "1234"]
+ * splitWords("user_nick_name") // ["user", "nick", "name"]
+ * splitWords("A文字B🎈C=-=Test") // ["A", "B", "C", "Test"]
+ * ```
+ */
+declare function splitWords(str: string): string[];
+
+/**
+ * 调用`Object.prototype.toString`获取对象类型名称
+ * @param value 要判断的类型
+ */
+declare function getTag(value: unknown): string;
+
+/**
+ * 获取全局对象，浏览器环境返回 `self` 或 `window`, Node.js 环境返回 `global`
+ * @returns 全局对象
+ */
+declare function getGlobalThis(): typeof globalThis;
+
 // compose
 type ComposeFuncList1<CompArgs extends any[], CompResult> = [(...args: CompArgs) => CompResult]
 type ComposeFuncList2<CompArgs extends any[], CompResult, Mid1 = any> = [
@@ -770,16 +1271,62 @@ declare function _curryMore<Arg1, Arg2, Res>(fn: (arg1: Arg1, arg2: Arg2) => Res
 declare function _curryMore<Arg1, Arg2, Arg3, Res>(fn: (arg1: Arg1, arg2: Arg2, arg3: Arg3) => Res): F.Curry<(arg1: Arg1, arg2: Arg2, arg3: Arg3) => Res>;
 declare function _curryMore<Args extends Array<any>, Res>(fn: (...args: Args) => Res): F.Curry<(...args: Args) => Res>;
 
+interface CustomCloner<T = any> {
+    cloner(val: T, map: Map<any, any>): T;
+    judger(val: any): boolean;
+}
+/** 深拷贝的配置项 */
+type CloneOptions = {
+    /** 拷贝 Symbol 键 默认为 true */
+    cloneSymbol: boolean;
+    /** 拷贝对象原型 默认为 false */
+    clonePrototype: boolean;
+    /** 拷贝属性的 Descriptor 默认为 false */
+    cloneDescriptor: boolean;
+    /** 自定义拷贝逻辑 默认为空 */
+    customCloner: CustomCloner[];
+};
+
+/**
+ * 标准深拷贝
+ * - 功能完善的深拷贝
+ *   - 如果不需要支持一些冷门的数据类型, 可以使用 `fastClone` 代替
+ *   - 可以使用 `customCloner` 实现自定义拷贝特殊数据的逻辑(如拷贝 Web 环境下的 `HTMLElement`)
+ * - 支持处理包括循环引用、数组、正则、`DataView`、`ArrayBuffer` 等复杂数据类型
+ *   - **暂不支持 `File` 类型**
+ * - 可以配置是否拷贝对象的原型、属性 descriptor、以 `Symbol` 为键的属性
+ * - 无法拷贝的内容将视为原生数据类型, 直接复制(如函数、`Promise`、`WeakMap`、`WeakSet`)
+ * - 层级过深(500 层以上)时可能导致栈溢出
+ * @param obj 需要深拷贝的数据
+ * @param options 配置项, 可选, 除非有特殊需求否则不传
+ * - `cloneSymbol`: 是否拷贝 `Symbol` 类型的键, 默认为 `true`
+ * - `clonePrototype`: 是否拷贝对象原型, 默认为 `false`
+ * - `cloneDescriptor`: 是否拷贝属性 Descriptor, 默认为 `false`
+ * - `customCloner`: 自定义拷贝函数, 默认为空数组, 即不支持自定义拷贝
+ * @param map 缓存对象, 用于处理循环引用, 建议不传
+ * @example
+ * ```js
+ * const obj = { map: new Map() }
+ * obj.map.set(obj, 'val')
+ * // 用 deepClone 复制带有 Map 和循环引用的对象
+ * const clone = deepClone(obj)
+ * clone === obj // false
+ * clone.map === obj.map // false
+ * clone.map.get(clone) === 'val' // true
+ * ```
+ * @version 0.2.0
+ */
+declare function deepClone<T>(obj: T, options?: Partial<CloneOptions>, map?: Map<any, any>): T;
+
 /**
  * 快速深拷贝
- * - 快速是相对 `deepClone` 而言的，功能比许多互联网上常见的深拷贝代码片段更多
- * - 支持处理的情况：循环引用、数组、`Date`、正则、`Set`、`Map`
+ * - 相对 `deepClone` 而言运行更快, 功能较为齐全
+ * - 支持处理的情况：循环引用、数组、`Date`、正则、`Set`、`Map`、`FormData`
  * - 对象上以 `Symbol` 为键的属性无法拷贝
- * - 无法拷贝的内容将视为原生数据类型，直接复制
- *   - 如函数、`Promise`、`WeakMap`、`WeakSet`
+ * - 无法拷贝的内容将视为原生数据类型, 直接复制(如函数、`Promise`、`WeakMap`、`WeakSet`)
  * - 层级过深(500 层以上)时可能导致栈溢出
  * @param obj 需要深拷贝的数据
- * @param map 缓存对象，用于处理循环引用，建议不传
+ * @param map 缓存对象, 用于处理循环引用, 建议不传
  * @example
  * ```js
  * const obj = { map: new Map() }
@@ -800,9 +1347,10 @@ declare function fastClone<T>(obj: T, map?: Map<any, any>): T;
  * 3. 若值为 函数 返回 `false`
  * 4. 若值为 类数组对象: `length` 为 `0` 返回 `true` 否则返回 `false`
  * 5. 若值为 `Buffer` 或 `ArrayBuffer`: `byteLength` 为 `0` 返回 `true` 否则返回 `false`
- * 6. 若值为 `Set` 或 `Map`: `size` 为 `0` 返回 `true` 否则返回 `false`
- * 7. 若值不为 原始类型: 根据 `Object.getOwnPropertyNames` 判断是否存在自身键, 若没有返回 `true` 否则返回 `false`
- * 8. 返回 `false`
+ * 6. 若值为 `Date`: 无效值 返回 `true` 否则返回 `false`
+ * 7. 若值为 `Set` 或 `Map`: `size` 为 `0` 返回 `true` 否则返回 `false`
+ * 8. 若值不为 原始类型: 根据 `Object.getOwnPropertyNames` 判断是否存在自身键, 若没有返回 `true` 否则返回 `false`
+ * 9. 返回 `false`
  * @param value 要判断的值
  * @example
  * ```js
@@ -821,6 +1369,22 @@ declare function fastClone<T>(obj: T, map?: Map<any, any>): T;
  */
 declare function isEmpty(value: unknown): boolean;
 
+/**
+ * 将一个函数记忆化, 多次调用如果参数相同, 则直接返回缓存的结果, 而不会反复执行函数
+ * - 每次运行时会将当前参数处理为 `key`, 相同 `key` 的函数调用将返回相同的结果
+ * @param fn 要缓存的函数
+ * @param options 缓存选项
+ * - `getKey` 自定义 key 的生成规则, 默认使用内部方法生成 key
+ * - `ttl` 缓存的过期时间, 单位毫秒, 为 0 表示不过期, 默认不过期
+ * - `count` 缓存最大使用次数, 为 0 表示不限次数, 默认不限次数
+ * @returns
+ */
+declare function memo<TArgs extends any[], TRes>(fn: (...args: TArgs) => TRes, options?: {
+    getKey?: (...args: TArgs) => string | number;
+    ttl?: number;
+    count?: number;
+}): (this: any, ...args: TArgs) => TRes;
+
 /**
  * 不做任何操作，返回 `void` ，一般用于函数式编程
  * @example
@@ -988,18 +1552,4 @@ declare function pipe<PipeArgs extends any[], PipeResult, Mid1, Mid2, Mid3, Mid4
 declare function pipe<PipeArgs extends any[], PipeResult, Mid1, Mid2, Mid3, Mid4, Mid5, Mid6, Mid7>(...pipeFunc: PipeFuncList8<PipeArgs, PipeResult, Mid1, Mid2, Mid3, Mid4, Mid5, Mid6, Mid7>): (...args: PipeArgs) => PipeResult;
 declare function pipe<PipeArgs extends any[], PipeResult, Mid1, Mid2, Mid3, Mid4, Mid5, Mid6, Mid7>(...pipeFunc: PipeFuncListMore<PipeArgs, PipeResult, Mid1, Mid2, Mid3, Mid4, Mid5, Mid6, Mid7>): (...args: PipeArgs) => PipeResult;
 
-/**
- * 分割单词, 适用于分割、转换变量名的场景
- * - 任何非英文字母、数字的字符均会视为分割符
- * @param str 需要分割的字符串
- * @returns 分割后的字符串
- * @example
- * ```js
- * splitWords("getTestUUID1234") // ["get", "Test", "UUID", "1234"]
- * splitWords("user_nick_name") // ["user", "nick", "name"]
- * splitWords("A文字B🎈C=-=Test") // ["A", "B", "C", "Test"]
- * ```
- */
-declare function splitWords(str: string): string[];
-
-export { _, acceptableFileName, acceptableFileType, caseCamel, caseConvert, caseKebab, casePascal, caseSnake, compose, _curryMore as curry, fastClone, getAcceptableExtByMIME, getAcceptableMIMEByExt, getGlobalThis, getTag, isArray, isArrayBuffer, isArrayLike, isBigInt, isBoolean, isBuffer, isEmpty, isFunction, isInteger, isMap, isNil, isNull, isNumber, isObject, isPlaceholder, isPrimitive, isPromise, isPromiseLike, isSet, isString, isSymbol, isUndefined, isWeakMap, isWeakSet, isWrapperBigInt, isWrapperBoolean, isWrapperNumber, isWrapperObject, isWrapperString, isWrapperSymbol, noop, not, pass, passWith, pipe, randomBase32String, randomChoice, randomHexString, randomInt, randomIntFloor, randomString, shuffle, splitWords, ulid, uuidNil, uuidV4 };
+export { type CloneOptions, type CustomCloner, type RangeOptions, type TypedArray, _, acceptableFileName, acceptableFileType, camelCase, caseCamel, caseConvert, caseKebab, casePascal, caseSnake, compose, _curryMore as curry, deepClone, 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, pascalCase, pass, passWith, pipe, randomBase32String, randomChoice, randomHexString, randomInt, randomIntFloor, randomString, range, shuffle, sleep, snakeCase, splitWords, titleCase, tryit, ulid, uuidNil, uuidV4, withResolvers };