@mudbean/is 2.0.2 → 2.0.4

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # 版本日志
 
+## 2.0.4 (2026-6-14)
+
+- 修复导出错误
+
+## 2.0.3 (2026-6-13)
+
+- 维护导出信息及修改其他信息
+
 ## 2.0.2 (2026-6-9)
 
 - 维护注释信息

package/cjs/error.js

@@ -1 +1,211 @@
-"use strict";var r=require("./typeOf.js");exports.isAggregateError=function(e){return"aggregateerror"===r.typeOf(e)},exports.isError=function(e){return"error"===r.typeOf(e)},exports.isEvalError=function(e){return"evalerror"===r.typeOf(e)},exports.isRangeError=function(e){return"rangeerror"===r.typeOf(e)},exports.isReferenceError=function(e){return"referenceerror"===r.typeOf(e)},exports.isSyntaxError=function(e){return"syntaxerror"===r.typeOf(e)},exports.isTypeError=function(e){return"typeerror"===r.typeOf(e)},exports.isURIError=function(e){return"urierror"===r.typeOf(e)};
+'use strict';
+
+var typeOf = require('./typeOf.js');
+
+/**
+ * 检测 Javascript 数据类型工具之: error
+ */
+/**
+ * # 检测 `input` 是否是 `Error` 类型
+ *
+ * @param input - 待检测的数据，任意类型
+ * @returns 返回 `true` 则说明该数据 `input` 类型为 `Error` ，且在 Typescript 中进行类型收缩
+ * @example
+ *
+ * ```ts
+ * import { isError } from '@mudbean/is';
+ *
+ * console.log(isError(new Error('test'))); // true
+ *
+ * // false (类型不符)
+ * console.log(isError(new EvalError('test')));
+ * // false  (类型不符)
+ * console.log(isError(new RangeError('test')));
+ * // false (类型不符)
+ * console.log(isError(new ReferenceError('test')));
+ *
+ * // false (类型不符)
+ * console.log(isError({ message: 'test' }));
+ * ```
+ * @since 0.1.4
+ */
+function isError(input) {
+    return typeOf.typeOf(input) === 'error';
+}
+/**
+ * # 检测 `input` 是否是 `EvalError` 类型
+ *
+ * @param input - 待检测的数据，任意类型
+ * @returns 返回 `true` 则说明该数据 `input` 类型为 `EvalError` ，且在 Typescript 中进行类型收缩
+ * @example
+ *
+ * ```ts
+ * import  { isEvalError } from '@mudbean/is';
+ *
+ * console.log(isEvalError(new EvalError('test'))); // true
+ *
+ * // false (类型非 EvalError)
+ * console.log(isEvalError(new Error('test')));
+ * // false (类型非 EvalError)
+ * console.log(isEvalError(new TypeError('test')));
+ * // false (类型非 EvalError)
+ * console.log(isEvalError(new RangeError('test')));
+ *
+ * // false (类型非 EvalError)
+ * console.log(isEvalError({ message: 'test' }));
+ * ```
+ */
+function isEvalError(input) {
+    return typeOf.typeOf(input) === 'evalerror';
+}
+/**
+ * # 检测 `input 是否是 `RangeError` 类型
+ *
+ * @param input - 待检测的数据，任意类型
+ * @returns 返回 `true` 则说明该数据 `input` 类型为 `RangeError` ，且在 Typescript 中进行类型收缩
+ * @example
+ *
+ * ```ts
+ * import { isRangeError } from '@mudbean/is';
+ *
+ * console.log(isRangeError(new RangeError('test'))); // true
+ *
+ * // false (类型非 RangeError
+ * console.log(isRangeError(new Error('test')));
+ * // false (类型非 RangeError)
+ * console.log(isRangeError(new TypeError('test')));
+ * // false (类型非 RangeError)
+ * console.log(isRangeError(new SyntaxError('test')));
+ *
+ * // false (类型非 RangeError)
+ * console.log(isRangeError('test'));
+ * ```
+ */
+function isRangeError(input) {
+    return typeOf.typeOf(input) === 'rangeerror';
+}
+/**
+ * # 检测 `input` 是否是 `ReferenceError` 类型
+ *
+ * @param input - 待检测的数据，任意类型
+ * @returns 返回 `true` 则说明该数据 `input` 类型为 `ReferenceError` ，且在 Typescript 中进行类型收缩
+ * @example
+ *
+ * ```ts
+ * import { isReferenceError } from '@mudbean/is';
+ *
+ * console.log(isReferenceError(new ReferenceError('test'))); // true
+ *
+ * // false (类型非 ReferenceError)
+ * console.log(isReferenceError(new Error('test')));
+ * // false (类型非 ReferenceError)
+ * console.log(isReferenceError(new TypeError('test')));
+ * // false (类型非 ReferenceError)
+ * console.log(isReferenceError(new SyntaxError('test')));
+ *
+ * // false (类型非 ReferenceError)
+ * console.log(isReferenceError('test');
+ * ```
+ */
+function isReferenceError(input) {
+    return typeOf.typeOf(input) === 'referenceerror';
+}
+/**
+ * # 检测 `input` 是否是 `SyntaxError` 类型
+ *
+ *  @param input - 待检测的数据，任意类型
+ * @returns 返回 `true` 则说明该数据 `input` 类型为 `SyntaxError` ，且在 Typescript 中进行类型收缩
+ * @example
+ *
+ * ```ts
+ * import { isSyntaxError } from '@mudbean/is';
+ *
+ * console.log(isSyntaxError(new SyntaxError('test'))); // true
+ *
+ * // false (类型非 SyntaxError)
+ * console.log(isSyntaxError(new Error('test')));
+ * // false (类型非 SyntaxError)
+ * console.log(isSyntaxError(new TypeError('test')));
+ * // false (类型非 SyntaxError)
+ * console.log(isSyntaxError(new ReferenceError('test')));
+ *
+ * // false (类型非 SyntaxError)
+ * console.log(isSyntaxError('test'));
+ * ```
+ */
+function isSyntaxError(input) {
+    return typeOf.typeOf(input) === 'syntaxerror';
+}
+/**
+ * # 检测 `input` 是否是 `TypeError` 类型
+ *
+ * @param input - 待检测的数据，任意类型
+ * @returns 返回 `true` 则说明该数据 `input` 类型为 `TypeError` ，且在 Typescript 中进行类型收缩
+ * @example
+ *
+ * ```ts
+ * import { isTypeError } from '@mudbean/is';
+ *
+ * console.log(isTypeError(new TypeError('test'))); // true
+ *
+ * // false (类型非 TypeError)
+ * console.log(isTypeError(new Error('test')));
+ * // false (类型非 TypeError)
+ * console.log(isTypeError(new SyntaxError('test')));
+ * // false (类型非 TypeError)
+ * console.log(isTypeError(new ReferenceError('test')));
+ * // false (类型非 TypeError)
+ * console.log(isTypeError(new EvalError('test')));
+ *
+ * // false (类型非 TypeError)
+ * console.log(isTypeError('test');
+ * ```
+ */
+function isTypeError(input) {
+    return typeOf.typeOf(input) === 'typeerror';
+}
+/**
+ * # 检测 `input` 是否是 `URIError` 类型
+ *
+ * @param input - 待检测的数据，任意类型
+ * @returns 返回 `true` 则说明该数据 `input` 类型为 `URIError` ，且在 Typescript 中进行类型收缩
+ * @example
+ *
+ * ```ts
+ * import { isURIError } from '@mudbean/is';
+ *
+ * console.log(isURIError(new URIError('test'))); // true
+ *
+ * console.log(isURIError(new Error('test'))); // false
+ * ```
+ */
+function isURIError(input) {
+    return typeOf.typeOf(input) === 'urierror';
+}
+/**
+ * # 检测 `input` 是否是 `AggregateError` 类型
+ *
+ * @param input - 待检测的数据，任意类型
+ * @returns 返回 `true` 则说明该数据 `input` 类型为 `AggregateError` ，且在 Typescript 中进行类型收缩
+ * @example
+ *
+ * ```ts
+ * import { isAggregateError } from '@mudbean/is';
+ *
+ * console.log(isAggregateError(new AggregateError([]))); // true
+ *
+ * console.log(isAggregateError(new Error('test'))); // false
+ * ```
+ */
+function isAggregateError(input) {
+    return typeOf.typeOf(input) === 'aggregateerror';
+}
+
+exports.isAggregateError = isAggregateError;
+exports.isError = isError;
+exports.isEvalError = isEvalError;
+exports.isRangeError = isRangeError;
+exports.isReferenceError = isReferenceError;
+exports.isSyntaxError = isSyntaxError;
+exports.isTypeError = isTypeError;
+exports.isURIError = isURIError;

package/cjs/index.js

@@ -1 +1,76 @@
-"use strict";var r=require("./typeOf.js"),s=require("./isString.js"),i=require("./isNumber.js"),e=require("./isBoolean.js"),t=require("./isNull.js"),o=require("./isFunction.js"),a=require("./isArray.js"),p=require("./isObject.js"),n=require("./isSymbol.js"),x=require("./intl.js"),y=require("./error.js"),l=require("./isType.js");exports.typeOf=r.typeOf,exports.isBusinessEmptyString=s.isBusinessEmptyString,exports.isEmptyString=s.isEmptyString,exports.isRegExp=s.isRegExp,exports.isString=s.isString,exports.isBigInt=i.isBigInt,exports.isNaN=i.isNaN,exports.isNegativeInteger=i.isNegativeInteger,exports.isNumber=i.isNumber,exports.isPositiveInteger=i.isPositiveInteger,exports.isZero=i.isZero,exports.isBoolean=e.isBoolean,exports.isFalse=e.isFalse,exports.isTrue=e.isTrue,exports.isNull=t.isNull,exports.isUndefined=t.isUndefined,exports.isAsyncFunction=o.isAsyncFunction,exports.isFunction=o.isFunction,exports.isGenerator=o.isGenerator,exports.isGeneratorFunction=o.isGeneratorFunction,exports.isPromise=o.isPromise,exports.isArray=a.isArray,exports.isArrayBuffer=a.isArrayBuffer,exports.isBigInt64Array=a.isBigInt64Array,exports.isBigUint64Array=a.isBigUint64Array,exports.isEmptyArray=a.isEmptyArray,exports.isFloat32Array=a.isFloat32Array,exports.isFloat64Array=a.isFloat64Array,exports.isInt16Array=a.isInt16Array,exports.isInt8Array=a.isInt8Array,exports.isSet=a.isSet,exports.isSharedArrayBuffer=a.isSharedArrayBuffer,exports.isUint16Array=a.isUint16Array,exports.isUint32Array=a.isUint32Array,exports.isUint8Array=a.isUint8Array,exports.isUint8ClampedArray=a.isUint8ClampedArray,exports.isWeakSet=a.isWeakSet,exports.isDataView=p.isDataView,exports.isDate=p.isDate,exports.isEmptyObject=p.isEmptyObject,exports.isMap=p.isMap,exports.isPlainObject=p.isPlainObject,exports.isWeakMap=p.isWeakMap,exports.isSymbol=n.isSymbol,exports.isIntlCollator=x.isIntlCollator,exports.isIntlDateTimeFormat=x.isIntlDateTimeFormat,exports.isIntlDisplayNames=x.isIntlDisplayNames,exports.isIntlListFormat=x.isIntlListFormat,exports.isIntlLocale=x.isIntlLocale,exports.isIntlNumberFormat=x.isIntlNumberFormat,exports.isAggregateError=y.isAggregateError,exports.isError=y.isError,exports.isEvalError=y.isEvalError,exports.isRangeError=y.isRangeError,exports.isReferenceError=y.isReferenceError,exports.isSyntaxError=y.isSyntaxError,exports.isTypeError=y.isTypeError,exports.isURIError=y.isURIError,exports.isType=l.isType;
+'use strict';
+
+var typeOf = require('./typeOf.js');
+var isString = require('./isString.js');
+var isNumber = require('./isNumber.js');
+var isBoolean = require('./isBoolean.js');
+var isNull = require('./isNull.js');
+var isFunction = require('./isFunction.js');
+var isArray = require('./isArray.js');
+var isObject = require('./isObject.js');
+var isSymbol = require('./isSymbol.js');
+var intl = require('./intl.js');
+var error = require('./error.js');
+var isType = require('./isType.js');
+
+
+
+exports.typeOf = typeOf.typeOf;
+exports.isBusinessEmptyString = isString.isBusinessEmptyString;
+exports.isEmptyString = isString.isEmptyString;
+exports.isRegExp = isString.isRegExp;
+exports.isString = isString.isString;
+exports.isBigInt = isNumber.isBigInt;
+exports.isNaN = isNumber.isNaN;
+exports.isNegativeInteger = isNumber.isNegativeInteger;
+exports.isNumber = isNumber.isNumber;
+exports.isPositiveInteger = isNumber.isPositiveInteger;
+exports.isZero = isNumber.isZero;
+exports.isBoolean = isBoolean.isBoolean;
+exports.isFalse = isBoolean.isFalse;
+exports.isTrue = isBoolean.isTrue;
+exports.isNull = isNull.isNull;
+exports.isUndefined = isNull.isUndefined;
+exports.isAsyncFunction = isFunction.isAsyncFunction;
+exports.isFunction = isFunction.isFunction;
+exports.isGenerator = isFunction.isGenerator;
+exports.isGeneratorFunction = isFunction.isGeneratorFunction;
+exports.isPromise = isFunction.isPromise;
+exports.isArray = isArray.isArray;
+exports.isArrayBuffer = isArray.isArrayBuffer;
+exports.isBigInt64Array = isArray.isBigInt64Array;
+exports.isBigUint64Array = isArray.isBigUint64Array;
+exports.isEmptyArray = isArray.isEmptyArray;
+exports.isFloat32Array = isArray.isFloat32Array;
+exports.isFloat64Array = isArray.isFloat64Array;
+exports.isInt16Array = isArray.isInt16Array;
+exports.isInt8Array = isArray.isInt8Array;
+exports.isSet = isArray.isSet;
+exports.isSharedArrayBuffer = isArray.isSharedArrayBuffer;
+exports.isUint16Array = isArray.isUint16Array;
+exports.isUint32Array = isArray.isUint32Array;
+exports.isUint8Array = isArray.isUint8Array;
+exports.isUint8ClampedArray = isArray.isUint8ClampedArray;
+exports.isWeakSet = isArray.isWeakSet;
+exports.isDataView = isObject.isDataView;
+exports.isDate = isObject.isDate;
+exports.isEmptyObject = isObject.isEmptyObject;
+exports.isMap = isObject.isMap;
+exports.isPlainObject = isObject.isPlainObject;
+exports.isWeakMap = isObject.isWeakMap;
+exports.isSymbol = isSymbol.isSymbol;
+exports.isIntlCollator = intl.isIntlCollator;
+exports.isIntlDateTimeFormat = intl.isIntlDateTimeFormat;
+exports.isIntlDisplayNames = intl.isIntlDisplayNames;
+exports.isIntlListFormat = intl.isIntlListFormat;
+exports.isIntlLocale = intl.isIntlLocale;
+exports.isIntlNumberFormat = intl.isIntlNumberFormat;
+exports.isAggregateError = error.isAggregateError;
+exports.isError = error.isError;
+exports.isEvalError = error.isEvalError;
+exports.isRangeError = error.isRangeError;
+exports.isReferenceError = error.isReferenceError;
+exports.isSyntaxError = error.isSyntaxError;
+exports.isTypeError = error.isTypeError;
+exports.isURIError = error.isURIError;
+exports.isType = isType.isType;

package/cjs/intl.js

@@ -1 +1,152 @@
-"use strict";var t=require("./typeOf.js");exports.isIntlCollator=function(e){return"intl.collator"===t.typeOf(e)},exports.isIntlDateTimeFormat=function(e){return"intl.datetimeformat"===t.typeOf(e)},exports.isIntlDisplayNames=function(e){return"intl.displaynames"===t.typeOf(e)},exports.isIntlListFormat=function(e){return"intl.listformat"===t.typeOf(e)},exports.isIntlLocale=function(e){return"intl.locale"===t.typeOf(e)},exports.isIntlNumberFormat=function(e){return"intl.numberformat"===t.typeOf(e)};
+'use strict';
+
+var typeOf = require('./typeOf.js');
+
+/**
+ * 检测 Javascript 数据类型工具之: Intl
+ * @author Mr.MudBean <Mr.MudBean@outlook.com>
+ */
+/**
+ * # 检测 `input` 是否是 `Intl.Collator` 类型
+ *
+ * @param input - 待检测的数据，任意类型
+ * @returns 返回 `true` 则说明该数据 `input` 类型为 `Intl.Collator` ，且在 Typescript 中进行类型收缩
+ * @example
+ *
+ * ```ts
+ * import { isIntlCollator } from '@mudbean/is';
+ *
+ * console.log(isIntlCollator(new Intl.Collator())); // true
+ *
+ * console.log(isIntlCollator(new Intl.DateTimeFormat())); // false
+ * ```
+ */
+function isIntlCollator(input) {
+    return typeOf.typeOf(input) === 'intl.collator';
+}
+/**
+ * # 检测 `input` 是否是 `Intl.DateTimeFormat` 类型
+ *
+ * @param input - 待检测的数据，任意类型
+ * @returns 返回 `true` 则说明该数据 `input` 类型为 `Intl.DateTimeFormat` ，且在 Typescript 中进行类型收缩
+ *
+ * @example
+ *
+ * ```ts
+ * import { isIntlDateTimeFormat } from '@mudbean/is';
+ *
+ * console.log(isIntlDateTimeFormat(new Intl.DateTimeFormat())); // true
+ *
+ * console.log(isIntlDateTimeFormat('hello')); // false
+ * console.log(isIntlDateTimeFormat(1)); // false
+ * console.log(isIntlDateTimeFormat(true)); // false
+ * ```
+ */
+function isIntlDateTimeFormat(input) {
+    return typeOf.typeOf(input) === 'intl.datetimeformat';
+}
+/**
+ * # 检测 `input` 是否是 `Intl.DisplayNames` 类型
+ *
+ * @param input - 待检测的数据，任意类型
+ * @returns 返回 `true` 则说明该数据 `input` 类型为 `Intl.DisplayNames` ，且在 Typescript 中进行类型收缩
+ * @example
+ *
+ * ```ts
+ * import { isIntlDisplayNames } from '@mudbean/is';
+ *
+ * console.log(isIntlDisplayNames(new Intl.DisplayNames())); // true
+ *
+ * console.log(isIntlDisplayNames(new Intl.Locale())); // false
+ * ```
+ */
+function isIntlDisplayNames(input) {
+    return typeOf.typeOf(input) === 'intl.displaynames';
+}
+/**
+ * #检测 `input` 是否是 `Intl.DurationFormat` 类型
+ *
+ * @param input - 待检测的数据，任意类型
+ * @returns 返回 `true` 则说明该数据 `input` 类型为 `Intl.DurationFormat` ，且在 Typescript 中进行类型收缩
+ * @example
+ *
+ * ```ts
+ * import { isIntlDurationFormat } from '@mudbean/is';
+ *
+ * ```
+ *
+ */
+// export function isIntlDurationFormat(
+//   input: any,
+// ): input is Intl.DurationFormat {
+//   return typeOf(input) === 'intl.durationformat';
+// }
+/**
+ * # 检测 `input` 是否是 `Intl.ListFormat` 类型
+ * @param input - 待检测的数据，任意类型
+ * @returns 返回 `true` 则说明该数据 `input` 类型为 `Intl.ListFormat` ，且在 Typescript 中进行类型收缩
+ * @example
+ *
+ * ```ts
+ * import { isIntlListFormat } from '@mudbean/is';
+ *
+ * console.log(isIntlListFormat(new Intl.ListFormat())); // true
+ *
+ * console.log(isIntlListFormat(new Intl.DateTimeFormat())); // false
+ * console.log(isIntlListFormat(1)); // false
+ * console.log(isIntlListFormat('1')); // false
+ * console.log(isIntlListFormat(null)); // false
+ * ```
+ */
+function isIntlListFormat(input) {
+    return typeOf.typeOf(input) === 'intl.listformat';
+}
+/**
+ * # 检测 `input` 是否是 `Intl.Locale` 类型
+ *
+ * @param input - 待检测的数据，任意类型
+ * @returns 返回 `true` 则说明该数据 `input` 类型为 `Intl.Locale` ，且在 Typescript 中进行类型收缩
+ *
+ * @example
+ *
+ * ```ts
+ * import { isIntlLocale } from '@mudbean/is';
+ *
+ * console.log(isIntlLocale(new Intl.Locale())); // true
+ *
+ * console.log(isIntlLocale('en')); // false
+ * console.log(isIntlLocale(1)); // false
+ * ```
+ */
+function isIntlLocale(input) {
+    return typeOf.typeOf(input) === 'intl.locale';
+}
+/**
+ * # 检测 `input` 是否是 `Intl.NumberFormat` 类型
+ *
+ * @param input - 待检测的数据，任意类型
+ * @returns 返回 `true` 则说明该数据 `input` 类型为 `Intl.NumberFormat` ，且在 Typescript 中进行类型收缩
+ *
+ * @example
+ *
+ * ```ts
+ * import { isIntlNumberFormat } from '@mudbean/is';
+ *
+ * console.log(isIntlNumberFormat(new Intl.NumberFormat())); // true
+ *
+ * console.log(isIntlNumberFormat(123)); // false
+ * console.log(isIntlNumberFormat('123')); // false
+ * console.log(isIntlNumberFormat(new Date())); // false
+ * console.log(isIntlNumberFormat(new Date(0))); // false
+ * ```
+ */
+function isIntlNumberFormat(input) {
+    return typeOf.typeOf(input) === 'intl.numberformat';
+}
+
+exports.isIntlCollator = isIntlCollator;
+exports.isIntlDateTimeFormat = isIntlDateTimeFormat;
+exports.isIntlDisplayNames = isIntlDisplayNames;
+exports.isIntlListFormat = isIntlListFormat;
+exports.isIntlLocale = isIntlLocale;
+exports.isIntlNumberFormat = isIntlNumberFormat;