@odinlin/utils 0.0.1 → 1.0.0

package/dist/node/is/isPrimitive.cjs

@@ -0,0 +1,91 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_isTypeOf = require('./isTypeOf.cjs');
+let es_toolkit = require("es-toolkit");
+
+//#region src/is/isPrimitive.ts
+/**
+* 判断 null 类型的类型谓词
+* @param {unknown} x 待检测值
+*/
+const isNull = (x) => (0, es_toolkit.isNull)(x);
+/**
+* 判断 undefined 类型的类型谓词
+* @param {unknown} x 待检测值
+*/
+const isUndefined = (x) => (0, es_toolkit.isUndefined)(x);
+/**
+* 判断 boolean 类型的类型谓词
+* @param {unknown} x 待检测值
+*/
+const isBoolean = (x) => (0, es_toolkit.isBoolean)(x);
+/**
+* 判断 string 类型的类型谓词
+* @param {unknown} x 待检测值
+*/
+const isString = (x) => (0, es_toolkit.isString)(x);
+/**
+* 判断 Symbol 类型的类型谓词
+* @param {unknown} x 待检测值
+*/
+const isSymbol = (x) => (0, es_toolkit.isSymbol)(x);
+/**
+* 判断 number 类型的类型谓词
+* @param {unknown} x 待检测值
+*/
+const isNumber = (x) => require_isTypeOf.isTypeOf(x, ["number"]);
+/**
+* 判断 bigint 类型的类型谓词
+* @param {unknown} x 待检测值
+*/
+const isBigInt = (x) => require_isTypeOf.isTypeOf(x, ["bigint"]);
+/**
+* 判断 null 或 undefined 类型的类型谓词
+* @param {unknown} x 待检测值
+*/
+const isNil = (x) => (0, es_toolkit.isNil)(x);
+/**
+* 判断 基本数据 类型的类型谓词
+* @param {unknown} x 待检测值
+*/
+const isPrimitive = (x) => (0, es_toolkit.isPrimitive)(x);
+/**
+* 判断 boolean + new Boolean(x) 类型的类型谓词
+* @function override
+* @param {unknown} x 待检测值
+*/
+const isBooleanLike = (x) => isBoolean(x) || x instanceof Boolean;
+/**
+* 判断 string + new String(x) 类型的类型谓词
+* @function override
+* @param {unknown} x 待检测值
+*/
+const isStringLike = (x) => isString(x) || x instanceof String;
+/**
+* 判断 number + new Number(x) 类型的类型谓词
+* @function override
+* @param {unknown} x 待检测值
+*/
+const isNumberLike = (x) => isNumber(x) || x instanceof Number;
+/**
+* 判断是否为非数字
+* 🚫 非类型谓词
+* @function override
+* @example Number.isNaN(NaN) === Number.isNaN(Number('1a')) 非数字类型需要手动转成数字
+* @param {unknown} x 待检测值
+*/
+const isNotNumber = (x) => Number.isNaN(x);
+
+//#endregion
+exports.isBigInt = isBigInt;
+exports.isBoolean = isBoolean;
+exports.isBooleanLike = isBooleanLike;
+exports.isNil = isNil;
+exports.isNotNumber = isNotNumber;
+exports.isNull = isNull;
+exports.isNumber = isNumber;
+exports.isNumberLike = isNumberLike;
+exports.isPrimitive = isPrimitive;
+exports.isString = isString;
+exports.isStringLike = isStringLike;
+exports.isSymbol = isSymbol;
+exports.isUndefined = isUndefined;

package/dist/node/is/isPrimitive.d.ts

@@ -0,0 +1,79 @@
+//#region src/is/isPrimitive.d.ts
+/** 空值 */
+type TypeNil = null | undefined;
+/** 基本数据类型 */
+type TypePrimitive = null | undefined | boolean | number | bigint | string | symbol;
+/**
+ * 判断 null 类型的类型谓词
+ * @param {unknown} x 待检测值
+ */
+declare const isNull: (x: unknown) => x is null;
+/**
+ * 判断 undefined 类型的类型谓词
+ * @param {unknown} x 待检测值
+ */
+declare const isUndefined: (x: unknown) => x is undefined;
+/**
+ * 判断 boolean 类型的类型谓词
+ * @param {unknown} x 待检测值
+ */
+declare const isBoolean: (x: unknown) => x is boolean;
+/**
+ * 判断 string 类型的类型谓词
+ * @param {unknown} x 待检测值
+ */
+declare const isString: (x: unknown) => x is string;
+/**
+ * 判断 Symbol 类型的类型谓词
+ * @param {unknown} x 待检测值
+ */
+declare const isSymbol: (x: unknown) => x is symbol;
+/**
+ * 判断 number 类型的类型谓词
+ * @param {unknown} x 待检测值
+ */
+declare const isNumber: (x: unknown) => x is number;
+/**
+ * 判断 bigint 类型的类型谓词
+ * @param {unknown} x 待检测值
+ */
+declare const isBigInt: (x: unknown) => x is bigint;
+/**
+ * 判断 null 或 undefined 类型的类型谓词
+ * @param {unknown} x 待检测值
+ */
+declare const isNil: (x: unknown) => x is TypeNil;
+/**
+ * 判断 基本数据 类型的类型谓词
+ * @param {unknown} x 待检测值
+ */
+declare const isPrimitive: (x: unknown) => x is TypePrimitive;
+/**
+ * 判断 boolean + new Boolean(x) 类型的类型谓词
+ * @function override
+ * @param {unknown} x 待检测值
+ */
+declare const isBooleanLike: (x: unknown) => x is boolean;
+/**
+ * 判断 string + new String(x) 类型的类型谓词
+ * @function override
+ * @param {unknown} x 待检测值
+ */
+declare const isStringLike: (x: unknown) => x is string;
+/**
+ * 判断 number + new Number(x) 类型的类型谓词
+ * @function override
+ * @param {unknown} x 待检测值
+ */
+declare const isNumberLike: (x: unknown) => x is number;
+/**
+ * 判断是否为非数字
+ * 🚫 非类型谓词
+ * @function override
+ * @example Number.isNaN(NaN) === Number.isNaN(Number('1a')) 非数字类型需要手动转成数字
+ * @param {unknown} x 待检测值
+ */
+declare const isNotNumber: (x: unknown) => boolean;
+//#endregion
+export { TypeNil, TypePrimitive, isBigInt, isBoolean, isBooleanLike, isNil, isNotNumber, isNull, isNumber, isNumberLike, isPrimitive, isString, isStringLike, isSymbol, isUndefined };
+//# sourceMappingURL=isPrimitive.d.ts.map

package/dist/node/is/isPrimitive.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isPrimitive.d.ts","names":[],"sources":["../../../src/is/isPrimitive.ts"],"sourcesContent":[],"mappings":";;AAgBY,KAAA,OAAA,GAAO,IAAA,GAAA,SAAA;AAEnB;AAMa,KAND,aAAA,GAMkD,IAAA,GAAA,SAAA,GAAA,OAAA,GAAA,MAAA,GAAA,MAAA,GAAA,MAAA,GAAA,MAAA;AAK9D;AAMA;AAKA;AAKA;AAKa,cA1BA,MA0B+D,EAAA,CAAA,CAAA,EAAA,OAAA,EAAA,GAAA,CAAA,IAAA,IAAA;AAK5E;AAMA;AAKA;AAOA;AAMa,cAlDA,WAkDgF,EAAA,CAAA,CAAA,EAAA,OAAA,EAAA,GAAA,CAAA,IAAA,SAAA;AAM7F;AAQA;;;cA1Da;;;;;cAKA;;;;;cAKA;;;;;cAKA;;;;;cAKA;;;;;cAMA,4BAA2B;;;;;cAK3B,kCAAiC;;;;;;cAOjC;;;;;;cAMA;;;;;;cAMA;;;;;;;;cAQA"}

package/dist/node/is/isPrimitive.js

@@ -0,0 +1,79 @@
+import { isTypeOf } from "./isTypeOf.js";
+import { isBoolean, isNil, isNull, isPrimitive, isString, isSymbol, isUndefined } from "es-toolkit";
+
+//#region src/is/isPrimitive.ts
+/**
+* 判断 null 类型的类型谓词
+* @param {unknown} x 待检测值
+*/
+const isNull$1 = (x) => isNull(x);
+/**
+* 判断 undefined 类型的类型谓词
+* @param {unknown} x 待检测值
+*/
+const isUndefined$1 = (x) => isUndefined(x);
+/**
+* 判断 boolean 类型的类型谓词
+* @param {unknown} x 待检测值
+*/
+const isBoolean$1 = (x) => isBoolean(x);
+/**
+* 判断 string 类型的类型谓词
+* @param {unknown} x 待检测值
+*/
+const isString$1 = (x) => isString(x);
+/**
+* 判断 Symbol 类型的类型谓词
+* @param {unknown} x 待检测值
+*/
+const isSymbol$1 = (x) => isSymbol(x);
+/**
+* 判断 number 类型的类型谓词
+* @param {unknown} x 待检测值
+*/
+const isNumber = (x) => isTypeOf(x, ["number"]);
+/**
+* 判断 bigint 类型的类型谓词
+* @param {unknown} x 待检测值
+*/
+const isBigInt = (x) => isTypeOf(x, ["bigint"]);
+/**
+* 判断 null 或 undefined 类型的类型谓词
+* @param {unknown} x 待检测值
+*/
+const isNil$1 = (x) => isNil(x);
+/**
+* 判断 基本数据 类型的类型谓词
+* @param {unknown} x 待检测值
+*/
+const isPrimitive$1 = (x) => isPrimitive(x);
+/**
+* 判断 boolean + new Boolean(x) 类型的类型谓词
+* @function override
+* @param {unknown} x 待检测值
+*/
+const isBooleanLike = (x) => isBoolean$1(x) || x instanceof Boolean;
+/**
+* 判断 string + new String(x) 类型的类型谓词
+* @function override
+* @param {unknown} x 待检测值
+*/
+const isStringLike = (x) => isString$1(x) || x instanceof String;
+/**
+* 判断 number + new Number(x) 类型的类型谓词
+* @function override
+* @param {unknown} x 待检测值
+*/
+const isNumberLike = (x) => isNumber(x) || x instanceof Number;
+/**
+* 判断是否为非数字
+* 🚫 非类型谓词
+* @function override
+* @example Number.isNaN(NaN) === Number.isNaN(Number('1a')) 非数字类型需要手动转成数字
+* @param {unknown} x 待检测值
+*/
+const isNotNumber = (x) => Number.isNaN(x);
+
+//#endregion
+export { isBigInt, isBoolean$1 as isBoolean, isBooleanLike, isNil$1 as isNil, isNotNumber, isNull$1 as isNull, isNumber, isNumberLike, isPrimitive$1 as isPrimitive, isString$1 as isString, isStringLike, isSymbol$1 as isSymbol, isUndefined$1 as isUndefined };
+//# sourceMappingURL=isPrimitive.js.map

package/dist/node/is/isPrimitive.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"isPrimitive.js","names":["isNull","originNull","isUndefined","originUndefined","isBoolean","originBoolean","isString","originString","isSymbol","originSymbol","isNil","originNil","isPrimitive","originPrimitive"],"sources":["../../../src/is/isPrimitive.ts"],"sourcesContent":["/* eslint-disable unicorn/no-instanceof-builtins */\n/* eslint-disable perfectionist/sort-named-imports */\nimport {\n  isNull as originNull,\n  isUndefined as originUndefined,\n  isBoolean as originBoolean,\n  // isNumber as originNumber,\n  isString as originString,\n  // isBigInt as originBigInt,\n  isSymbol as originSymbol,\n  isNil as originNil,\n  isPrimitive as originPrimitive,\n} from 'es-toolkit'\nimport { isTypeOf } from './isTypeOf'\n\n/** 空值 */\nexport type TypeNil = null | undefined\n/** 基本数据类型 */\nexport type TypePrimitive = null | undefined | boolean | number | bigint | string | symbol\n\n/**\n * 判断 null 类型的类型谓词\n * @param {unknown} x 待检测值\n */\nexport const isNull = (x: unknown): x is null => originNull(x)\n/**\n * 判断 undefined 类型的类型谓词\n * @param {unknown} x 待检测值\n */\nexport const isUndefined = (x: unknown): x is undefined => originUndefined(x)\n\n/**\n * 判断 boolean 类型的类型谓词\n * @param {unknown} x 待检测值\n */\nexport const isBoolean = (x: unknown): x is boolean => originBoolean(x)\n/**\n * 判断 string 类型的类型谓词\n * @param {unknown} x 待检测值\n */\nexport const isString = (x: unknown): x is string => originString(x)\n/**\n * 判断 Symbol 类型的类型谓词\n * @param {unknown} x 待检测值\n */\nexport const isSymbol = (x: unknown): x is symbol => originSymbol(x)\n/**\n * 判断 number 类型的类型谓词\n * @param {unknown} x 待检测值\n */\nexport const isNumber = (x: unknown): x is number => isTypeOf(x, ['number'])\n/**\n * 判断 bigint 类型的类型谓词\n * @param {unknown} x 待检测值\n */\nexport const isBigInt = (x: unknown): x is bigint => isTypeOf(x, ['bigint'])\n\n/**\n * 判断 null 或 undefined 类型的类型谓词\n * @param {unknown} x 待检测值\n */\nexport const isNil = (x: unknown): x is TypeNil => originNil(x)\n/**\n * 判断 基本数据 类型的类型谓词\n * @param {unknown} x 待检测值\n */\nexport const isPrimitive = (x: unknown): x is TypePrimitive => originPrimitive(x)\n\n/**\n * 判断 boolean + new Boolean(x) 类型的类型谓词\n * @function override\n * @param {unknown} x 待检测值\n */\nexport const isBooleanLike = (x: unknown): x is boolean => isBoolean(x) || (x instanceof Boolean)\n/**\n * 判断 string + new String(x) 类型的类型谓词\n * @function override\n * @param {unknown} x 待检测值\n */\nexport const isStringLike = (x: unknown): x is string => isString(x) || (x instanceof String)\n/**\n * 判断 number + new Number(x) 类型的类型谓词\n * @function override\n * @param {unknown} x 待检测值\n */\nexport const isNumberLike = (x: unknown): x is number => isNumber(x) || (x instanceof Number)\n/**\n * 判断是否为非数字\n * 🚫 非类型谓词\n * @function override\n * @example Number.isNaN(NaN) === Number.isNaN(Number('1a')) 非数字类型需要手动转成数字\n * @param {unknown} x 待检测值\n */\nexport const isNotNumber = (x: unknown): boolean => Number.isNaN(x)\n"],"mappings":";;;;;;;;AAwBA,MAAaA,YAAU,MAA0BC,OAAW,EAAE;;;;;AAK9D,MAAaC,iBAAe,MAA+BC,YAAgB,EAAE;;;;;AAM7E,MAAaC,eAAa,MAA6BC,UAAc,EAAE;;;;;AAKvE,MAAaC,cAAY,MAA4BC,SAAa,EAAE;;;;;AAKpE,MAAaC,cAAY,MAA4BC,SAAa,EAAE;;;;;AAKpE,MAAa,YAAY,MAA4B,SAAS,GAAG,CAAC,SAAS,CAAC;;;;;AAK5E,MAAa,YAAY,MAA4B,SAAS,GAAG,CAAC,SAAS,CAAC;;;;;AAM5E,MAAaC,WAAS,MAA6BC,MAAU,EAAE;;;;;AAK/D,MAAaC,iBAAe,MAAmCC,YAAgB,EAAE;;;;;;AAOjF,MAAa,iBAAiB,MAA6BT,YAAU,EAAE,IAAK,aAAa;;;;;;AAMzF,MAAa,gBAAgB,MAA4BE,WAAS,EAAE,IAAK,aAAa;;;;;;AAMtF,MAAa,gBAAgB,MAA4B,SAAS,EAAE,IAAK,aAAa;;;;;;;;AAQtF,MAAa,eAAe,MAAwB,OAAO,MAAM,EAAE"}

package/dist/node/is/isPrimitiveWithout.cjs

@@ -0,0 +1,86 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+let es_toolkit = require("es-toolkit");
+let es_toolkit_compat = require("es-toolkit/compat");
+
+//#region src/is/isPrimitiveWithout.ts
+/**
+* 判断 Array 类型的类型谓词
+* @param {unknown} x 待检测值
+*/
+const isArray = (x) => (0, es_toolkit_compat.isArray)(x);
+/**
+* 判断 Object 类型的类型谓词
+* @param {unknown} x 待检测值
+*/
+const isObject = (x) => (0, es_toolkit_compat.isObject)(x);
+/**
+* 判断 Function 类型的类型谓词
+* @param {unknown} x 待检测值
+*/
+const isFunction = (x) => (0, es_toolkit.isFunction)(x);
+/**
+* 判断 Set 类型的类型谓词
+* @param {unknown} x 待检测值
+*/
+const isSet = (x) => (0, es_toolkit.isSet)(x);
+/**
+* 判断 Map 类型的类型谓词
+* @param {unknown} x 待检测值
+*/
+const isMap = (x) => (0, es_toolkit.isMap)(x);
+/**
+* 判断 WeakSet 类型的类型谓词
+* @param {unknown} x 待检测值
+*/
+const isWeakSet = (x) => (0, es_toolkit.isWeakSet)(x);
+/**
+* 判断 WeakMap 类型的类型谓词
+* @param {unknown} x 待检测值
+*/
+const isWeakMap = (x) => (0, es_toolkit.isWeakMap)(x);
+/**
+* 判断 Date 类型的类型谓词
+* @param {unknown} x 待检测值
+*/
+const isDate = (x) => (0, es_toolkit.isDate)(x);
+/**
+* 判断 RegExp 类型的类型谓词
+* @param {unknown} x 待检测值
+*/
+const isRegExp = (x) => (0, es_toolkit.isRegExp)(x);
+/**
+* 判断 Promise 类型的类型谓词
+* @param {unknown} x 待检测值
+*/
+const isPromise = (x) => (0, es_toolkit.isPromise)(x);
+/**
+* 判断 Error 类型的类型谓词
+* @param {unknown} x 待检测值
+*/
+const isError = (x) => (0, es_toolkit.isError)(x);
+/**
+* 判断 普通对象 Record<PropertyKey, unknown> 类型的类型谓词
+* @param {unknown} x 待检测值
+*/
+const isPlainObject = (x) => (0, es_toolkit.isPlainObject)(x);
+/**
+* 判断 给定值 是否为空
+* 🚫 非类型谓词
+* @returns {boolean} 可以判断字符串、数组、对象、Map、Set 等类型是否为空
+*/
+const isEmpty = (x) => (0, es_toolkit_compat.isEmpty)(x);
+
+//#endregion
+exports.isArray = isArray;
+exports.isDate = isDate;
+exports.isEmpty = isEmpty;
+exports.isError = isError;
+exports.isFunction = isFunction;
+exports.isMap = isMap;
+exports.isObject = isObject;
+exports.isPlainObject = isPlainObject;
+exports.isPromise = isPromise;
+exports.isRegExp = isRegExp;
+exports.isSet = isSet;
+exports.isWeakMap = isWeakMap;
+exports.isWeakSet = isWeakSet;

package/dist/node/is/isPrimitiveWithout.d.ts

@@ -0,0 +1,72 @@
+//#region src/is/isPrimitiveWithout.d.ts
+/** typedArray */
+type TypeTypedArray = Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | BigInt64Array | BigUint64Array | Float16Array | Float32Array | Float64Array;
+/**
+ * 判断 Array 类型的类型谓词
+ * @param {unknown} x 待检测值
+ */
+declare const isArray: <T = unknown>(x: unknown) => x is Array<T>;
+/**
+ * 判断 Object 类型的类型谓词
+ * @param {unknown} x 待检测值
+ */
+declare const isObject: (x: unknown) => x is object;
+/**
+ * 判断 Function 类型的类型谓词
+ * @param {unknown} x 待检测值
+ */
+declare const isFunction: (x: unknown) => x is (...args: any[]) => any;
+/**
+ * 判断 Set 类型的类型谓词
+ * @param {unknown} x 待检测值
+ */
+declare const isSet: <T = unknown>(x: unknown) => x is Set<T>;
+/**
+ * 判断 Map 类型的类型谓词
+ * @param {unknown} x 待检测值
+ */
+declare const isMap: <T = unknown, K extends PropertyKey = PropertyKey>(x: unknown) => x is Map<K, T>;
+/**
+ * 判断 WeakSet 类型的类型谓词
+ * @param {unknown} x 待检测值
+ */
+declare const isWeakSet: <T extends WeakKey = WeakKey>(x: unknown) => x is WeakSet<T>;
+/**
+ * 判断 WeakMap 类型的类型谓词
+ * @param {unknown} x 待检测值
+ */
+declare const isWeakMap: <T = unknown, K extends WeakKey = WeakKey>(x: unknown) => x is WeakMap<K, T>;
+/**
+ * 判断 Date 类型的类型谓词
+ * @param {unknown} x 待检测值
+ */
+declare const isDate: (x: unknown) => x is Date;
+/**
+ * 判断 RegExp 类型的类型谓词
+ * @param {unknown} x 待检测值
+ */
+declare const isRegExp: (x: unknown) => x is RegExp;
+/**
+ * 判断 Promise 类型的类型谓词
+ * @param {unknown} x 待检测值
+ */
+declare const isPromise: <T = unknown>(x: unknown) => x is Promise<T>;
+/**
+ * 判断 Error 类型的类型谓词
+ * @param {unknown} x 待检测值
+ */
+declare const isError: (x: unknown) => x is Error;
+/**
+ * 判断 普通对象 Record<PropertyKey, unknown> 类型的类型谓词
+ * @param {unknown} x 待检测值
+ */
+declare const isPlainObject: <T = unknown, K extends PropertyKey = PropertyKey>(x: unknown) => x is Record<K, T>;
+/**
+ * 判断 给定值 是否为空
+ * 🚫 非类型谓词
+ * @returns {boolean} 可以判断字符串、数组、对象、Map、Set 等类型是否为空
+ */
+declare const isEmpty: (x: unknown) => boolean;
+//#endregion
+export { TypeTypedArray, isArray, isDate, isEmpty, isError, isFunction, isMap, isObject, isPlainObject, isPromise, isRegExp, isSet, isWeakMap, isWeakSet };
+//# sourceMappingURL=isPrimitiveWithout.d.ts.map

package/dist/node/is/isPrimitiveWithout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isPrimitiveWithout.d.ts","names":[],"sources":["../../../src/is/isPrimitiveWithout.ts"],"sourcesContent":[],"mappings":";;AAgBY,KAAA,cAAA,GAAiB,SAAH,GAAe,UAAf,GAA4B,iBAA5B,GAAgD,UAAhD,GAA6D,WAA7D,GAA2E,UAA3E,GAAwF,WAAxF,GAAsG,aAAtG,GAAsH,cAAtH,GAAuI,YAAvI,GAAsJ,YAAtJ,GAAqK,YAArK;;;;;AAA6D,cAM1E,OAN0E,EAAA,CAAA,IAAA,OAAA,CAAA,CAAA,CAAA,EAAA,OAAA,EAAA,GAAA,CAAA,IAMhC,KANgC,CAM1B,CAN0B,CAAA;;;;;AAA0E,cAWpJ,QAXoJ,EAAA,CAAA,CAAA,EAAA,OAAA,EAAA,GAAA,CAAA,IAAA,MAAA;;;;AAMjK;AAKa,cAKA,UALuD,EAAA,CAAA,CAAA,EAAA,OAAA,EAAA,GAAA,CAAA,IAAA,CAAA,GAAA,IAAA,EAAA,GAAA,EAAA,EAAA,GAAA,GAAA;AAKpE;AAMA;AAKA;;AAA2D,cAL9C,KAK8C,EAAA,CAAA,IAAA,OAAA,CAAA,CAAA,CAAA,EAAA,OAAA,EAAA,GAAA,CAAA,IALN,GAKM,CALF,CAKE,CAAA;;;;;AAK9C,cALA,KAK0F,EAAA,CAAA,IAAA,OAAA,EAAA,UAL1D,WAK0D,GAL5C,WAK4C,CAAA,CAAA,CAAA,EAAA,OAAA,EAAA,GAAA,CAAA,IALb,GAKa,CALT,CAKS,EALN,CAKM,CAAA;;;;;AAAvB,cAAnE,SAAmE,EAAA,CAAA,UAA5C,OAA4C,GAAlC,OAAkC,CAAA,CAAA,CAAA,EAAA,OAAA,EAAA,GAAA,CAAA,IAAP,OAAO,CAAC,CAAD,CAAA;AAKhF;;;;AAAiG,cAApF,SAAoF,EAAA,CAAA,IAAA,OAAA,EAAA,UAAhD,OAAgD,GAAtC,OAAsC,CAAA,CAAA,CAAA,EAAA,OAAA,EAAA,GAAA,CAAA,IAAX,OAAW,CAAH,CAAG,EAAA,CAAA,CAAA;;;AAKjG;AAKA;AAKa,cAVA,MAU0E,EAAA,CAAtB,CAAA,EAAR,OAAA,EAAO,GAAA,CAAA,IAVvB,IAUuB;AAKhE;AAMA;;;AAAyG,cAhB5F,QAgB4F,EAAA,CAAA,CAAA,EAAA,OAAA,EAAA,GAAA,CAAA,IAhB9D,MAgB8D;;;;AAMzG;cAjBa,6CAA4C,QAAQ;;;;;cAKpD,8BAA6B;;;;;cAM7B,uCAAwC,cAAc,iCAA+B,OAAO,GAAG;;;;;;cAM/F"}

package/dist/node/is/isPrimitiveWithout.js

@@ -0,0 +1,74 @@
+import { isDate, isError, isFunction, isMap, isPlainObject, isPromise, isRegExp, isSet, isWeakMap, isWeakSet } from "es-toolkit";
+import { isArray, isEmpty, isObject } from "es-toolkit/compat";
+
+//#region src/is/isPrimitiveWithout.ts
+/**
+* 判断 Array 类型的类型谓词
+* @param {unknown} x 待检测值
+*/
+const isArray$1 = (x) => isArray(x);
+/**
+* 判断 Object 类型的类型谓词
+* @param {unknown} x 待检测值
+*/
+const isObject$1 = (x) => isObject(x);
+/**
+* 判断 Function 类型的类型谓词
+* @param {unknown} x 待检测值
+*/
+const isFunction$1 = (x) => isFunction(x);
+/**
+* 判断 Set 类型的类型谓词
+* @param {unknown} x 待检测值
+*/
+const isSet$1 = (x) => isSet(x);
+/**
+* 判断 Map 类型的类型谓词
+* @param {unknown} x 待检测值
+*/
+const isMap$1 = (x) => isMap(x);
+/**
+* 判断 WeakSet 类型的类型谓词
+* @param {unknown} x 待检测值
+*/
+const isWeakSet$1 = (x) => isWeakSet(x);
+/**
+* 判断 WeakMap 类型的类型谓词
+* @param {unknown} x 待检测值
+*/
+const isWeakMap$1 = (x) => isWeakMap(x);
+/**
+* 判断 Date 类型的类型谓词
+* @param {unknown} x 待检测值
+*/
+const isDate$1 = (x) => isDate(x);
+/**
+* 判断 RegExp 类型的类型谓词
+* @param {unknown} x 待检测值
+*/
+const isRegExp$1 = (x) => isRegExp(x);
+/**
+* 判断 Promise 类型的类型谓词
+* @param {unknown} x 待检测值
+*/
+const isPromise$1 = (x) => isPromise(x);
+/**
+* 判断 Error 类型的类型谓词
+* @param {unknown} x 待检测值
+*/
+const isError$1 = (x) => isError(x);
+/**
+* 判断 普通对象 Record<PropertyKey, unknown> 类型的类型谓词
+* @param {unknown} x 待检测值
+*/
+const isPlainObject$1 = (x) => isPlainObject(x);
+/**
+* 判断 给定值 是否为空
+* 🚫 非类型谓词
+* @returns {boolean} 可以判断字符串、数组、对象、Map、Set 等类型是否为空
+*/
+const isEmpty$1 = (x) => isEmpty(x);
+
+//#endregion
+export { isArray$1 as isArray, isDate$1 as isDate, isEmpty$1 as isEmpty, isError$1 as isError, isFunction$1 as isFunction, isMap$1 as isMap, isObject$1 as isObject, isPlainObject$1 as isPlainObject, isPromise$1 as isPromise, isRegExp$1 as isRegExp, isSet$1 as isSet, isWeakMap$1 as isWeakMap, isWeakSet$1 as isWeakSet };
+//# sourceMappingURL=isPrimitiveWithout.js.map

package/dist/node/is/isPrimitiveWithout.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"isPrimitiveWithout.js","names":["isArray","originArray","isObject","originObject","isFunction","originFunction","isSet","originSet","isMap","originMap","isWeakSet","originWeakSet","isWeakMap","originWeakMap","isDate","originDate","isRegExp","originRegExp","isPromise","originPromise","isError","originError","isPlainObject","originPlainObject","isEmpty","originEmpty"],"sources":["../../../src/is/isPrimitiveWithout.ts"],"sourcesContent":["/* eslint-disable perfectionist/sort-named-imports */\nimport {\n  isFunction as originFunction,\n  isSet as originSet,\n  isMap as originMap,\n  isWeakSet as originWeakSet,\n  isWeakMap as originWeakMap,\n  isDate as originDate,\n  isRegExp as originRegExp,\n  isPromise as originPromise,\n  isError as originError,\n  isPlainObject as originPlainObject,\n} from 'es-toolkit'\nimport { isArray as originArray, isObject as originObject, isEmpty as originEmpty } from 'es-toolkit/compat'\n\n/** typedArray */\nexport type TypeTypedArray = Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | BigInt64Array | BigUint64Array | Float16Array | Float32Array | Float64Array\n\n/**\n * 判断 Array 类型的类型谓词\n * @param {unknown} x 待检测值\n */\nexport const isArray = <T = unknown>(x: unknown): x is Array<T> => originArray(x)\n/**\n * 判断 Object 类型的类型谓词\n * @param {unknown} x 待检测值\n */\nexport const isObject = (x: unknown): x is object => originObject(x)\n/**\n * 判断 Function 类型的类型谓词\n * @param {unknown} x 待检测值\n */\nexport const isFunction = (x: unknown): x is (...args: any[]) => any => originFunction(x)\n\n/**\n * 判断 Set 类型的类型谓词\n * @param {unknown} x 待检测值\n */\nexport const isSet = <T = unknown>(x: unknown): x is Set<T> => originSet(x)\n/**\n * 判断 Map 类型的类型谓词\n * @param {unknown} x 待检测值\n */\nexport const isMap = <T = unknown, K extends PropertyKey = PropertyKey>(x: unknown): x is Map<K, T> => originMap(x)\n/**\n * 判断 WeakSet 类型的类型谓词\n * @param {unknown} x 待检测值\n */\nexport const isWeakSet = <T extends WeakKey = WeakKey>(x: unknown): x is WeakSet<T> => originWeakSet(x)\n/**\n * 判断 WeakMap 类型的类型谓词\n * @param {unknown} x 待检测值\n */\nexport const isWeakMap = <T = unknown, K extends WeakKey = WeakKey>(x: unknown): x is WeakMap<K, T> => originWeakMap(x)\n/**\n * 判断 Date 类型的类型谓词\n * @param {unknown} x 待检测值\n */\nexport const isDate = (x: unknown): x is Date => originDate(x)\n/**\n * 判断 RegExp 类型的类型谓词\n * @param {unknown} x 待检测值\n */\nexport const isRegExp = (x: unknown): x is RegExp => originRegExp(x)\n/**\n * 判断 Promise 类型的类型谓词\n * @param {unknown} x 待检测值\n */\nexport const isPromise = <T = unknown>(x: unknown): x is Promise<T> => originPromise(x)\n/**\n * 判断 Error 类型的类型谓词\n * @param {unknown} x 待检测值\n */\nexport const isError = (x: unknown): x is Error => originError(x)\n\n/**\n * 判断 普通对象 Record<PropertyKey, unknown> 类型的类型谓词\n * @param {unknown} x 待检测值\n */\nexport const isPlainObject = <T = unknown, K extends PropertyKey = PropertyKey>(x: unknown): x is Record<K, T> => originPlainObject(x)\n/**\n * 判断 给定值 是否为空\n * 🚫 非类型谓词\n * @returns {boolean} 可以判断字符串、数组、对象、Map、Set 等类型是否为空\n */\nexport const isEmpty = (x: unknown): boolean => originEmpty(x)\n"],"mappings":";;;;;;;;AAsBA,MAAaA,aAAwB,MAA8BC,QAAY,EAAE;;;;;AAKjF,MAAaC,cAAY,MAA4BC,SAAa,EAAE;;;;;AAKpE,MAAaC,gBAAc,MAA6CC,WAAe,EAAE;;;;;AAMzF,MAAaC,WAAsB,MAA4BC,MAAU,EAAE;;;;;AAK3E,MAAaC,WAA2D,MAA+BC,MAAU,EAAE;;;;;AAKnH,MAAaC,eAA0C,MAAgCC,UAAc,EAAE;;;;;AAKvG,MAAaC,eAAuD,MAAmCC,UAAc,EAAE;;;;;AAKvH,MAAaC,YAAU,MAA0BC,OAAW,EAAE;;;;;AAK9D,MAAaC,cAAY,MAA4BC,SAAa,EAAE;;;;;AAKpE,MAAaC,eAA0B,MAAgCC,UAAc,EAAE;;;;;AAKvF,MAAaC,aAAW,MAA2BC,QAAY,EAAE;;;;;AAMjE,MAAaC,mBAAmE,MAAkCC,cAAkB,EAAE;;;;;;AAMtI,MAAaC,aAAW,MAAwBC,QAAY,EAAE"}

package/dist/node/is/isTagOf.cjs

@@ -0,0 +1,21 @@
+
+//#region src/is/isTagOf.ts
+const toString = Object.prototype.toString;
+const toStringCache = Object.create(null);
+function tagOf(thing) {
+	const str = toString.call(thing);
+	return toStringCache[str] || (toStringCache[str] = str.slice(8, -1).toLowerCase());
+}
+/**
+* 根据 `Object.prototype.toString` 方法判断值的类型
+* @param {unknown} x The value to test.
+* @param {string[]} type The types to check.
+*
+* @reference axios/dist/axios.js
+*/
+function isTagOf(x, type) {
+	return type.some((t) => tagOf(x) === t.toLowerCase());
+}
+
+//#endregion
+exports.isTagOf = isTagOf;

package/dist/node/is/isTagOf.d.ts

@@ -0,0 +1,12 @@
+//#region src/is/isTagOf.d.ts
+/**
+ * 根据 `Object.prototype.toString` 方法判断值的类型
+ * @param {unknown} x The value to test.
+ * @param {string[]} type The types to check.
+ *
+ * @reference axios/dist/axios.js
+ */
+declare function isTagOf(x: unknown, type: string[]): boolean;
+//#endregion
+export { isTagOf };
+//# sourceMappingURL=isTagOf.d.ts.map

package/dist/node/is/isTagOf.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isTagOf.d.ts","names":[],"sources":["../../../src/is/isTagOf.ts"],"sourcesContent":[],"mappings":";;AAiBA;;;;;;iBAAgB,OAAA"}

package/dist/node/is/isTagOf.js

@@ -0,0 +1,21 @@
+//#region src/is/isTagOf.ts
+const toString = Object.prototype.toString;
+const toStringCache = Object.create(null);
+function tagOf(thing) {
+	const str = toString.call(thing);
+	return toStringCache[str] || (toStringCache[str] = str.slice(8, -1).toLowerCase());
+}
+/**
+* 根据 `Object.prototype.toString` 方法判断值的类型
+* @param {unknown} x The value to test.
+* @param {string[]} type The types to check.
+*
+* @reference axios/dist/axios.js
+*/
+function isTagOf(x, type) {
+	return type.some((t) => tagOf(x) === t.toLowerCase());
+}
+
+//#endregion
+export { isTagOf };
+//# sourceMappingURL=isTagOf.js.map

package/dist/node/is/isTagOf.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"isTagOf.js","names":["toStringCache: Record<string, string>"],"sources":["../../../src/is/isTagOf.ts"],"sourcesContent":["// eslint-disable-next-line ts/unbound-method\nconst toString = Object.prototype.toString\n\nconst toStringCache: Record<string, string> = Object.create(null)\n\nfunction tagOf(thing: unknown): string {\n  const str = toString.call(thing)\n  return toStringCache[str] || (toStringCache[str] = str.slice(8, -1).toLowerCase())\n};\n\n/**\n * 根据 `Object.prototype.toString` 方法判断值的类型\n * @param {unknown} x The value to test.\n * @param {string[]} type The types to check.\n *\n * @reference axios/dist/axios.js\n */\nexport function isTagOf(x: unknown, type: string[]): boolean {\n  return type.some(t => tagOf(x) === t.toLowerCase())\n}\n"],"mappings":";AACA,MAAM,WAAW,OAAO,UAAU;AAElC,MAAMA,gBAAwC,OAAO,OAAO,KAAK;AAEjE,SAAS,MAAM,OAAwB;CACrC,MAAM,MAAM,SAAS,KAAK,MAAM;AAChC,QAAO,cAAc,SAAS,cAAc,OAAO,IAAI,MAAM,GAAG,GAAG,CAAC,aAAa;;;;;;;;;AAUnF,SAAgB,QAAQ,GAAY,MAAyB;AAC3D,QAAO,KAAK,MAAK,MAAK,MAAM,EAAE,KAAK,EAAE,aAAa,CAAC"}

package/dist/node/is/isTypeOf.cjs

@@ -0,0 +1,29 @@
+
+//#region src/is/isTypeOf.ts
+/**
+* The result of `typeof` operator.
+*/
+const isTypeOfResult = [
+	"bigint",
+	"boolean",
+	"function",
+	"number",
+	"object",
+	"string",
+	"symbol",
+	"undefined"
+];
+/**
+* 根据 `typeof` 方法判断值的类型
+* @param {unknown} x The value to test.
+* @param {string[]} type The types to check.
+*
+* @reference axios/dist/axios.js
+*/
+function isTypeOf(x, type) {
+	return type.some((t) => typeof x === t.toLowerCase());
+}
+
+//#endregion
+exports.isTypeOf = isTypeOf;
+exports.isTypeOfResult = isTypeOfResult;

package/dist/node/is/isTypeOf.d.ts

@@ -0,0 +1,16 @@
+//#region src/is/isTypeOf.d.ts
+/**
+ * The result of `typeof` operator.
+ */
+declare const isTypeOfResult: readonly ["bigint", "boolean", "function", "number", "object", "string", "symbol", "undefined"];
+/**
+ * 根据 `typeof` 方法判断值的类型
+ * @param {unknown} x The value to test.
+ * @param {string[]} type The types to check.
+ *
+ * @reference axios/dist/axios.js
+ */
+declare function isTypeOf(x: unknown, type: string[]): boolean;
+//#endregion
+export { isTypeOf, isTypeOfResult };
+//# sourceMappingURL=isTypeOf.d.ts.map

package/dist/node/is/isTypeOf.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isTypeOf.d.ts","names":[],"sources":["../../../src/is/isTypeOf.ts"],"sourcesContent":[],"mappings":";;AAGA;AASA;cATa;;;;;;;;iBASG,QAAA"}

package/dist/node/is/isTypeOf.js

@@ -0,0 +1,28 @@
+//#region src/is/isTypeOf.ts
+/**
+* The result of `typeof` operator.
+*/
+const isTypeOfResult = [
+	"bigint",
+	"boolean",
+	"function",
+	"number",
+	"object",
+	"string",
+	"symbol",
+	"undefined"
+];
+/**
+* 根据 `typeof` 方法判断值的类型
+* @param {unknown} x The value to test.
+* @param {string[]} type The types to check.
+*
+* @reference axios/dist/axios.js
+*/
+function isTypeOf(x, type) {
+	return type.some((t) => typeof x === t.toLowerCase());
+}
+
+//#endregion
+export { isTypeOf, isTypeOfResult };
+//# sourceMappingURL=isTypeOf.js.map

package/dist/node/is/isTypeOf.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"isTypeOf.js","names":[],"sources":["../../../src/is/isTypeOf.ts"],"sourcesContent":["/**\n * The result of `typeof` operator.\n */\nexport const isTypeOfResult = ['bigint', 'boolean', 'function', 'number', 'object', 'string', 'symbol', 'undefined'] as const\n\n/**\n * 根据 `typeof` 方法判断值的类型\n * @param {unknown} x The value to test.\n * @param {string[]} type The types to check.\n *\n * @reference axios/dist/axios.js\n */\nexport function isTypeOf(x: unknown, type: string[]): boolean {\n  // eslint-disable-next-line valid-typeof\n  return type.some(t => (typeof x) === t.toLowerCase())\n}\n"],"mappings":";;;;AAGA,MAAa,iBAAiB;CAAC;CAAU;CAAW;CAAY;CAAU;CAAU;CAAU;CAAU;CAAY;;;;;;;;AASpH,SAAgB,SAAS,GAAY,MAAyB;AAE5D,QAAO,KAAK,MAAK,MAAM,OAAO,MAAO,EAAE,aAAa,CAAC"}