@cloudcome/utils-core 1.19.1 → 1.20.1

package/dist/try.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"try.mjs","sources":["../src/try/curry.ts","../src/try/callback.ts","../src/try/function.ts","../src/try/promise.ts","../src/try/main.ts"],"sourcesContent":["// biome-ignore lint/suspicious/noConfusingVoidType: <explanation>\nexport type Callback<T = void> = (err: null | undefined | void | Error, res: T) => unknown;\n\nexport type CallbackFunction0<T = void> = (callback: Callback<T>) => unknown;\nexport type CallbackFunction1<A, T = void> = (a: A, callback: Callback<T>) => unknown;\nexport type CallbackFunction2<A, B, T = void> = (a: A, b: B, callback: Callback<T>) => unknown;\nexport type CallbackFunction3<A, B, C, T = void> = (a: A, b: B, c: C, callback: Callback<T>) => unknown;\nexport type CallbackFunction4<A, B, C, D, T = void> = (a: A, b: B, c: C, d: D, callback: Callback<T>) => unknown;\nexport type CallbackFunction5<A, B, C, D, E, T = void> = (\n  a: A,\n  b: B,\n  c: C,\n  d: D,\n  e: E,\n  callback: Callback<T>,\n) => unknown;\nexport type CallbackFunction6<A, B, C, D, E, F, T = void> = (\n  a: A,\n  b: B,\n  c: C,\n  d: D,\n  e: E,\n  f: F,\n  callback: Callback<T>,\n) => unknown;\n\nexport type CallbackCurried<T> = (callback: Callback<T>) => unknown;\n\nexport function callbackCurry<T = void>(cf: CallbackFunction0<T>): CallbackCurried<T>;\nexport function callbackCurry<A, T = void>(cf: CallbackFunction1<A, T>, a: A): CallbackCurried<T>;\nexport function callbackCurry<A, B, T = void>(cf: CallbackFunction2<A, B, T>, a: A, b: B): CallbackCurried<T>;\nexport function callbackCurry<A, B, C, T = void>(\n  cf: CallbackFunction3<A, B, C, T>,\n  a: A,\n  b: B,\n  c: C,\n): CallbackCurried<T>;\nexport function callbackCurry<A, B, C, D, T = void>(\n  cf: CallbackFunction4<A, B, C, D, T>,\n  a: A,\n  b: B,\n  c: C,\n  d: D,\n): CallbackCurried<T>;\nexport function callbackCurry<A, B, C, D, E, T = void>(\n  cf: CallbackFunction5<A, B, C, D, E, T>,\n  a: A,\n  b: B,\n  c: C,\n  d: D,\n  e: E,\n): CallbackCurried<T>;\nexport function callbackCurry<A, B, C, D, E, F, T = void>(\n  cf: CallbackFunction6<A, B, C, D, E, F, T>,\n  a: A,\n  b: B,\n  c: C,\n  d: D,\n  e: E,\n  f: F,\n): CallbackCurried<T>;\nexport function callbackCurry(cf: unknown, ...args: unknown[]): CallbackCurried<unknown> {\n  return function callbackCurried(callback: Callback<unknown>) {\n    // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n    // @ts-ignore\n    cf.apply(this, [...args, callback]);\n  };\n}\n","import { errorNormalize } from '@/error';\nimport type {\n  CallbackFunction0,\n  CallbackFunction1,\n  CallbackFunction2,\n  CallbackFunction3,\n  CallbackFunction4,\n  CallbackFunction5,\n  CallbackFunction6,\n} from './curry';\nimport { callbackCurry } from './curry';\nimport type { FlattenReturn } from './types';\n\nexport function tryCallback(cf: CallbackFunction0): Promise<FlattenReturn>;\nexport function tryCallback<T = void>(cf: CallbackFunction0<T>): Promise<FlattenReturn<T>>;\nexport function tryCallback<A, T = void>(cf: CallbackFunction1<A, T>, a: A): Promise<FlattenReturn<T>>;\nexport function tryCallback<A, B, T = void>(cf: CallbackFunction2<A, B, T>, a: A, b: B): Promise<FlattenReturn<T>>;\nexport function tryCallback<A, B, C, T = void>(\n  cf: CallbackFunction3<A, B, C, T>,\n  a: A,\n  b: B,\n  c: C,\n): Promise<FlattenReturn<T>>;\nexport function tryCallback<A, B, C, D, T = void>(\n  cf: CallbackFunction4<A, B, C, D>,\n  a: A,\n  b: B,\n  c: C,\n  d: D,\n): Promise<FlattenReturn<T>>;\nexport function tryCallback<A, B, C, D, E, T = void>(\n  cf: CallbackFunction5<A, B, C, D, E, T>,\n  a: A,\n  b: B,\n  c: C,\n  d: D,\n  e: E,\n): Promise<FlattenReturn<T>>;\nexport function tryCallback<A, B, C, D, E, F, T = void>(\n  cf: CallbackFunction6<A, B, C, D, E, F, T>,\n  a: A,\n  b: B,\n  c: C,\n  d: D,\n  e: E,\n  f: F,\n): Promise<FlattenReturn<T>>;\nexport function tryCallback(cf: unknown, ...args: unknown[]): Promise<FlattenReturn<unknown>> {\n  return new Promise((resolve) => {\n    // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n    // @ts-ignore\n    callbackCurry.apply(this, [cf, ...args])((err, res) => {\n      if (err) {\n        resolve([errorNormalize(err), undefined] as const);\n      } else {\n        resolve([undefined, res] as const);\n      }\n    });\n  });\n}\n","import { errorNormalize } from '@/error';\nimport type { FlattenReturn } from './types';\n\nexport type SyncFunction<T> = () => T;\n\nexport function trySync<T>(syncFn: SyncFunction<T>): FlattenReturn<T> {\n  try {\n    return [undefined, syncFn()] as const;\n  } catch (err) {\n    return [errorNormalize(err), undefined] as const;\n  }\n}\n\nexport type AsyncFunction<T> = () => Promise<T>;\n\nexport function tryAsync<T>(asyncFn: AsyncFunction<T>): Promise<FlattenReturn<T>> {\n  return asyncFn().then(\n    (res) => [undefined, res] as const,\n    (err) => [errorNormalize(err), undefined] as const,\n  );\n}\n","import { errorNormalize } from '@/error';\nimport type { FlattenReturn } from './types';\n\nexport function tryPromise<T>(promise: PromiseLike<T>): PromiseLike<FlattenReturn<T>> {\n  return promise.then(\n    (res) => [undefined, res] as const,\n    (err) => [errorNormalize(err), undefined] as const,\n  );\n}\n","import { isAsyncFunction } from '@/type';\nimport { tryCallback } from './callback';\nimport type { CallbackFunction0 } from './curry';\nimport { type AsyncFunction, type SyncFunction, tryAsync, trySync } from './function';\nimport { tryPromise } from './promise';\nimport type { FlattenReturn } from './types';\n\nexport type FlattenAble<T> = SyncFunction<T> | AsyncFunction<T> | CallbackFunction0<T> | PromiseLike<T>;\n\n// 注意顺序 AsyncFunction > SyncFunction > CallbackFunction0 > PromiseLike\n// 需要先匹配 AsyncFunction，否则会把入参当做同步函数\nexport function tryFlatten<T>(flattenAble: AsyncFunction<T>): Promise<FlattenReturn<T>>;\nexport function tryFlatten<T>(flattenAble: SyncFunction<T>): FlattenReturn<T>;\nexport function tryFlatten<T>(flattenAble: CallbackFunction0<T> | PromiseLike<T>): Promise<FlattenReturn<T>>;\nexport function tryFlatten<T>(flattenAble: FlattenAble<T>): unknown {\n  if ('then' in flattenAble) {\n    return tryPromise<T>(flattenAble);\n  }\n\n  // SyncFunction | AsyncFunction\n  if (flattenAble.length === 0) {\n    if (isAsyncFunction(flattenAble)) return tryAsync<T>(flattenAble as AsyncFunction<T>);\n    return trySync<T>(flattenAble as SyncFunction<T>);\n  }\n\n  return tryCallback<T>(flattenAble);\n}\n"],"names":[],"mappings":";;AA6DgB,SAAA,cAAc,OAAgB,MAA2C;AAChF,SAAA,SAAS,gBAAgB,UAA6B;AAG3D,OAAG,MAAM,MAAM,CAAC,GAAG,MAAM,QAAQ,CAAC;AAAA,EACpC;AACF;ACpBgB,SAAA,YAAY,OAAgB,MAAkD;AACrF,SAAA,IAAI,QAAQ,CAAC,YAAY;AAGhB,kBAAA,MAAM,MAAM,CAAC,IAAI,GAAG,IAAI,CAAC,EAAE,CAAC,KAAK,QAAQ;AACrD,UAAI,KAAK;AACP,gBAAQ,CAAC,eAAe,GAAG,GAAG,MAAS,CAAU;AAAA,MAAA,OAC5C;AACG,gBAAA,CAAC,QAAW,GAAG,CAAU;AAAA,MAAA;AAAA,IACnC,CACD;AAAA,EAAA,CACF;AACH;ACtDO,SAAS,QAAW,QAA2C;AAChE,MAAA;AACK,WAAA,CAAC,QAAW,QAAQ;AAAA,WACpB,KAAK;AACZ,WAAO,CAAC,eAAe,GAAG,GAAG,MAAS;AAAA,EAAA;AAE1C;AAIO,SAAS,SAAY,SAAsD;AAChF,SAAO,QAAU,EAAA;AAAA,IACf,CAAC,QAAQ,CAAC,QAAW,GAAG;AAAA,IACxB,CAAC,QAAQ,CAAC,eAAe,GAAG,GAAG,MAAS;AAAA,EAC1C;AACF;ACjBO,SAAS,WAAc,SAAwD;AACpF,SAAO,QAAQ;AAAA,IACb,CAAC,QAAQ,CAAC,QAAW,GAAG;AAAA,IACxB,CAAC,QAAQ,CAAC,eAAe,GAAG,GAAG,MAAS;AAAA,EAC1C;AACF;ACMO,SAAS,WAAc,aAAsC;AAClE,MAAI,UAAU,aAAa;AACzB,WAAO,WAAc,WAAW;AAAA,EAAA;AAI9B,MAAA,YAAY,WAAW,GAAG;AAC5B,QAAI,gBAAgB,WAAW,EAAG,QAAO,SAAY,WAA+B;AACpF,WAAO,QAAW,WAA8B;AAAA,EAAA;AAGlD,SAAO,YAAe,WAAW;AACnC;"}
+{"version":3,"file":"try.mjs","names":[],"sources":["../src/try/curry.ts","../src/try/callback.ts","../src/try/function.ts","../src/try/promise.ts","../src/try/main.ts"],"sourcesContent":["export type Callback<T = void> = (err: null | undefined | undefined | Error, res: T) => unknown;\n\nexport type CallbackFunction0<T = void> = (callback: Callback<T>) => unknown;\nexport type CallbackFunction1<A, T = void> = (a: A, callback: Callback<T>) => unknown;\nexport type CallbackFunction2<A, B, T = void> = (a: A, b: B, callback: Callback<T>) => unknown;\nexport type CallbackFunction3<A, B, C, T = void> = (a: A, b: B, c: C, callback: Callback<T>) => unknown;\nexport type CallbackFunction4<A, B, C, D, T = void> = (a: A, b: B, c: C, d: D, callback: Callback<T>) => unknown;\nexport type CallbackFunction5<A, B, C, D, E, T = void> = (\n  a: A,\n  b: B,\n  c: C,\n  d: D,\n  e: E,\n  callback: Callback<T>,\n) => unknown;\nexport type CallbackFunction6<A, B, C, D, E, F, T = void> = (\n  a: A,\n  b: B,\n  c: C,\n  d: D,\n  e: E,\n  f: F,\n  callback: Callback<T>,\n) => unknown;\n\nexport type CallbackCurried<T> = (callback: Callback<T>) => unknown;\n\nexport function callbackCurry<T = void>(cf: CallbackFunction0<T>): CallbackCurried<T>;\nexport function callbackCurry<A, T = void>(cf: CallbackFunction1<A, T>, a: A): CallbackCurried<T>;\nexport function callbackCurry<A, B, T = void>(cf: CallbackFunction2<A, B, T>, a: A, b: B): CallbackCurried<T>;\nexport function callbackCurry<A, B, C, T = void>(\n  cf: CallbackFunction3<A, B, C, T>,\n  a: A,\n  b: B,\n  c: C,\n): CallbackCurried<T>;\nexport function callbackCurry<A, B, C, D, T = void>(\n  cf: CallbackFunction4<A, B, C, D, T>,\n  a: A,\n  b: B,\n  c: C,\n  d: D,\n): CallbackCurried<T>;\nexport function callbackCurry<A, B, C, D, E, T = void>(\n  cf: CallbackFunction5<A, B, C, D, E, T>,\n  a: A,\n  b: B,\n  c: C,\n  d: D,\n  e: E,\n): CallbackCurried<T>;\nexport function callbackCurry<A, B, C, D, E, F, T = void>(\n  cf: CallbackFunction6<A, B, C, D, E, F, T>,\n  a: A,\n  b: B,\n  c: C,\n  d: D,\n  e: E,\n  f: F,\n): CallbackCurried<T>;\nexport function callbackCurry(cf: unknown, ...args: unknown[]): CallbackCurried<unknown> {\n  return function callbackCurried(callback: Callback<unknown>) {\n    // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n    // @ts-expect-error\n    cf.apply(this, [...args, callback]);\n  };\n}\n","import { errorNormalize } from '@/error';\nimport type {\n  CallbackFunction0,\n  CallbackFunction1,\n  CallbackFunction2,\n  CallbackFunction3,\n  CallbackFunction4,\n  CallbackFunction5,\n  CallbackFunction6,\n} from './curry';\nimport { callbackCurry } from './curry';\nimport type { FlattenReturn } from './types';\n\nexport function tryCallback(cf: CallbackFunction0): Promise<FlattenReturn>;\nexport function tryCallback<T = void>(cf: CallbackFunction0<T>): Promise<FlattenReturn<T>>;\nexport function tryCallback<A, T = void>(cf: CallbackFunction1<A, T>, a: A): Promise<FlattenReturn<T>>;\nexport function tryCallback<A, B, T = void>(cf: CallbackFunction2<A, B, T>, a: A, b: B): Promise<FlattenReturn<T>>;\nexport function tryCallback<A, B, C, T = void>(\n  cf: CallbackFunction3<A, B, C, T>,\n  a: A,\n  b: B,\n  c: C,\n): Promise<FlattenReturn<T>>;\nexport function tryCallback<A, B, C, D, T = void>(\n  cf: CallbackFunction4<A, B, C, D>,\n  a: A,\n  b: B,\n  c: C,\n  d: D,\n): Promise<FlattenReturn<T>>;\nexport function tryCallback<A, B, C, D, E, T = void>(\n  cf: CallbackFunction5<A, B, C, D, E, T>,\n  a: A,\n  b: B,\n  c: C,\n  d: D,\n  e: E,\n): Promise<FlattenReturn<T>>;\nexport function tryCallback<A, B, C, D, E, F, T = void>(\n  cf: CallbackFunction6<A, B, C, D, E, F, T>,\n  a: A,\n  b: B,\n  c: C,\n  d: D,\n  e: E,\n  f: F,\n): Promise<FlattenReturn<T>>;\nexport function tryCallback(cf: unknown, ...args: unknown[]): Promise<FlattenReturn<unknown>> {\n  return new Promise((resolve) => {\n    // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n    // @ts-expect-error\n    callbackCurry.apply(this, [cf, ...args])((err, res) => {\n      if (err) {\n        resolve([errorNormalize(err), undefined] as const);\n      } else {\n        resolve([undefined, res] as const);\n      }\n    });\n  });\n}\n","import { errorNormalize } from '@/error';\nimport type { FlattenReturn } from './types';\n\nexport type SyncFunction<T> = () => T;\n\nexport function trySync<T>(syncFn: SyncFunction<T>): FlattenReturn<T> {\n  try {\n    return [undefined, syncFn()] as const;\n  } catch (err) {\n    return [errorNormalize(err), undefined] as const;\n  }\n}\n\nexport type AsyncFunction<T> = () => Promise<T>;\n\nexport function tryAsync<T>(asyncFn: AsyncFunction<T>): Promise<FlattenReturn<T>> {\n  return asyncFn().then(\n    (res) => [undefined, res] as const,\n    (err) => [errorNormalize(err), undefined] as const,\n  );\n}\n","import { errorNormalize } from '@/error';\nimport type { FlattenReturn } from './types';\n\nexport function tryPromise<T>(promise: PromiseLike<T>): PromiseLike<FlattenReturn<T>> {\n  return promise.then(\n    (res) => [undefined, res] as const,\n    (err) => [errorNormalize(err), undefined] as const,\n  );\n}\n","import { isAsyncFunction } from '@/type';\nimport { tryCallback } from './callback';\nimport type { CallbackFunction0 } from './curry';\nimport { type AsyncFunction, type SyncFunction, tryAsync, trySync } from './function';\nimport { tryPromise } from './promise';\nimport type { FlattenReturn } from './types';\n\nexport type FlattenAble<T> = SyncFunction<T> | AsyncFunction<T> | CallbackFunction0<T> | PromiseLike<T>;\n\n// 注意顺序 AsyncFunction > SyncFunction > CallbackFunction0 > PromiseLike\n// 需要先匹配 AsyncFunction，否则会把入参当做同步函数\nexport function tryFlatten<T>(flattenAble: AsyncFunction<T>): Promise<FlattenReturn<T>>;\nexport function tryFlatten<T>(flattenAble: SyncFunction<T>): FlattenReturn<T>;\nexport function tryFlatten<T>(flattenAble: CallbackFunction0<T> | PromiseLike<T>): Promise<FlattenReturn<T>>;\nexport function tryFlatten<T>(flattenAble: FlattenAble<T>): unknown {\n  if ('then' in flattenAble) {\n    return tryPromise<T>(flattenAble);\n  }\n\n  // SyncFunction | AsyncFunction\n  if (flattenAble.length === 0) {\n    if (isAsyncFunction(flattenAble)) return tryAsync<T>(flattenAble as AsyncFunction<T>);\n    return trySync<T>(flattenAble as SyncFunction<T>);\n  }\n\n  return tryCallback<T>(flattenAble);\n}\n"],"mappings":";;;AA4DA,SAAgB,cAAc,IAAa,GAAG,MAA2C;CACvF,OAAO,SAAS,gBAAgB,UAA6B;EAG3D,GAAG,MAAM,MAAM,CAAC,GAAG,MAAM,SAAS,CAAC;;;;;ACjBvC,SAAgB,YAAY,IAAa,GAAG,MAAkD;CAC5F,OAAO,IAAI,SAAS,YAAY;EAG9B,cAAc,MAAM,MAAM,CAAC,IAAI,GAAG,KAAK,CAAC,EAAE,KAAK,QAAQ;GACrD,IAAI,KACF,QAAQ,CAAC,eAAe,IAAI,EAAE,KAAA,EAAU,CAAU;QAElD,QAAQ,CAAC,KAAA,GAAW,IAAI,CAAU;IAEpC;GACF;;;;ACrDJ,SAAgB,QAAW,QAA2C;CACpE,IAAI;EACF,OAAO,CAAC,KAAA,GAAW,QAAQ,CAAC;UACrB,KAAK;EACZ,OAAO,CAAC,eAAe,IAAI,EAAE,KAAA,EAAU;;;AAM3C,SAAgB,SAAY,SAAsD;CAChF,OAAO,SAAS,CAAC,MACd,QAAQ,CAAC,KAAA,GAAW,IAAI,GACxB,QAAQ,CAAC,eAAe,IAAI,EAAE,KAAA,EAAU,CAC1C;;;;AChBH,SAAgB,WAAc,SAAwD;CACpF,OAAO,QAAQ,MACZ,QAAQ,CAAC,KAAA,GAAW,IAAI,GACxB,QAAQ,CAAC,eAAe,IAAI,EAAE,KAAA,EAAU,CAC1C;;;;ACOH,SAAgB,WAAc,aAAsC;CAClE,IAAI,UAAU,aACZ,OAAO,WAAc,YAAY;CAInC,IAAI,YAAY,WAAW,GAAG;EAC5B,IAAI,gBAAgB,YAAY,EAAE,OAAO,SAAY,YAAgC;EACrF,OAAO,QAAW,YAA+B;;CAGnD,OAAO,YAAe,YAAY"}

package/dist/type.cjs

@@ -1,61 +1,162 @@
-"use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/type.ts
+/**
+* 获取未知类型的类型名称
+* @param unknown - 未知类型的值
+* @returns 类型名称字符串
+*/
 function typeIs(unknown) {
-  return Object.prototype.toString.call(unknown).slice(8, -1).toLowerCase();
+	return Object.prototype.toString.call(unknown).slice(8, -1).toLowerCase();
 }
+/**
+* 检查值是否为字符串
+* @param unknown - 未知类型的值
+* @returns 如果值为字符串则返回 true，否则返回 false
+*/
 function isString(unknown) {
-  return typeof unknown === "string";
+	return typeof unknown === "string";
 }
+/**
+* 检查值是否为布尔值
+* @param unknown - 未知类型的值
+* @returns 如果值为布尔值则返回 true，否则返回 false
+*/
 function isBoolean(unknown) {
-  return typeof unknown === "boolean";
+	return typeof unknown === "boolean";
 }
+/**
+* 检查值是否为符号
+* @param unknown - 未知类型的值
+* @returns 如果值为符号则返回 true，否则返回 false
+*/
 function isSymbol(unknown) {
-  return typeof unknown === "symbol";
+	return typeof unknown === "symbol";
 }
+/**
+* 检查值是否为大整数
+* @param unknown - 未知类型的值
+* @returns 如果值为大整数则返回 true，否则返回 false
+*/
 function isBigInt(unknown) {
-  return typeof unknown === "bigint";
+	return typeof unknown === "bigint";
 }
+/**
+* 检查值是否为数字
+* @param unknown - 未知类型的值
+* @returns 如果值为数字且不是 NaN 则返回 true，否则返回 false
+*/
 function isNumber(unknown) {
-  return typeof unknown === "number" && !Number.isNaN(unknown);
+	return typeof unknown === "number" && !Number.isNaN(unknown);
 }
+/**
+* 检查值是否为 undefined
+* @param unknown - 未知类型的值
+* @returns 如果值为 undefined 则返回 true，否则返回 false
+*/
 function isUndefined(unknown) {
-  return typeof unknown === "undefined";
+	return typeof unknown === "undefined";
 }
+/**
+* 检查值是否为 void
+* @param unknown - 未知类型的值
+* @returns 如果值为 undefined 则返回 true，否则返回 false
+*/
 function isVoid(unknown) {
-  return isUndefined(unknown);
-}
-function isNever(unknown) {
-}
+	return isUndefined(unknown);
+}
+/**
+* 永不执行，用于 switch-case/if-else 类型断言
+* @param unknown - 永远不会执行的值
+*/
+function isNever(_unknown) {}
+/**
+* 检查值是否为 null
+* @param unknown - 未知类型的值
+* @returns 如果值为 null 则返回 true，否则返回 false
+*/
 function isNull(unknown) {
-  return unknown === null;
+	return unknown === null;
 }
+/**
+* 检查值是否为 nullish（null 或 undefined 或 void）
+* @param unknown - 未知类型的值
+* @returns 如果值为 null 或 undefined 或 void 则返回 true，否则返回 false
+*/
 function isNullish(unknown) {
-  return isNull(unknown) || isUndefined(unknown) || isVoid(unknown);
+	return isNull(unknown) || isUndefined(unknown) || isVoid(unknown);
 }
+/**
+* 检查值是否为原始类型（null 或 非对象）
+* @param unknown - 未知类型的值
+* @returns 如果值为原始类型则返回 true，否则返回 false
+*/
 function isPrimitive(unknown) {
-  return isNull(unknown) || !(typeof unknown === "object" || typeof unknown === "function");
+	return isNull(unknown) || !(typeof unknown === "object" || typeof unknown === "function");
 }
+/**
+* 检查值是否为对象，但要注意，此时的对象类型是包含了数组和函数
+* @param unknown - 未知类型的值
+* @returns 如果值为对象则返回 true，否则返回 false
+*/
 function isObject(unknown) {
-  return typeIs(unknown) === "object";
+	return typeIs(unknown) === "object";
 }
+/**
+* 检查值是否为数组
+* @param unknown - 未知类型的值
+* @returns 如果值为数组则返回 true，否则返回 false
+*/
 function isArray(unknown) {
-  return Array.isArray(unknown);
+	return Array.isArray(unknown);
 }
+/**
+* 检查值是否为函数
+* @param unknown - 未知类型的值
+* @returns 如果值为函数则返回 true，否则返回 false
+*/
 function isFunction(unknown) {
-  return typeof unknown === "function";
-}
+	return typeof unknown === "function";
+}
+/**
+* 检查值是否为异步函数
+* @param unknown - 需要检查的值
+* @returns 如果值为异步函数则返回 true，否则返回 false
+* @example
+* ```typescript
+* async function example() {}
+*
+* isAsyncFunction(example); // true
+* isAsyncFunction(() => {}); // false
+* ```
+*/
 function isAsyncFunction(unknown) {
-  return isFunction(unknown) && unknown.constructor.name === "AsyncFunction";
+	return isFunction(unknown) && unknown.constructor.name === "AsyncFunction";
 }
+/**
+* 检查值是否为 Error 类型
+* @param unknown - 未知类型的值
+* @returns 如果值为 Error 类型则返回 true，否则返回 false
+*/
 function isError(unknown) {
-  return unknown instanceof Error;
+	return unknown instanceof Error;
 }
+/**
+* 检查值是否为 Promise 类型
+* @param unknown - 未知类型的值
+* @returns 如果值为 Promise 类型则返回 true，否则返回 false
+*/
 function isPromise(unknown) {
-  return typeIs(unknown) === "promise";
+	return typeIs(unknown) === "promise";
 }
+/**
+* 检查值是否为 Date 类型
+* @param unknown - 未知类型的值
+* @returns 如果值为 Date 类型则返回 true，否则返回 false
+*/
 function isDate(unknown) {
-  return unknown instanceof Date;
+	return unknown instanceof Date;
 }
+//#endregion
 exports.isArray = isArray;
 exports.isAsyncFunction = isAsyncFunction;
 exports.isBigInt = isBigInt;
@@ -75,4 +176,5 @@ exports.isSymbol = isSymbol;
 exports.isUndefined = isUndefined;
 exports.isVoid = isVoid;
 exports.typeIs = typeIs;
-//# sourceMappingURL=type.cjs.map
+
+//# sourceMappingURL=type.cjs.map

package/dist/type.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"type.cjs","sources":["../src/type.ts"],"sourcesContent":["import type { AnyArray, AnyAsyncFunction, AnyFunction, AnyObject } from './types';\n\n/**\n * 获取未知类型的类型名称\n * @param unknown - 未知类型的值\n * @returns 类型名称字符串\n */\nexport function typeIs(\n  unknown: unknown,\n):\n  | 'string'\n  | 'number'\n  | 'boolean'\n  | 'object'\n  | 'array'\n  | 'function'\n  | 'null'\n  | 'undefined'\n  | 'symbol'\n  | 'bigint'\n  | 'error'\n  | 'promise'\n  | string {\n  return Object.prototype.toString.call(unknown).slice(8, -1).toLowerCase();\n}\n\n/**\n * 检查值是否为字符串\n * @param unknown - 未知类型的值\n * @returns 如果值为字符串则返回 true，否则返回 false\n */\nexport function isString(unknown: unknown): unknown is string {\n  return typeof unknown === 'string';\n}\n\n/**\n * 检查值是否为布尔值\n * @param unknown - 未知类型的值\n * @returns 如果值为布尔值则返回 true，否则返回 false\n */\nexport function isBoolean(unknown: unknown): unknown is boolean {\n  return typeof unknown === 'boolean';\n}\n\n/**\n * 检查值是否为符号\n * @param unknown - 未知类型的值\n * @returns 如果值为符号则返回 true，否则返回 false\n */\nexport function isSymbol(unknown: unknown): unknown is symbol {\n  return typeof unknown === 'symbol';\n}\n\n/**\n * 检查值是否为大整数\n * @param unknown - 未知类型的值\n * @returns 如果值为大整数则返回 true，否则返回 false\n */\nexport function isBigInt(unknown: unknown): unknown is bigint {\n  return typeof unknown === 'bigint';\n}\n\n/**\n * 检查值是否为数字\n * @param unknown - 未知类型的值\n * @returns 如果值为数字且不是 NaN 则返回 true，否则返回 false\n */\nexport function isNumber(unknown: unknown): unknown is number {\n  return typeof unknown === 'number' && !Number.isNaN(unknown);\n}\n\n/**\n * 检查值是否为 undefined\n * @param unknown - 未知类型的值\n * @returns 如果值为 undefined 则返回 true，否则返回 false\n */\nexport function isUndefined(unknown: unknown): unknown is undefined {\n  return typeof unknown === 'undefined';\n}\n\n/**\n * 检查值是否为 void\n * @param unknown - 未知类型的值\n * @returns 如果值为 undefined 则返回 true，否则返回 false\n */\n// biome-ignore lint/suspicious/noConfusingVoidType: <explanation>\nexport function isVoid(unknown: unknown): unknown is void {\n  return isUndefined(unknown);\n}\n\n/**\n * 永不执行，用于 switch-case/if-else 类型断言\n * @param unknown - 永远不会执行的值\n */\nexport function isNever(unknown: never) {\n  //\n}\n\n/**\n * 检查值是否为 null\n * @param unknown - 未知类型的值\n * @returns 如果值为 null 则返回 true，否则返回 false\n */\nexport function isNull(unknown: unknown): unknown is null {\n  return unknown === null;\n}\n\n/**\n * 检查值是否为 nullish（null 或 undefined 或 void）\n * @param unknown - 未知类型的值\n * @returns 如果值为 null 或 undefined 或 void 则返回 true，否则返回 false\n */\n// biome-ignore lint/suspicious/noConfusingVoidType: <explanation>\nexport function isNullish(unknown: unknown): unknown is null | undefined | void {\n  return isNull(unknown) || isUndefined(unknown) || isVoid(unknown);\n}\n\n/**\n * 检查值是否为原始类型（null 或 非对象）\n * @param unknown - 未知类型的值\n * @returns 如果值为原始类型则返回 true，否则返回 false\n */\nexport function isPrimitive(\n  unknown: unknown,\n): unknown is string | number | boolean | symbol | bigint | null | undefined {\n  return isNull(unknown) || !(typeof unknown === 'object' || typeof unknown === 'function');\n}\n\n/**\n * 检查值是否为对象，但要注意，此时的对象类型是包含了数组和函数\n * @param unknown - 未知类型的值\n * @returns 如果值为对象则返回 true，否则返回 false\n */\nexport function isObject(unknown: unknown): unknown is AnyObject {\n  return typeIs(unknown) === 'object';\n}\n\n/**\n * 检查值是否为数组\n * @param unknown - 未知类型的值\n * @returns 如果值为数组则返回 true，否则返回 false\n */\nexport function isArray(unknown: unknown): unknown is AnyArray {\n  return Array.isArray(unknown);\n}\n\n/**\n * 检查值是否为函数\n * @param unknown - 未知类型的值\n * @returns 如果值为函数则返回 true，否则返回 false\n */\nexport function isFunction(unknown: unknown): unknown is AnyFunction {\n  return typeof unknown === 'function';\n}\n\n/**\n * 检查值是否为异步函数\n * @param unknown - 需要检查的值\n * @returns 如果值为异步函数则返回 true，否则返回 false\n * @example\n * ```typescript\n * async function example() {}\n *\n * isAsyncFunction(example); // true\n * isAsyncFunction(() => {}); // false\n * ```\n */\nexport function isAsyncFunction(unknown: unknown): unknown is AnyAsyncFunction {\n  return isFunction(unknown) && unknown.constructor.name === 'AsyncFunction';\n}\n\n/**\n * 检查值是否为 Error 类型\n * @param unknown - 未知类型的值\n * @returns 如果值为 Error 类型则返回 true，否则返回 false\n */\nexport function isError(unknown: unknown): unknown is Error {\n  return unknown instanceof Error;\n}\n\n/**\n * 检查值是否为 Promise 类型\n * @param unknown - 未知类型的值\n * @returns 如果值为 Promise 类型则返回 true，否则返回 false\n */\nexport function isPromise<T>(unknown: unknown): unknown is Promise<T> {\n  return typeIs(unknown) === 'promise';\n}\n\n/**\n * 检查值是否为 Date 类型\n * @param unknown - 未知类型的值\n * @returns 如果值为 Date 类型则返回 true，否则返回 false\n */\nexport function isDate(unknown: unknown): unknown is Date {\n  return unknown instanceof Date;\n}\n"],"names":[],"mappings":";;AAOO,SAAS,OACd,SAcS;AACF,SAAA,OAAO,UAAU,SAAS,KAAK,OAAO,EAAE,MAAM,GAAG,EAAE,EAAE,YAAY;AAC1E;AAOO,SAAS,SAAS,SAAqC;AAC5D,SAAO,OAAO,YAAY;AAC5B;AAOO,SAAS,UAAU,SAAsC;AAC9D,SAAO,OAAO,YAAY;AAC5B;AAOO,SAAS,SAAS,SAAqC;AAC5D,SAAO,OAAO,YAAY;AAC5B;AAOO,SAAS,SAAS,SAAqC;AAC5D,SAAO,OAAO,YAAY;AAC5B;AAOO,SAAS,SAAS,SAAqC;AAC5D,SAAO,OAAO,YAAY,YAAY,CAAC,OAAO,MAAM,OAAO;AAC7D;AAOO,SAAS,YAAY,SAAwC;AAClE,SAAO,OAAO,YAAY;AAC5B;AAQO,SAAS,OAAO,SAAmC;AACxD,SAAO,YAAY,OAAO;AAC5B;AAMO,SAAS,QAAQ,SAAgB;AAExC;AAOO,SAAS,OAAO,SAAmC;AACxD,SAAO,YAAY;AACrB;AAQO,SAAS,UAAU,SAAsD;AAC9E,SAAO,OAAO,OAAO,KAAK,YAAY,OAAO,KAAK,OAAO,OAAO;AAClE;AAOO,SAAS,YACd,SAC2E;AACpE,SAAA,OAAO,OAAO,KAAK,EAAE,OAAO,YAAY,YAAY,OAAO,YAAY;AAChF;AAOO,SAAS,SAAS,SAAwC;AACxD,SAAA,OAAO,OAAO,MAAM;AAC7B;AAOO,SAAS,QAAQ,SAAuC;AACtD,SAAA,MAAM,QAAQ,OAAO;AAC9B;AAOO,SAAS,WAAW,SAA0C;AACnE,SAAO,OAAO,YAAY;AAC5B;AAcO,SAAS,gBAAgB,SAA+C;AAC7E,SAAO,WAAW,OAAO,KAAK,QAAQ,YAAY,SAAS;AAC7D;AAOO,SAAS,QAAQ,SAAoC;AAC1D,SAAO,mBAAmB;AAC5B;AAOO,SAAS,UAAa,SAAyC;AAC7D,SAAA,OAAO,OAAO,MAAM;AAC7B;AAOO,SAAS,OAAO,SAAmC;AACxD,SAAO,mBAAmB;AAC5B;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"type.cjs","names":[],"sources":["../src/type.ts"],"sourcesContent":["import type { AnyArray, AnyAsyncFunction, AnyFunction, AnyObject } from './types';\n\n/**\n * 获取未知类型的类型名称\n * @param unknown - 未知类型的值\n * @returns 类型名称字符串\n */\nexport function typeIs(\n  unknown: unknown,\n):\n  | 'string'\n  | 'number'\n  | 'boolean'\n  | 'object'\n  | 'array'\n  | 'function'\n  | 'null'\n  | 'undefined'\n  | 'symbol'\n  | 'bigint'\n  | 'error'\n  | 'promise'\n  | string {\n  return Object.prototype.toString.call(unknown).slice(8, -1).toLowerCase();\n}\n\n/**\n * 检查值是否为字符串\n * @param unknown - 未知类型的值\n * @returns 如果值为字符串则返回 true，否则返回 false\n */\nexport function isString(unknown: unknown): unknown is string {\n  return typeof unknown === 'string';\n}\n\n/**\n * 检查值是否为布尔值\n * @param unknown - 未知类型的值\n * @returns 如果值为布尔值则返回 true，否则返回 false\n */\nexport function isBoolean(unknown: unknown): unknown is boolean {\n  return typeof unknown === 'boolean';\n}\n\n/**\n * 检查值是否为符号\n * @param unknown - 未知类型的值\n * @returns 如果值为符号则返回 true，否则返回 false\n */\nexport function isSymbol(unknown: unknown): unknown is symbol {\n  return typeof unknown === 'symbol';\n}\n\n/**\n * 检查值是否为大整数\n * @param unknown - 未知类型的值\n * @returns 如果值为大整数则返回 true，否则返回 false\n */\nexport function isBigInt(unknown: unknown): unknown is bigint {\n  return typeof unknown === 'bigint';\n}\n\n/**\n * 检查值是否为数字\n * @param unknown - 未知类型的值\n * @returns 如果值为数字且不是 NaN 则返回 true，否则返回 false\n */\nexport function isNumber(unknown: unknown): unknown is number {\n  return typeof unknown === 'number' && !Number.isNaN(unknown);\n}\n\n/**\n * 检查值是否为 undefined\n * @param unknown - 未知类型的值\n * @returns 如果值为 undefined 则返回 true，否则返回 false\n */\nexport function isUndefined(unknown: unknown): unknown is undefined {\n  return typeof unknown === 'undefined';\n}\n\n/**\n * 检查值是否为 void\n * @param unknown - 未知类型的值\n * @returns 如果值为 undefined 则返回 true，否则返回 false\n */\n// biome-ignore lint/suspicious/noConfusingVoidType: 必须使用 void 类型断言\nexport function isVoid(unknown: unknown): unknown is void {\n  return isUndefined(unknown);\n}\n\n/**\n * 永不执行，用于 switch-case/if-else 类型断言\n * @param unknown - 永远不会执行的值\n */\nexport function isNever(_unknown: never) {\n  //\n}\n\n/**\n * 检查值是否为 null\n * @param unknown - 未知类型的值\n * @returns 如果值为 null 则返回 true，否则返回 false\n */\nexport function isNull(unknown: unknown): unknown is null {\n  return unknown === null;\n}\n\n/**\n * 检查值是否为 nullish（null 或 undefined 或 void）\n * @param unknown - 未知类型的值\n * @returns 如果值为 null 或 undefined 或 void 则返回 true，否则返回 false\n */\nexport function isNullish(unknown: unknown): unknown is null | undefined | undefined {\n  return isNull(unknown) || isUndefined(unknown) || isVoid(unknown);\n}\n\n/**\n * 检查值是否为原始类型（null 或 非对象）\n * @param unknown - 未知类型的值\n * @returns 如果值为原始类型则返回 true，否则返回 false\n */\nexport function isPrimitive(\n  unknown: unknown,\n): unknown is string | number | boolean | symbol | bigint | null | undefined {\n  return isNull(unknown) || !(typeof unknown === 'object' || typeof unknown === 'function');\n}\n\n/**\n * 检查值是否为对象，但要注意，此时的对象类型是包含了数组和函数\n * @param unknown - 未知类型的值\n * @returns 如果值为对象则返回 true，否则返回 false\n */\nexport function isObject(unknown: unknown): unknown is AnyObject {\n  return typeIs(unknown) === 'object';\n}\n\n/**\n * 检查值是否为数组\n * @param unknown - 未知类型的值\n * @returns 如果值为数组则返回 true，否则返回 false\n */\nexport function isArray(unknown: unknown): unknown is AnyArray {\n  return Array.isArray(unknown);\n}\n\n/**\n * 检查值是否为函数\n * @param unknown - 未知类型的值\n * @returns 如果值为函数则返回 true，否则返回 false\n */\nexport function isFunction(unknown: unknown): unknown is AnyFunction {\n  return typeof unknown === 'function';\n}\n\n/**\n * 检查值是否为异步函数\n * @param unknown - 需要检查的值\n * @returns 如果值为异步函数则返回 true，否则返回 false\n * @example\n * ```typescript\n * async function example() {}\n *\n * isAsyncFunction(example); // true\n * isAsyncFunction(() => {}); // false\n * ```\n */\nexport function isAsyncFunction(unknown: unknown): unknown is AnyAsyncFunction {\n  return isFunction(unknown) && unknown.constructor.name === 'AsyncFunction';\n}\n\n/**\n * 检查值是否为 Error 类型\n * @param unknown - 未知类型的值\n * @returns 如果值为 Error 类型则返回 true，否则返回 false\n */\nexport function isError(unknown: unknown): unknown is Error {\n  return unknown instanceof Error;\n}\n\n/**\n * 检查值是否为 Promise 类型\n * @param unknown - 未知类型的值\n * @returns 如果值为 Promise 类型则返回 true，否则返回 false\n */\nexport function isPromise<T>(unknown: unknown): unknown is Promise<T> {\n  return typeIs(unknown) === 'promise';\n}\n\n/**\n * 检查值是否为 Date 类型\n * @param unknown - 未知类型的值\n * @returns 如果值为 Date 类型则返回 true，否则返回 false\n */\nexport function isDate(unknown: unknown): unknown is Date {\n  return unknown instanceof Date;\n}\n"],"mappings":";;;;;;;AAOA,SAAgB,OACd,SAcS;CACT,OAAO,OAAO,UAAU,SAAS,KAAK,QAAQ,CAAC,MAAM,GAAG,GAAG,CAAC,aAAa;;;;;;;AAQ3E,SAAgB,SAAS,SAAqC;CAC5D,OAAO,OAAO,YAAY;;;;;;;AAQ5B,SAAgB,UAAU,SAAsC;CAC9D,OAAO,OAAO,YAAY;;;;;;;AAQ5B,SAAgB,SAAS,SAAqC;CAC5D,OAAO,OAAO,YAAY;;;;;;;AAQ5B,SAAgB,SAAS,SAAqC;CAC5D,OAAO,OAAO,YAAY;;;;;;;AAQ5B,SAAgB,SAAS,SAAqC;CAC5D,OAAO,OAAO,YAAY,YAAY,CAAC,OAAO,MAAM,QAAQ;;;;;;;AAQ9D,SAAgB,YAAY,SAAwC;CAClE,OAAO,OAAO,YAAY;;;;;;;AAS5B,SAAgB,OAAO,SAAmC;CACxD,OAAO,YAAY,QAAQ;;;;;;AAO7B,SAAgB,QAAQ,UAAiB;;;;;;AASzC,SAAgB,OAAO,SAAmC;CACxD,OAAO,YAAY;;;;;;;AAQrB,SAAgB,UAAU,SAA2D;CACnF,OAAO,OAAO,QAAQ,IAAI,YAAY,QAAQ,IAAI,OAAO,QAAQ;;;;;;;AAQnE,SAAgB,YACd,SAC2E;CAC3E,OAAO,OAAO,QAAQ,IAAI,EAAE,OAAO,YAAY,YAAY,OAAO,YAAY;;;;;;;AAQhF,SAAgB,SAAS,SAAwC;CAC/D,OAAO,OAAO,QAAQ,KAAK;;;;;;;AAQ7B,SAAgB,QAAQ,SAAuC;CAC7D,OAAO,MAAM,QAAQ,QAAQ;;;;;;;AAQ/B,SAAgB,WAAW,SAA0C;CACnE,OAAO,OAAO,YAAY;;;;;;;;;;;;;;AAe5B,SAAgB,gBAAgB,SAA+C;CAC7E,OAAO,WAAW,QAAQ,IAAI,QAAQ,YAAY,SAAS;;;;;;;AAQ7D,SAAgB,QAAQ,SAAoC;CAC1D,OAAO,mBAAmB;;;;;;;AAQ5B,SAAgB,UAAa,SAAyC;CACpE,OAAO,OAAO,QAAQ,KAAK;;;;;;;AAQ7B,SAAgB,OAAO,SAAmC;CACxD,OAAO,mBAAmB"}

package/dist/type.d.ts

@@ -51,7 +51,7 @@ export declare function isVoid(unknown: unknown): unknown is void;
  * 永不执行，用于 switch-case/if-else 类型断言
  * @param unknown - 永远不会执行的值
  */
-export declare function isNever(unknown: never): void;
+export declare function isNever(_unknown: never): void;
 /**
  * 检查值是否为 null
  * @param unknown - 未知类型的值
@@ -63,7 +63,7 @@ export declare function isNull(unknown: unknown): unknown is null;
  * @param unknown - 未知类型的值
  * @returns 如果值为 null 或 undefined 或 void 则返回 true，否则返回 false
  */
-export declare function isNullish(unknown: unknown): unknown is null | undefined | void;
+export declare function isNullish(unknown: unknown): unknown is null | undefined | undefined;
 /**
  * 检查值是否为原始类型（null 或 非对象）
  * @param unknown - 未知类型的值

package/dist/type.mjs

@@ -1,78 +1,161 @@
+//#region src/type.ts
+/**
+* 获取未知类型的类型名称
+* @param unknown - 未知类型的值
+* @returns 类型名称字符串
+*/
 function typeIs(unknown) {
-  return Object.prototype.toString.call(unknown).slice(8, -1).toLowerCase();
+	return Object.prototype.toString.call(unknown).slice(8, -1).toLowerCase();
 }
+/**
+* 检查值是否为字符串
+* @param unknown - 未知类型的值
+* @returns 如果值为字符串则返回 true，否则返回 false
+*/
 function isString(unknown) {
-  return typeof unknown === "string";
+	return typeof unknown === "string";
 }
+/**
+* 检查值是否为布尔值
+* @param unknown - 未知类型的值
+* @returns 如果值为布尔值则返回 true，否则返回 false
+*/
 function isBoolean(unknown) {
-  return typeof unknown === "boolean";
+	return typeof unknown === "boolean";
 }
+/**
+* 检查值是否为符号
+* @param unknown - 未知类型的值
+* @returns 如果值为符号则返回 true，否则返回 false
+*/
 function isSymbol(unknown) {
-  return typeof unknown === "symbol";
+	return typeof unknown === "symbol";
 }
+/**
+* 检查值是否为大整数
+* @param unknown - 未知类型的值
+* @returns 如果值为大整数则返回 true，否则返回 false
+*/
 function isBigInt(unknown) {
-  return typeof unknown === "bigint";
+	return typeof unknown === "bigint";
 }
+/**
+* 检查值是否为数字
+* @param unknown - 未知类型的值
+* @returns 如果值为数字且不是 NaN 则返回 true，否则返回 false
+*/
 function isNumber(unknown) {
-  return typeof unknown === "number" && !Number.isNaN(unknown);
+	return typeof unknown === "number" && !Number.isNaN(unknown);
 }
+/**
+* 检查值是否为 undefined
+* @param unknown - 未知类型的值
+* @returns 如果值为 undefined 则返回 true，否则返回 false
+*/
 function isUndefined(unknown) {
-  return typeof unknown === "undefined";
+	return typeof unknown === "undefined";
 }
+/**
+* 检查值是否为 void
+* @param unknown - 未知类型的值
+* @returns 如果值为 undefined 则返回 true，否则返回 false
+*/
 function isVoid(unknown) {
-  return isUndefined(unknown);
-}
-function isNever(unknown) {
-}
+	return isUndefined(unknown);
+}
+/**
+* 永不执行，用于 switch-case/if-else 类型断言
+* @param unknown - 永远不会执行的值
+*/
+function isNever(_unknown) {}
+/**
+* 检查值是否为 null
+* @param unknown - 未知类型的值
+* @returns 如果值为 null 则返回 true，否则返回 false
+*/
 function isNull(unknown) {
-  return unknown === null;
+	return unknown === null;
 }
+/**
+* 检查值是否为 nullish（null 或 undefined 或 void）
+* @param unknown - 未知类型的值
+* @returns 如果值为 null 或 undefined 或 void 则返回 true，否则返回 false
+*/
 function isNullish(unknown) {
-  return isNull(unknown) || isUndefined(unknown) || isVoid(unknown);
+	return isNull(unknown) || isUndefined(unknown) || isVoid(unknown);
 }
+/**
+* 检查值是否为原始类型（null 或 非对象）
+* @param unknown - 未知类型的值
+* @returns 如果值为原始类型则返回 true，否则返回 false
+*/
 function isPrimitive(unknown) {
-  return isNull(unknown) || !(typeof unknown === "object" || typeof unknown === "function");
+	return isNull(unknown) || !(typeof unknown === "object" || typeof unknown === "function");
 }
+/**
+* 检查值是否为对象，但要注意，此时的对象类型是包含了数组和函数
+* @param unknown - 未知类型的值
+* @returns 如果值为对象则返回 true，否则返回 false
+*/
 function isObject(unknown) {
-  return typeIs(unknown) === "object";
+	return typeIs(unknown) === "object";
 }
+/**
+* 检查值是否为数组
+* @param unknown - 未知类型的值
+* @returns 如果值为数组则返回 true，否则返回 false
+*/
 function isArray(unknown) {
-  return Array.isArray(unknown);
+	return Array.isArray(unknown);
 }
+/**
+* 检查值是否为函数
+* @param unknown - 未知类型的值
+* @returns 如果值为函数则返回 true，否则返回 false
+*/
 function isFunction(unknown) {
-  return typeof unknown === "function";
-}
+	return typeof unknown === "function";
+}
+/**
+* 检查值是否为异步函数
+* @param unknown - 需要检查的值
+* @returns 如果值为异步函数则返回 true，否则返回 false
+* @example
+* ```typescript
+* async function example() {}
+*
+* isAsyncFunction(example); // true
+* isAsyncFunction(() => {}); // false
+* ```
+*/
 function isAsyncFunction(unknown) {
-  return isFunction(unknown) && unknown.constructor.name === "AsyncFunction";
+	return isFunction(unknown) && unknown.constructor.name === "AsyncFunction";
 }
+/**
+* 检查值是否为 Error 类型
+* @param unknown - 未知类型的值
+* @returns 如果值为 Error 类型则返回 true，否则返回 false
+*/
 function isError(unknown) {
-  return unknown instanceof Error;
+	return unknown instanceof Error;
 }
+/**
+* 检查值是否为 Promise 类型
+* @param unknown - 未知类型的值
+* @returns 如果值为 Promise 类型则返回 true，否则返回 false
+*/
 function isPromise(unknown) {
-  return typeIs(unknown) === "promise";
+	return typeIs(unknown) === "promise";
 }
+/**
+* 检查值是否为 Date 类型
+* @param unknown - 未知类型的值
+* @returns 如果值为 Date 类型则返回 true，否则返回 false
+*/
 function isDate(unknown) {
-  return unknown instanceof Date;
-}
-export {
-  isArray,
-  isAsyncFunction,
-  isBigInt,
-  isBoolean,
-  isDate,
-  isError,
-  isFunction,
-  isNever,
-  isNull,
-  isNullish,
-  isNumber,
-  isObject,
-  isPrimitive,
-  isPromise,
-  isString,
-  isSymbol,
-  isUndefined,
-  isVoid,
-  typeIs
-};
-//# sourceMappingURL=type.mjs.map
+	return unknown instanceof Date;
+}
+//#endregion
+export { isArray, isAsyncFunction, isBigInt, isBoolean, isDate, isError, isFunction, isNever, isNull, isNullish, isNumber, isObject, isPrimitive, isPromise, isString, isSymbol, isUndefined, isVoid, typeIs };
+
+//# sourceMappingURL=type.mjs.map

package/dist/type.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"type.mjs","sources":["../src/type.ts"],"sourcesContent":["import type { AnyArray, AnyAsyncFunction, AnyFunction, AnyObject } from './types';\n\n/**\n * 获取未知类型的类型名称\n * @param unknown - 未知类型的值\n * @returns 类型名称字符串\n */\nexport function typeIs(\n  unknown: unknown,\n):\n  | 'string'\n  | 'number'\n  | 'boolean'\n  | 'object'\n  | 'array'\n  | 'function'\n  | 'null'\n  | 'undefined'\n  | 'symbol'\n  | 'bigint'\n  | 'error'\n  | 'promise'\n  | string {\n  return Object.prototype.toString.call(unknown).slice(8, -1).toLowerCase();\n}\n\n/**\n * 检查值是否为字符串\n * @param unknown - 未知类型的值\n * @returns 如果值为字符串则返回 true，否则返回 false\n */\nexport function isString(unknown: unknown): unknown is string {\n  return typeof unknown === 'string';\n}\n\n/**\n * 检查值是否为布尔值\n * @param unknown - 未知类型的值\n * @returns 如果值为布尔值则返回 true，否则返回 false\n */\nexport function isBoolean(unknown: unknown): unknown is boolean {\n  return typeof unknown === 'boolean';\n}\n\n/**\n * 检查值是否为符号\n * @param unknown - 未知类型的值\n * @returns 如果值为符号则返回 true，否则返回 false\n */\nexport function isSymbol(unknown: unknown): unknown is symbol {\n  return typeof unknown === 'symbol';\n}\n\n/**\n * 检查值是否为大整数\n * @param unknown - 未知类型的值\n * @returns 如果值为大整数则返回 true，否则返回 false\n */\nexport function isBigInt(unknown: unknown): unknown is bigint {\n  return typeof unknown === 'bigint';\n}\n\n/**\n * 检查值是否为数字\n * @param unknown - 未知类型的值\n * @returns 如果值为数字且不是 NaN 则返回 true，否则返回 false\n */\nexport function isNumber(unknown: unknown): unknown is number {\n  return typeof unknown === 'number' && !Number.isNaN(unknown);\n}\n\n/**\n * 检查值是否为 undefined\n * @param unknown - 未知类型的值\n * @returns 如果值为 undefined 则返回 true，否则返回 false\n */\nexport function isUndefined(unknown: unknown): unknown is undefined {\n  return typeof unknown === 'undefined';\n}\n\n/**\n * 检查值是否为 void\n * @param unknown - 未知类型的值\n * @returns 如果值为 undefined 则返回 true，否则返回 false\n */\n// biome-ignore lint/suspicious/noConfusingVoidType: <explanation>\nexport function isVoid(unknown: unknown): unknown is void {\n  return isUndefined(unknown);\n}\n\n/**\n * 永不执行，用于 switch-case/if-else 类型断言\n * @param unknown - 永远不会执行的值\n */\nexport function isNever(unknown: never) {\n  //\n}\n\n/**\n * 检查值是否为 null\n * @param unknown - 未知类型的值\n * @returns 如果值为 null 则返回 true，否则返回 false\n */\nexport function isNull(unknown: unknown): unknown is null {\n  return unknown === null;\n}\n\n/**\n * 检查值是否为 nullish（null 或 undefined 或 void）\n * @param unknown - 未知类型的值\n * @returns 如果值为 null 或 undefined 或 void 则返回 true，否则返回 false\n */\n// biome-ignore lint/suspicious/noConfusingVoidType: <explanation>\nexport function isNullish(unknown: unknown): unknown is null | undefined | void {\n  return isNull(unknown) || isUndefined(unknown) || isVoid(unknown);\n}\n\n/**\n * 检查值是否为原始类型（null 或 非对象）\n * @param unknown - 未知类型的值\n * @returns 如果值为原始类型则返回 true，否则返回 false\n */\nexport function isPrimitive(\n  unknown: unknown,\n): unknown is string | number | boolean | symbol | bigint | null | undefined {\n  return isNull(unknown) || !(typeof unknown === 'object' || typeof unknown === 'function');\n}\n\n/**\n * 检查值是否为对象，但要注意，此时的对象类型是包含了数组和函数\n * @param unknown - 未知类型的值\n * @returns 如果值为对象则返回 true，否则返回 false\n */\nexport function isObject(unknown: unknown): unknown is AnyObject {\n  return typeIs(unknown) === 'object';\n}\n\n/**\n * 检查值是否为数组\n * @param unknown - 未知类型的值\n * @returns 如果值为数组则返回 true，否则返回 false\n */\nexport function isArray(unknown: unknown): unknown is AnyArray {\n  return Array.isArray(unknown);\n}\n\n/**\n * 检查值是否为函数\n * @param unknown - 未知类型的值\n * @returns 如果值为函数则返回 true，否则返回 false\n */\nexport function isFunction(unknown: unknown): unknown is AnyFunction {\n  return typeof unknown === 'function';\n}\n\n/**\n * 检查值是否为异步函数\n * @param unknown - 需要检查的值\n * @returns 如果值为异步函数则返回 true，否则返回 false\n * @example\n * ```typescript\n * async function example() {}\n *\n * isAsyncFunction(example); // true\n * isAsyncFunction(() => {}); // false\n * ```\n */\nexport function isAsyncFunction(unknown: unknown): unknown is AnyAsyncFunction {\n  return isFunction(unknown) && unknown.constructor.name === 'AsyncFunction';\n}\n\n/**\n * 检查值是否为 Error 类型\n * @param unknown - 未知类型的值\n * @returns 如果值为 Error 类型则返回 true，否则返回 false\n */\nexport function isError(unknown: unknown): unknown is Error {\n  return unknown instanceof Error;\n}\n\n/**\n * 检查值是否为 Promise 类型\n * @param unknown - 未知类型的值\n * @returns 如果值为 Promise 类型则返回 true，否则返回 false\n */\nexport function isPromise<T>(unknown: unknown): unknown is Promise<T> {\n  return typeIs(unknown) === 'promise';\n}\n\n/**\n * 检查值是否为 Date 类型\n * @param unknown - 未知类型的值\n * @returns 如果值为 Date 类型则返回 true，否则返回 false\n */\nexport function isDate(unknown: unknown): unknown is Date {\n  return unknown instanceof Date;\n}\n"],"names":[],"mappings":"AAOO,SAAS,OACd,SAcS;AACF,SAAA,OAAO,UAAU,SAAS,KAAK,OAAO,EAAE,MAAM,GAAG,EAAE,EAAE,YAAY;AAC1E;AAOO,SAAS,SAAS,SAAqC;AAC5D,SAAO,OAAO,YAAY;AAC5B;AAOO,SAAS,UAAU,SAAsC;AAC9D,SAAO,OAAO,YAAY;AAC5B;AAOO,SAAS,SAAS,SAAqC;AAC5D,SAAO,OAAO,YAAY;AAC5B;AAOO,SAAS,SAAS,SAAqC;AAC5D,SAAO,OAAO,YAAY;AAC5B;AAOO,SAAS,SAAS,SAAqC;AAC5D,SAAO,OAAO,YAAY,YAAY,CAAC,OAAO,MAAM,OAAO;AAC7D;AAOO,SAAS,YAAY,SAAwC;AAClE,SAAO,OAAO,YAAY;AAC5B;AAQO,SAAS,OAAO,SAAmC;AACxD,SAAO,YAAY,OAAO;AAC5B;AAMO,SAAS,QAAQ,SAAgB;AAExC;AAOO,SAAS,OAAO,SAAmC;AACxD,SAAO,YAAY;AACrB;AAQO,SAAS,UAAU,SAAsD;AAC9E,SAAO,OAAO,OAAO,KAAK,YAAY,OAAO,KAAK,OAAO,OAAO;AAClE;AAOO,SAAS,YACd,SAC2E;AACpE,SAAA,OAAO,OAAO,KAAK,EAAE,OAAO,YAAY,YAAY,OAAO,YAAY;AAChF;AAOO,SAAS,SAAS,SAAwC;AACxD,SAAA,OAAO,OAAO,MAAM;AAC7B;AAOO,SAAS,QAAQ,SAAuC;AACtD,SAAA,MAAM,QAAQ,OAAO;AAC9B;AAOO,SAAS,WAAW,SAA0C;AACnE,SAAO,OAAO,YAAY;AAC5B;AAcO,SAAS,gBAAgB,SAA+C;AAC7E,SAAO,WAAW,OAAO,KAAK,QAAQ,YAAY,SAAS;AAC7D;AAOO,SAAS,QAAQ,SAAoC;AAC1D,SAAO,mBAAmB;AAC5B;AAOO,SAAS,UAAa,SAAyC;AAC7D,SAAA,OAAO,OAAO,MAAM;AAC7B;AAOO,SAAS,OAAO,SAAmC;AACxD,SAAO,mBAAmB;AAC5B;"}
+{"version":3,"file":"type.mjs","names":[],"sources":["../src/type.ts"],"sourcesContent":["import type { AnyArray, AnyAsyncFunction, AnyFunction, AnyObject } from './types';\n\n/**\n * 获取未知类型的类型名称\n * @param unknown - 未知类型的值\n * @returns 类型名称字符串\n */\nexport function typeIs(\n  unknown: unknown,\n):\n  | 'string'\n  | 'number'\n  | 'boolean'\n  | 'object'\n  | 'array'\n  | 'function'\n  | 'null'\n  | 'undefined'\n  | 'symbol'\n  | 'bigint'\n  | 'error'\n  | 'promise'\n  | string {\n  return Object.prototype.toString.call(unknown).slice(8, -1).toLowerCase();\n}\n\n/**\n * 检查值是否为字符串\n * @param unknown - 未知类型的值\n * @returns 如果值为字符串则返回 true，否则返回 false\n */\nexport function isString(unknown: unknown): unknown is string {\n  return typeof unknown === 'string';\n}\n\n/**\n * 检查值是否为布尔值\n * @param unknown - 未知类型的值\n * @returns 如果值为布尔值则返回 true，否则返回 false\n */\nexport function isBoolean(unknown: unknown): unknown is boolean {\n  return typeof unknown === 'boolean';\n}\n\n/**\n * 检查值是否为符号\n * @param unknown - 未知类型的值\n * @returns 如果值为符号则返回 true，否则返回 false\n */\nexport function isSymbol(unknown: unknown): unknown is symbol {\n  return typeof unknown === 'symbol';\n}\n\n/**\n * 检查值是否为大整数\n * @param unknown - 未知类型的值\n * @returns 如果值为大整数则返回 true，否则返回 false\n */\nexport function isBigInt(unknown: unknown): unknown is bigint {\n  return typeof unknown === 'bigint';\n}\n\n/**\n * 检查值是否为数字\n * @param unknown - 未知类型的值\n * @returns 如果值为数字且不是 NaN 则返回 true，否则返回 false\n */\nexport function isNumber(unknown: unknown): unknown is number {\n  return typeof unknown === 'number' && !Number.isNaN(unknown);\n}\n\n/**\n * 检查值是否为 undefined\n * @param unknown - 未知类型的值\n * @returns 如果值为 undefined 则返回 true，否则返回 false\n */\nexport function isUndefined(unknown: unknown): unknown is undefined {\n  return typeof unknown === 'undefined';\n}\n\n/**\n * 检查值是否为 void\n * @param unknown - 未知类型的值\n * @returns 如果值为 undefined 则返回 true，否则返回 false\n */\n// biome-ignore lint/suspicious/noConfusingVoidType: 必须使用 void 类型断言\nexport function isVoid(unknown: unknown): unknown is void {\n  return isUndefined(unknown);\n}\n\n/**\n * 永不执行，用于 switch-case/if-else 类型断言\n * @param unknown - 永远不会执行的值\n */\nexport function isNever(_unknown: never) {\n  //\n}\n\n/**\n * 检查值是否为 null\n * @param unknown - 未知类型的值\n * @returns 如果值为 null 则返回 true，否则返回 false\n */\nexport function isNull(unknown: unknown): unknown is null {\n  return unknown === null;\n}\n\n/**\n * 检查值是否为 nullish（null 或 undefined 或 void）\n * @param unknown - 未知类型的值\n * @returns 如果值为 null 或 undefined 或 void 则返回 true，否则返回 false\n */\nexport function isNullish(unknown: unknown): unknown is null | undefined | undefined {\n  return isNull(unknown) || isUndefined(unknown) || isVoid(unknown);\n}\n\n/**\n * 检查值是否为原始类型（null 或 非对象）\n * @param unknown - 未知类型的值\n * @returns 如果值为原始类型则返回 true，否则返回 false\n */\nexport function isPrimitive(\n  unknown: unknown,\n): unknown is string | number | boolean | symbol | bigint | null | undefined {\n  return isNull(unknown) || !(typeof unknown === 'object' || typeof unknown === 'function');\n}\n\n/**\n * 检查值是否为对象，但要注意，此时的对象类型是包含了数组和函数\n * @param unknown - 未知类型的值\n * @returns 如果值为对象则返回 true，否则返回 false\n */\nexport function isObject(unknown: unknown): unknown is AnyObject {\n  return typeIs(unknown) === 'object';\n}\n\n/**\n * 检查值是否为数组\n * @param unknown - 未知类型的值\n * @returns 如果值为数组则返回 true，否则返回 false\n */\nexport function isArray(unknown: unknown): unknown is AnyArray {\n  return Array.isArray(unknown);\n}\n\n/**\n * 检查值是否为函数\n * @param unknown - 未知类型的值\n * @returns 如果值为函数则返回 true，否则返回 false\n */\nexport function isFunction(unknown: unknown): unknown is AnyFunction {\n  return typeof unknown === 'function';\n}\n\n/**\n * 检查值是否为异步函数\n * @param unknown - 需要检查的值\n * @returns 如果值为异步函数则返回 true，否则返回 false\n * @example\n * ```typescript\n * async function example() {}\n *\n * isAsyncFunction(example); // true\n * isAsyncFunction(() => {}); // false\n * ```\n */\nexport function isAsyncFunction(unknown: unknown): unknown is AnyAsyncFunction {\n  return isFunction(unknown) && unknown.constructor.name === 'AsyncFunction';\n}\n\n/**\n * 检查值是否为 Error 类型\n * @param unknown - 未知类型的值\n * @returns 如果值为 Error 类型则返回 true，否则返回 false\n */\nexport function isError(unknown: unknown): unknown is Error {\n  return unknown instanceof Error;\n}\n\n/**\n * 检查值是否为 Promise 类型\n * @param unknown - 未知类型的值\n * @returns 如果值为 Promise 类型则返回 true，否则返回 false\n */\nexport function isPromise<T>(unknown: unknown): unknown is Promise<T> {\n  return typeIs(unknown) === 'promise';\n}\n\n/**\n * 检查值是否为 Date 类型\n * @param unknown - 未知类型的值\n * @returns 如果值为 Date 类型则返回 true，否则返回 false\n */\nexport function isDate(unknown: unknown): unknown is Date {\n  return unknown instanceof Date;\n}\n"],"mappings":";;;;;;AAOA,SAAgB,OACd,SAcS;CACT,OAAO,OAAO,UAAU,SAAS,KAAK,QAAQ,CAAC,MAAM,GAAG,GAAG,CAAC,aAAa;;;;;;;AAQ3E,SAAgB,SAAS,SAAqC;CAC5D,OAAO,OAAO,YAAY;;;;;;;AAQ5B,SAAgB,UAAU,SAAsC;CAC9D,OAAO,OAAO,YAAY;;;;;;;AAQ5B,SAAgB,SAAS,SAAqC;CAC5D,OAAO,OAAO,YAAY;;;;;;;AAQ5B,SAAgB,SAAS,SAAqC;CAC5D,OAAO,OAAO,YAAY;;;;;;;AAQ5B,SAAgB,SAAS,SAAqC;CAC5D,OAAO,OAAO,YAAY,YAAY,CAAC,OAAO,MAAM,QAAQ;;;;;;;AAQ9D,SAAgB,YAAY,SAAwC;CAClE,OAAO,OAAO,YAAY;;;;;;;AAS5B,SAAgB,OAAO,SAAmC;CACxD,OAAO,YAAY,QAAQ;;;;;;AAO7B,SAAgB,QAAQ,UAAiB;;;;;;AASzC,SAAgB,OAAO,SAAmC;CACxD,OAAO,YAAY;;;;;;;AAQrB,SAAgB,UAAU,SAA2D;CACnF,OAAO,OAAO,QAAQ,IAAI,YAAY,QAAQ,IAAI,OAAO,QAAQ;;;;;;;AAQnE,SAAgB,YACd,SAC2E;CAC3E,OAAO,OAAO,QAAQ,IAAI,EAAE,OAAO,YAAY,YAAY,OAAO,YAAY;;;;;;;AAQhF,SAAgB,SAAS,SAAwC;CAC/D,OAAO,OAAO,QAAQ,KAAK;;;;;;;AAQ7B,SAAgB,QAAQ,SAAuC;CAC7D,OAAO,MAAM,QAAQ,QAAQ;;;;;;;AAQ/B,SAAgB,WAAW,SAA0C;CACnE,OAAO,OAAO,YAAY;;;;;;;;;;;;;;AAe5B,SAAgB,gBAAgB,SAA+C;CAC7E,OAAO,WAAW,QAAQ,IAAI,QAAQ,YAAY,SAAS;;;;;;;AAQ7D,SAAgB,QAAQ,SAAoC;CAC1D,OAAO,mBAAmB;;;;;;;AAQ5B,SAAgB,UAAa,SAAyC;CACpE,OAAO,OAAO,QAAQ,KAAK;;;;;;;AAQ7B,SAAgB,OAAO,SAAmC;CACxD,OAAO,mBAAmB"}

package/dist/types.cjs

@@ -1,2 +0,0 @@
-"use strict";
-//# sourceMappingURL=types.cjs.map

package/dist/types.d.ts

@@ -26,7 +26,7 @@ export type AnyArray = Array<unknown>;
  * // string | number | boolean | bigint | symbol | null | undefined | void | never
  * ```
  */
-export type PrimitiveValue = string | number | boolean | bigint | symbol | null | undefined | void | never;
+export type PrimitiveValue = string | number | boolean | bigint | symbol | null | undefined | undefined | never;
 /**
  * 引用类型值
  * @description 表示所有非原始类型的值，即除了 PrimitiveValue 之外的所有类型

package/dist/types.mjs

@@ -1,2 +0,0 @@
-
-//# sourceMappingURL=types.mjs.map

package/dist/unique.cjs

@@ -1,46 +1,49 @@
-"use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const number = require("./string2.cjs");
-const type = require("./type.cjs");
-let lastTimestamp = 0;
-let lastSafePadding = 0;
+const require_type = require("./type.cjs");
+const require_string = require("./string2.cjs");
+//#region src/unique.ts
+var lastTimestamp = 0;
+var lastSafePadding = 0;
+/**
+* 生成一个唯一的 BigInt 值。
+*
+* @param randomLength - 可选参数，指定随机部分的长度，默认为 0。
+*                        如果大于 0，则会在结果中附加指定长度的随机数。
+* @returns 返回一个唯一的 BigInt 值，包含时间戳、随机部分（如果有）以及递增的填充值。
+*/
 function uniqueBigInt(randomLength = 0) {
-  const now = Date.now();
-  if (now !== lastTimestamp) {
-    lastTimestamp = now;
-    lastSafePadding = 0;
-  }
-  let randomPart = "";
-  if (randomLength > 0) {
-    const randomMin = 10 ** (randomLength - 1);
-    const randomMax = 10 ** randomLength - 1;
-    randomPart = String(number.randomNumber(randomMin, randomMax));
-  }
-  return BigInt(randomPart + lastSafePadding++ + now);
+	const now = Date.now();
+	if (now !== lastTimestamp) {
+		lastTimestamp = now;
+		lastSafePadding = 0;
+	}
+	let randomPart = "";
+	if (randomLength > 0) {
+		const randomMin = 10 ** (randomLength - 1);
+		const randomMax = 10 ** randomLength - 1;
+		randomPart = String(require_string.randomNumber(randomMin, randomMax));
+	}
+	return BigInt(randomPart + lastSafePadding++ + now);
 }
-const _randomChar = (dict) => {
-  const poolIndex = number.randomNumber(0, dict.length - 1);
-  return dict[poolIndex];
+var _randomChar = (dict) => {
+	return dict[require_string.randomNumber(0, dict.length - 1)];
 };
 function uniqueString(minLength, dict) {
-  let finalLength = 0;
-  let finalDict = number.STRING_DICT;
-  if (type.isString(dict)) {
-    finalLength = minLength;
-    finalDict = dict;
-  } else if (type.isNumber(minLength)) {
-    finalLength = minLength;
-  } else if (type.isString(minLength)) {
-    finalDict = minLength;
-  }
-  let uniqueString2 = number.numberConvert(uniqueBigInt(), finalDict);
-  let insertLength = finalLength - uniqueString2.length;
-  if (insertLength <= 0) return uniqueString2;
-  while (insertLength--) {
-    uniqueString2 += _randomChar(finalDict);
-  }
-  return uniqueString2;
+	let finalLength = 0;
+	let finalDict = require_string.STRING_DICT;
+	if (require_type.isString(dict)) {
+		finalLength = minLength;
+		finalDict = dict;
+	} else if (require_type.isNumber(minLength)) finalLength = minLength;
+	else if (require_type.isString(minLength)) finalDict = minLength;
+	let uniqueString = require_string.numberConvert(uniqueBigInt(), finalDict);
+	let insertLength = finalLength - uniqueString.length;
+	if (insertLength <= 0) return uniqueString;
+	while (insertLength--) uniqueString += _randomChar(finalDict);
+	return uniqueString;
 }
+//#endregion
 exports.uniqueBigInt = uniqueBigInt;
 exports.uniqueString = uniqueString;
-//# sourceMappingURL=unique.cjs.map
+
+//# sourceMappingURL=unique.cjs.map