@aiao/utils 0.0.6 → 0.0.8

package/dist/random/randomUintByLength.d.ts

@@ -1,2 +1,17 @@
+/**
+ * 生成指定位数的随机正整数
+ * 通过生成随机数字字符串然后转换为数字实现
+ * @param length - 数字的位数，默认 16
+ * @returns 指定位数的随机正整数
+ * @example
+ * randomUintByLength(3); // 返回 3 位随机数，如 123、456、789
+ * @example
+ * randomUintByLength(1); // 返回 1 位随机数，如 1、2、3、4、5、6、7、8、9（不含 0）
+ * @example
+ * randomUintByLength(5); // 返回 5 位随机数，如 12345
+ * **Note:** 第一位不会是 0，确保返回的数字位数正确
+ * **Note:** 使用 randomUintString 生成字符串后转换为数字
+ * **Note:** 对于大位数（>15），可能超出 JavaScript 安全整数范围
+ */
 export declare const randomUintByLength: (length?: number) => number;
 //# sourceMappingURL=randomUintByLength.d.ts.map

package/dist/random/randomUintByLength.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"randomUintByLength.d.ts","sourceRoot":"","sources":["../../src/random/randomUintByLength.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,kBAAkB,GAAI,SAAQ,MAAW,KAAG,MAAgD,CAAC"}
+{"version":3,"file":"randomUintByLength.d.ts","sourceRoot":"","sources":["../../src/random/randomUintByLength.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,kBAAkB,GAAI,SAAQ,MAAW,KAAG,MAAgD,CAAC"}

package/dist/random/randomUintString.d.ts

@@ -1,2 +1,17 @@
+/**
+ * 生成指定长度的随机数字字符串，第一位不为 0
+ * 适用于生成数字 ID 或序列号，确保不会以 0 开头
+ * @param length - 字符串长度，默认 16
+ * @returns 指定长度的随机数字字符串
+ * @example
+ * randomUintString(3); // 返回 3 位数字字符串，如 '123'、'456'、'789'
+ * @example
+ * randomUintString(1); // 返回 1 位数字字符串，如 '1'、'2'、'3'...'9'
+ * @example
+ * randomUintString(5); // 返回 5 位数字字符串，如 '12345'
+ * **Note:** 第一位使用 NUMBER_WITHOUT_ZERO（1-9），其余位使用 NUMBERS（0-9）
+ * **Note:** 确保生成的字符串可以安全转换为正整数
+ * **Note:** 适用于生成唯一标识符或序列号
+ */
 export declare const randomUintString: (length?: number) => string;
 //# sourceMappingURL=randomUintString.d.ts.map

package/dist/random/randomUintString.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"randomUintString.d.ts","sourceRoot":"","sources":["../../src/random/randomUintString.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,gBAAgB,GAAI,SAAQ,MAAW,KAAG,MACmB,CAAC"}
+{"version":3,"file":"randomUintString.d.ts","sourceRoot":"","sources":["../../src/random/randomUintString.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,gBAAgB,GAAI,SAAQ,MAAW,KAAG,MACmB,CAAC"}

package/dist/string/camelCase.d.ts

@@ -17,7 +17,7 @@
  * camelCase('  hello--world  '); // 返回 'helloWorld'（自动去除首尾空格）
  * @example
  * camelCase('');                 // 返回 ''（空字符串输入返回空字符串）
- * @note 内部使用getWords()函数拆分单词，使用capitalize()函数处理单词首字母
+ * **Note:** 内部使用getWords()函数拆分单词，使用capitalize()函数处理单词首字母
  */
 export declare function camelCase(str: string): string;
 //# sourceMappingURL=camelCase.d.ts.map

package/dist/string/getWords.d.ts

@@ -1,2 +1,23 @@
+/**
+ * 从字符串中提取单词，使用大小写和数字边界进行分割
+ * 支持驼峰命名、帕斯卡命名和包含数字的字符串
+ * @param str - 要分割的字符串
+ * @returns 分割后的单词数组
+ * @example
+ * getWords('camelCaseString'); // 返回 ['camel', 'Case', 'String']
+ * @example
+ * getWords('PascalCaseString'); // 返回 ['Pascal', 'Case', 'String']
+ * @example
+ * getWords('stringWith123Numbers'); // 返回 ['string', 'With', '123', 'Numbers']
+ * @example
+ * getWords('HTMLParser'); // 返回 ['HTML', 'Parser']
+ * @example
+ * getWords('simple'); // 返回 ['simple']
+ * @example
+ * getWords(''); // 返回 []
+ * **Note:** 使用正则表达式 /[A-Z]?[a-z]+|[0-9]+|[A-Z]+(?![a-z])/g 进行匹配
+ * **Note:** 连续的大写字母会被视为一个单词（如 'HTML'）
+ * **Note:** 数字序列会被单独提取（如 '123'）
+ */
 export declare const getWords: (str: string) => string[];
 //# sourceMappingURL=getWords.d.ts.map

package/dist/string/getWords.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getWords.d.ts","sourceRoot":"","sources":["../../src/string/getWords.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,QAAQ,GAAI,KAAK,MAAM,KAAG,MAAM,EAAqD,CAAC"}
+{"version":3,"file":"getWords.d.ts","sourceRoot":"","sources":["../../src/string/getWords.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,QAAQ,GAAI,KAAK,MAAM,KAAG,MAAM,EAAqD,CAAC"}

package/dist/string/kebabCase.d.ts

@@ -1,7 +1,7 @@
 /**
  * 转换为 kebab-case
- * @param value
- * @returns
+ * @param str 输入字符串
+ * @returns kebab-case 格式的字符串
  *
  * @example
  * camelCase -> 'camel-case'

package/dist/string/stringSingleline.d.ts

@@ -1,5 +1,18 @@
 /**
- * 单行文本
+ * 将多行文本转换为单行文本，移除多余的空白字符
+ * 去除首尾空白，并将连续的空白字符替换为单个空格
+ * @param value - 要处理的字符串
+ * @returns 处理后的单行字符串
+ * @example
+ * stringSingleline('  hello   world  '); // 返回 'hello world'
+ * @example
+ * stringSingleline('line1\nline2\tline3'); // 返回 'line1 line2 line3'
+ * @example
+ * stringSingleline('multiple   spaces'); // 返回 'multiple spaces'
+ * @example
+ * stringSingleline(''); // 返回 ''
+ * **Note:** 先使用 trim() 去除首尾空白，然后用正则 /\s+/g 替换连续空白为单个空格
+ * **Note:** 适用于清理用户输入或格式化显示文本
  */
 export declare const stringSingleline: (value: string) => string;
 //# sourceMappingURL=stringSingleline.d.ts.map

package/dist/string/stringSingleline.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"stringSingleline.d.ts","sourceRoot":"","sources":["../../src/string/stringSingleline.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,eAAO,MAAM,gBAAgB,GAAI,OAAO,MAAM,WAAsC,CAAC"}
+{"version":3,"file":"stringSingleline.d.ts","sourceRoot":"","sources":["../../src/string/stringSingleline.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,gBAAgB,GAAI,OAAO,MAAM,WAAsC,CAAC"}

package/dist/string/stringToArrayBuffer.d.ts

@@ -1,7 +1,6 @@
 /**
  * 字符串转 ArrayBuffer
  *
- * @export
  * @param str
  */
 export declare function stringToArrayBuffer(str: string): ArrayBuffer;

package/dist/string/stringToArrayBuffer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"stringToArrayBuffer.d.ts","sourceRoot":"","sources":["../../src/string/stringToArrayBuffer.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,MAAM,eAO9C"}
+{"version":3,"file":"stringToArrayBuffer.d.ts","sourceRoot":"","sources":["../../src/string/stringToArrayBuffer.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,MAAM,eAO9C"}

package/dist/tools/event.d.ts

@@ -1,36 +1,40 @@
 /**
- * 事件接口
- */
-export interface Event {
-    type: string;
-}
-/**
- * 自定义事件映射接口
+ * 事件映射接口
+ * 定义事件名称到事件数据的映射关系
+ *
+ * @example
+ * ```typescript
+ * interface MyEvents {
+ *   'click': { x: number; y: number };
+ *   'change': { value: string };
+ * }
+ * ```
  */
-export interface CustomEvents {
+export interface EventMap {
     [eventName: string]: any;
 }
 /**
  * 事件监听器类型
  */
-export type EventListener<T> = (event: T) => void;
-export interface IEventDispatcher<Events extends CustomEvents = CustomEvents> {
+export type EventListener<T> = (data: T) => void;
+export interface IEventDispatcher<Events extends EventMap = EventMap> {
     addEventListener<T extends keyof Events>(type: T, listener: EventListener<Events[T]>): void;
     hasEventListener<T extends keyof Events>(type: T, listener: EventListener<Events[T]>): boolean;
     removeEventListener<T extends keyof Events>(type: T, listener: EventListener<Events[T]>): void;
-    dispatchEvent(event: Events[keyof Events]): void;
-    removeAllEventListener(): void;
+    dispatchEvent<T extends keyof Events>(type: T, data: Events[T]): void;
+    removeAllEventListeners(): void;
 }
 /**
- * 自定义事件调度器
- * 提供事件的添加、移除和分发功能
+ * 事件调度器
+ * 提供类型安全的事件添加、移除和分发功能
  *
- * @template Events - 事件类型映射
+ * @template Events - 事件映射类型
  * @example
+ * ```typescript
  * // 定义事件类型
- * interface MyEvents extends CustomEvents {
- *   'click': { type: 'click', x: number, y: number };
- *   'change': { type: 'change', value: string };
+ * interface MyEvents {
+ *   'click': { x: number; y: number };
+ *   'change': { value: string };
  * }
  *
  * // 创建事件调度器
@@ -38,12 +42,13 @@ export interface IEventDispatcher<Events extends CustomEvents = CustomEvents> {
  *
  * // 使用事件调度器
  * const dispatcher = new MyEventDispatcher();
- * dispatcher.addEventListener('click', (event) => {
- *   console.log(`Click at ${event.x}, ${event.y}`);
+ * dispatcher.addEventListener('click', (data) => {
+ *   console.log(`Click at ${data.x}, ${data.y}`);
  * });
- * dispatcher.dispatchEvent({ type: 'click', x: 10, y: 20 });
+ * dispatcher.dispatchEvent('click', { x: 10, y: 20 });
+ * ```
  */
-export declare abstract class EventDispatcher<Events extends CustomEvents = CustomEvents> implements IEventDispatcher<Events> {
+export declare abstract class EventDispatcher<Events extends EventMap = EventMap> implements IEventDispatcher<Events> {
     #private;
     /**
      * 添加事件监听器
@@ -66,12 +71,13 @@ export declare abstract class EventDispatcher<Events extends CustomEvents = Cust
     removeEventListener<T extends keyof Events>(type: T, listener: EventListener<Events[T]>): void;
     /**
      * 分发事件
-     * @param event - 要分发的事件对象
+     * @param type - 事件类型
+     * @param data - 事件数据
      */
-    dispatchEvent(event: Events[keyof Events]): void;
+    dispatchEvent<T extends keyof Events>(type: T, data: Events[T]): void;
     /**
      * 移除所有事件监听器
      */
-    removeAllEventListener(): void;
+    removeAllEventListeners(): void;
 }
 //# sourceMappingURL=event.d.ts.map

package/dist/tools/event.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"event.d.ts","sourceRoot":"","sources":["../../src/tools/event.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,WAAW,KAAK;IACpB,IAAI,EAAE,MAAM,CAAC;CACd;AAED;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,CAAC,SAAS,EAAE,MAAM,GAAG,GAAG,CAAC;CAC1B;AAED;;GAEG;AACH,MAAM,MAAM,aAAa,CAAC,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,CAAC;AAElD,MAAM,WAAW,gBAAgB,CAAC,MAAM,SAAS,YAAY,GAAG,YAAY;IAC1E,gBAAgB,CAAC,CAAC,SAAS,MAAM,MAAM,EAAE,IAAI,EAAE,CAAC,EAAE,QAAQ,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;IAE5F,gBAAgB,CAAC,CAAC,SAAS,MAAM,MAAM,EAAE,IAAI,EAAE,CAAC,EAAE,QAAQ,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC;IAE/F,mBAAmB,CAAC,CAAC,SAAS,MAAM,MAAM,EAAE,IAAI,EAAE,CAAC,EAAE,QAAQ,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;IAC/F,aAAa,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,MAAM,CAAC,GAAG,IAAI,CAAC;IACjD,sBAAsB,IAAI,IAAI,CAAC;CAChC;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,8BAAsB,eAAe,CAAC,MAAM,SAAS,YAAY,GAAG,YAAY,CAAE,YAAW,gBAAgB,CAAC,MAAM,CAAC;;IAGnH;;;;OAIG;IACH,gBAAgB,CAAC,CAAC,SAAS,MAAM,MAAM,EAAE,IAAI,EAAE,CAAC,EAAE,QAAQ,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI;IAI3F;;;;;OAKG;IACH,gBAAgB,CAAC,CAAC,SAAS,MAAM,MAAM,EAAE,IAAI,EAAE,CAAC,EAAE,QAAQ,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,GAAG,OAAO;IAI9F;;;;OAIG;IACH,mBAAmB,CAAC,CAAC,SAAS,MAAM,MAAM,EAAE,IAAI,EAAE,CAAC,EAAE,QAAQ,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI;IAI9F;;;OAGG;IACH,aAAa,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,MAAM,CAAC,GAAG,IAAI;IAIhD;;OAEG;IACH,sBAAsB,IAAI,IAAI;CAmB/B"}
+{"version":3,"file":"event.d.ts","sourceRoot":"","sources":["../../src/tools/event.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,QAAQ;IACvB,CAAC,SAAS,EAAE,MAAM,GAAG,GAAG,CAAC;CAC1B;AAED;;GAEG;AACH,MAAM,MAAM,aAAa,CAAC,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,KAAK,IAAI,CAAC;AAEjD,MAAM,WAAW,gBAAgB,CAAC,MAAM,SAAS,QAAQ,GAAG,QAAQ;IAClE,gBAAgB,CAAC,CAAC,SAAS,MAAM,MAAM,EAAE,IAAI,EAAE,CAAC,EAAE,QAAQ,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;IAE5F,gBAAgB,CAAC,CAAC,SAAS,MAAM,MAAM,EAAE,IAAI,EAAE,CAAC,EAAE,QAAQ,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC;IAE/F,mBAAmB,CAAC,CAAC,SAAS,MAAM,MAAM,EAAE,IAAI,EAAE,CAAC,EAAE,QAAQ,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;IAE/F,aAAa,CAAC,CAAC,SAAS,MAAM,MAAM,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,MAAM,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;IAEtE,uBAAuB,IAAI,IAAI,CAAC;CACjC;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,8BAAsB,eAAe,CAAC,MAAM,SAAS,QAAQ,GAAG,QAAQ,CAAE,YAAW,gBAAgB,CAAC,MAAM,CAAC;;IAG3G;;;;OAIG;IACH,gBAAgB,CAAC,CAAC,SAAS,MAAM,MAAM,EAAE,IAAI,EAAE,CAAC,EAAE,QAAQ,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI;IAI3F;;;;;OAKG;IACH,gBAAgB,CAAC,CAAC,SAAS,MAAM,MAAM,EAAE,IAAI,EAAE,CAAC,EAAE,QAAQ,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,GAAG,OAAO;IAI9F;;;;OAIG;IACH,mBAAmB,CAAC,CAAC,SAAS,MAAM,MAAM,EAAE,IAAI,EAAE,CAAC,EAAE,QAAQ,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI;IAI9F;;;;OAIG;IACH,aAAa,CAAC,CAAC,SAAS,MAAM,MAAM,EAAE,IAAI,EAAE,CAAC,EAAE,IAAI,EAAE,MAAM,CAAC,CAAC,CAAC,GAAG,IAAI;IAUrE;;OAEG;IACH,uBAAuB,IAAI,IAAI;CAiBhC"}

package/dist/type-definition/result-types.d.ts

@@ -1,12 +1,34 @@
 import { XOR } from 'ts-xor';
-export interface SuccessResult<SuccessDataType = any> {
-    data: SuccessDataType;
+/**
+ * 成功结果接口，包含成功时返回的数据
+ * @template T - 成功数据类型，默认为 any
+ */
+export interface SuccessResult<T = any> {
+    /** 成功时返回的数据 */
+    data: T;
 }
+/**
+ * 错误结果接口，包含失败时返回的错误信息
+ * @template ErrorDataType - 错误数据类型，默认为 any
+ */
 export interface ErrorResult<ErrorDataType = any> {
+    /** 失败时返回的错误信息 */
     error: ErrorDataType;
 }
 /**
- * 结果返回类型
+ * 结果返回类型，要么是成功结果，要么是错误结果，两者互斥
+ * 使用 XOR 类型确保结果对象要么有 data 属性，要么有 error 属性，不能同时存在
+ * @template T - 成功数据类型，默认为 any
+ * @template ErrorDataType - 错误数据类型，默认为 any
+ * @example
+ * // 成功结果
+ * const success: Result<string> = { data: '操作成功' };
+ *
+ * // 错误结果
+ * const error: Result<string, string> = { error: '操作失败' };
+ *
+ * // 类型检查会阻止同时包含 data 和 error
+ * // const invalid: Result = { data: 'ok', error: 'error' }; // 编译错误
  */
-export type Result<SuccessDataType = any, ErrorDataType = any> = XOR<SuccessResult<SuccessDataType>, ErrorResult<ErrorDataType>>;
+export type Result<T = any, ErrorDataType = any> = XOR<SuccessResult<T>, ErrorResult<ErrorDataType>>;
 //# sourceMappingURL=result-types.d.ts.map

package/dist/type-definition/result-types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"result-types.d.ts","sourceRoot":"","sources":["../../src/type-definition/result-types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,QAAQ,CAAC;AAE7B,MAAM,WAAW,aAAa,CAAC,eAAe,GAAG,GAAG;IAClD,IAAI,EAAE,eAAe,CAAC;CACvB;AACD,MAAM,WAAW,WAAW,CAAC,aAAa,GAAG,GAAG;IAC9C,KAAK,EAAE,aAAa,CAAC;CACtB;AAED;;GAEG;AACH,MAAM,MAAM,MAAM,CAAC,eAAe,GAAG,GAAG,EAAE,aAAa,GAAG,GAAG,IAAI,GAAG,CAClE,aAAa,CAAC,eAAe,CAAC,EAC9B,WAAW,CAAC,aAAa,CAAC,CAC3B,CAAC"}
+{"version":3,"file":"result-types.d.ts","sourceRoot":"","sources":["../../src/type-definition/result-types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,QAAQ,CAAC;AAE7B;;;GAGG;AACH,MAAM,WAAW,aAAa,CAAC,CAAC,GAAG,GAAG;IACpC,eAAe;IACf,IAAI,EAAE,CAAC,CAAC;CACT;AAED;;;GAGG;AACH,MAAM,WAAW,WAAW,CAAC,aAAa,GAAG,GAAG;IAC9C,iBAAiB;IACjB,KAAK,EAAE,aAAa,CAAC;CACtB;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,MAAM,CAAC,CAAC,GAAG,GAAG,EAAE,aAAa,GAAG,GAAG,IAAI,GAAG,CAAC,aAAa,CAAC,CAAC,CAAC,EAAE,WAAW,CAAC,aAAa,CAAC,CAAC,CAAC"}

package/dist/types/AnyFunction.d.ts

@@ -14,8 +14,8 @@
  * // 匹配异步函数
  * const func3: AnyFunction = async () => { await Promise.resolve(); return 42; };
  *
- * @note 此类型提供了最大的灵活性，但牺牲了类型安全性
- * @note 对于需要类型安全的场景，建议使用更具体的函数类型
+ * **Note:** 此类型提供了最大的灵活性，但牺牲了类型安全性
+ * **Note:** 对于需要类型安全的场景，建议使用更具体的函数类型
  */
 export type AnyFunction = (...args: any[]) => any;
 //# sourceMappingURL=AnyFunction.d.ts.map

package/dist/types/DeepPartial.d.ts

@@ -39,9 +39,9 @@
  *   }],
  * };
  *
- * @note 此类型递归地将所有属性变为可选，包括嵌套对象和数组元素
- * @note 对于数组类型，会递归应用到数组元素的类型
- * @note 对于只读数组，保持其只读特性的同时递归应用到元素类型
+ * **Note:** 此类型递归地将所有属性变为可选，包括嵌套对象和数组元素
+ * **Note:** 对于数组类型，会递归应用到数组元素的类型
+ * **Note:** 对于只读数组，保持其只读特性的同时递归应用到元素类型
  */
 export declare type DeepPartial<T> = {
     [P in keyof T]?: T[P] extends Array<infer U> ? Array<DeepPartial<U>> : T[P] extends ReadonlyArray<infer UE> ? ReadonlyArray<DeepPartial<UE>> : DeepPartial<T[P]>;

package/dist/types/isArray.d.ts

@@ -14,7 +14,7 @@
  * isArray(null); // 返回 false（null不是数组）
  * @example
  * isArray("array"); // 返回 false（字符串不是数组）
- * @note 这是对原生Array.isArray函数的直接重导出，保持与原生函数相同的行为
+ * **Note:** 这是对原生Array.isArray函数的直接重导出，保持与原生函数相同的行为
  */
 export declare const isArray: (arg: any) => arg is any[];
 //# sourceMappingURL=isArray.d.ts.map

package/dist/types/isArrayBuffer.d.ts

@@ -16,9 +16,9 @@
  * isArrayBuffer(undefined); // 返回 false（undefined不是ArrayBuffer）
  * @example
  * isArrayBuffer(new Uint8Array()); // 返回 false（Uint8Array不是ArrayBuffer）
- * @note 函数使用instanceof运算符判断是否为ArrayBuffer实例
- * @note ArrayBuffer是用于表示通用的、固定长度的原始二进制数据缓冲区
- * @note 与TypedArray（如Uint8Array）的区别：ArrayBuffer是原始二进制数据，而TypedArray是对其的视图
+ * **Note:** 函数使用instanceof运算符判断是否为ArrayBuffer实例
+ * **Note:** ArrayBuffer是用于表示通用的、固定长度的原始二进制数据缓冲区
+ * **Note:** 与TypedArray（如Uint8Array）的区别：ArrayBuffer是原始二进制数据，而TypedArray是对其的视图
  */
 export declare const isArrayBuffer: (value: unknown) => value is ArrayBuffer;
 //# sourceMappingURL=isArrayBuffer.d.ts.map

package/dist/types/isBoolean.d.ts

@@ -20,9 +20,9 @@
  * isBoolean(null); // 返回 false（null不是布尔类型）
  * @example
  * isBoolean(undefined); // 返回 false（undefined不是布尔类型）
- * @note 函数使用三种方式判断：直接比较true/false、检查valueOf()返回值类型
- * @note 对于布尔对象(new Boolean())，valueOf()返回其原始布尔值
- * @note 与typeof的区别：typeof new Boolean(true)返回'object'，但isBoolean返回true
+ * **Note:** 函数使用三种方式判断：直接比较true/false、检查valueOf()返回值类型
+ * **Note:** 对于布尔对象(new Boolean())，valueOf()返回其原始布尔值
+ * **Note:** 与typeof的区别：typeof new Boolean(true)返回'object'，但isBoolean返回true
  */
 export declare function isBoolean(value: any): value is boolean;
 //# sourceMappingURL=isBoolean.d.ts.map

package/dist/types/isDate.d.ts

@@ -18,9 +18,9 @@
  * isDate({}); // 返回 false（普通对象不是Date对象）
  * @example
  * isDate(new Date('invalid date')); // 返回 true（即使是无效日期也是Date对象）
- * @note 函数使用两种方式判断：instanceof和Object.prototype.toString.call()
- * @note 对于无效日期（Invalid Date），函数仍返回true，因为它仍是Date对象
- * @note 与isDateString的区别：此函数检查是否为Date对象，而非日期字符串
+ * **Note:** 函数使用两种方式判断：instanceof和Object.prototype.toString.call()
+ * **Note:** 对于无效日期（Invalid Date），函数仍返回true，因为它仍是Date对象
+ * **Note:** 与isDateString的区别：此函数检查是否为Date对象，而非日期字符串
  */
 export declare function isDate(value: unknown): value is Date;
 //# sourceMappingURL=isDate.d.ts.map

package/dist/types/isEmpty.d.ts

@@ -32,10 +32,10 @@
  * isEmpty(() => {}); // 返回 false（函数）
  * @example
  * isEmpty(Symbol('foo')); // 返回 false（符号）
- * @note 空值定义：null、undefined、空字符串、空数组、空对象、数字0、布尔值false、无效日期
- * @note 函数和符号类型永远不会被视为空值
- * @note 对于有length属性的对象（如数组、字符串），length为0时视为空
- * @note 对于有size属性的对象（如Map、Set），size为0时视为空
+ * **Note:** 空值定义：null、undefined、空字符串、空数组、空对象、数字0、布尔值false、无效日期
+ * **Note:** 函数和符号类型永远不会被视为空值
+ * **Note:** 对于有length属性的对象（如数组、字符串），length为0时视为空
+ * **Note:** 对于有size属性的对象（如Map、Set），size为0时视为空
  */
 export declare const isEmpty: (value: unknown) => boolean;
 //# sourceMappingURL=isEmpty.d.ts.map

package/dist/types/isNil.d.ts

@@ -14,8 +14,8 @@
  * isNil(''); // 返回 false（空字符串不是null或undefined）
  * @example
  * isNil(false); // 返回 false（false不是null或undefined）
- * @note 此函数在判断null和undefined时使用严格相等运算符（===）
- * @note 与isEmpty的区别：isNil仅检查null和undefined，而isEmpty还会检查空字符串、空数组等
+ * **Note:** 此函数在判断null和undefined时使用严格相等运算符（===）
+ * **Note:** 与isEmpty的区别：isNil仅检查null和undefined，而isEmpty还会检查空字符串、空数组等
  */
 export declare const isNil: (value: unknown) => value is null | undefined;
 //# sourceMappingURL=isNil.d.ts.map

package/dist/types/isNumber.d.ts

@@ -22,9 +22,9 @@
  * isNumber(undefined); // 返回 false（undefined不是数字）
  * @example
  * isNumber(new Number(123)); // 返回 false（Number对象不是数字字面量）
- * @note 与typeof的区别：typeof NaN返回'number'，但isNumber(NaN)返回false
- * @note 函数使用try-catch块处理可能的类型转换异常
- * @note 数字字面量和Infinity都会返回true（Infinity是有效数字）
+ * **Note:** 与typeof的区别：typeof NaN返回'number'，但isNumber(NaN)返回false
+ * **Note:** 函数使用try-catch块处理可能的类型转换异常
+ * **Note:** 数字字面量和Infinity都会返回true（Infinity是有效数字）
  */
 export declare const isNumber: (value: any) => value is number;
 //# sourceMappingURL=isNumber.d.ts.map

package/dist/types/isObject.d.ts

@@ -16,8 +16,8 @@
  * isObject(new Date()); // 返回 false（日期对象不是纯对象）
  * @example
  * isObject(Object.create(null)); // 返回 false（没有constructor属性）
- * @note 此函数使用value.constructor === Object进行判断，因此不识别通过Object.create(null)创建的对象
- * @note 与isObjectLike的区别：isObjectLike仅检查值是否为非null的对象，而isObject还要求是通过Object构造函数创建的
+ * **Note:** 此函数使用value.constructor === Object进行判断，因此不识别通过Object.create(null)创建的对象
+ * **Note:** 与isObjectLike的区别：isObjectLike仅检查值是否为非null的对象，而isObject还要求是通过Object构造函数创建的
  */
 export declare const isObject: (value: unknown) => value is object;
 //# sourceMappingURL=isObject.d.ts.map

package/dist/types/isPlainObject.d.ts

@@ -20,9 +20,9 @@
  * isPlainObject(Object.create(null)); // 返回 true（原型为null的对象视为纯对象）
  * @example
  * isPlainObject(new Map()); // 返回 false（Map对象不是纯对象）
- * @note 函数通过检查toString标签和原型链来判断是否为纯对象
- * @note 与isObject的区别：isObject包含所有对象类型，而isPlainObject仅包含普通对象
- * @note 原型为null的对象（Object.create(null)）也被视为纯对象
+ * **Note:** 函数通过检查toString标签和原型链来判断是否为纯对象
+ * **Note:** 与isObject的区别：isObject包含所有对象类型，而isPlainObject仅包含普通对象
+ * **Note:** 原型为null的对象（Object.create(null)）也被视为纯对象
  */
 export declare function isPlainObject(object: unknown): object is object;
 //# sourceMappingURL=isPlainObject.d.ts.map

package/dist/types/isPrimitive.d.ts

@@ -26,9 +26,9 @@
  * isPrimitive(() => {}); // 返回 false（函数不是原始类型）
  * @example
  * isPrimitive(new Date()); // 返回 false（日期对象不是原始类型）
- * @note 函数使用typeof运算符和null检查来判断是否为原始类型
- * @note 原始类型是不可变的值，没有方法和属性（尽管JavaScript允许访问它们的包装对象方法）
- * @note 函数实现使用`value == null`来同时检查null和undefined
+ * **Note:** 函数使用typeof运算符和null检查来判断是否为原始类型
+ * **Note:** 原始类型是不可变的值，没有方法和属性（尽管JavaScript允许访问它们的包装对象方法）
+ * **Note:** 函数实现使用`value == null`来同时检查null和undefined
  */
 export declare function isPrimitive(value: unknown): value is null | undefined | string | number | boolean | symbol | bigint;
 //# sourceMappingURL=isPrimitive.d.ts.map

package/dist/types/isRegExp.d.ts

@@ -16,9 +16,9 @@
  * isRegExp(undefined); // 返回 false（undefined不是正则表达式）
  * @example
  * isRegExp({}); // 返回 false（普通对象不是正则表达式）
- * @note 函数使用instanceof运算符判断是否为RegExp实例
- * @note 正则表达式字面量和通过RegExp构造函数创建的正则表达式都会返回true
- * @note 字符串形式的正则表达式（如'/abc/'）不会被识别为正则表达式
+ * **Note:** 函数使用instanceof运算符判断是否为RegExp实例
+ * **Note:** 正则表达式字面量和通过RegExp构造函数创建的正则表达式都会返回true
+ * **Note:** 字符串形式的正则表达式（如'/abc/'）不会被识别为正则表达式
  */
 export declare function isRegExp(value: unknown): value is RegExp;
 //# sourceMappingURL=isRegExp.d.ts.map

package/dist/types/isString.d.ts

@@ -16,8 +16,8 @@
  * isString(undefined); // 返回 false（undefined不是字符串）
  * @example
  * isString(new String('hello')); // 返回 false（String对象不是字符串字面量）
- * @note 使用typeof运算符判断，对于String对象返回'object'而非'string'
- * @note 字符串字面量和空字符串都会返回true
+ * **Note:** 使用typeof运算符判断，对于String对象返回'object'而非'string'
+ * **Note:** 字符串字面量和空字符串都会返回true
  */
 export declare function isString(value: unknown): value is string;
 //# sourceMappingURL=isString.d.ts.map

package/dist/types/isUint8Array.d.ts

@@ -18,9 +18,9 @@
  * isUint8Array(new ArrayBuffer(8)); // 返回 false（ArrayBuffer不是Uint8Array）
  * @example
  * isUint8Array(new Uint16Array()); // 返回 false（Uint16Array不是Uint8Array）
- * @note 函数使用instanceof运算符判断是否为Uint8Array实例
- * @note Uint8Array是8位无符号整数类型化数组，范围为0到255
- * @note 与ArrayBuffer的区别：Uint8Array是对ArrayBuffer的视图，提供了对二进制数据的特定类型访问
+ * **Note:** 函数使用instanceof运算符判断是否为Uint8Array实例
+ * **Note:** Uint8Array是8位无符号整数类型化数组，范围为0到255
+ * **Note:** 与ArrayBuffer的区别：Uint8Array是对ArrayBuffer的视图，提供了对二进制数据的特定类型访问
  */
 export declare const isUint8Array: (value: unknown) => value is Uint8Array;
 //# sourceMappingURL=isUint8Array.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aiao/utils",
-  "version": "0.0.6",
+  "version": "0.0.8",
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -25,10 +25,10 @@
     ]
   },
   "dependencies": {
-    "rxjs": "^7.8.2",
     "fastest-levenshtein": "^1.0.16",
-    "ts-xor": "^1.3.0",
     "ms": "^2.1.3",
-    "type-fest": "^4.41.0"
+    "rxjs": "^7.8.2",
+    "ts-xor": "^1.3.0",
+    "type-fest": "^5.3.1"
   }
 }