@mudbean/is 2.0.2 → 2.0.3

package/es/error.js

@@ -1 +1,202 @@
-import{typeOf as r}from"./typeOf.js";function e(e){return"error"===r(e)}function n(e){return"evalerror"===r(e)}function t(e){return"rangeerror"===r(e)}function o(e){return"referenceerror"===r(e)}function u(e){return"syntaxerror"===r(e)}function f(e){return"typeerror"===r(e)}function i(e){return"urierror"===r(e)}function c(e){return"aggregateerror"===r(e)}export{c as isAggregateError,e as isError,n as isEvalError,t as isRangeError,o as isReferenceError,u as isSyntaxError,f as isTypeError,i as isURIError};
+import { typeOf } from './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(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(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(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(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(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(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(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(input) === 'aggregateerror';
+}
+
+export { isAggregateError, isError, isEvalError, isRangeError, isReferenceError, isSyntaxError, isTypeError, isURIError };

package/es/index.js

@@ -1 +1,12 @@
-export{typeOf}from"./typeOf.js";export{isBusinessEmptyString,isEmptyString,isRegExp,isString}from"./isString.js";export{isBigInt,isNaN,isNegativeInteger,isNumber,isPositiveInteger,isZero}from"./isNumber.js";export{isBoolean,isFalse,isTrue}from"./isBoolean.js";export{isNull,isUndefined}from"./isNull.js";export{isAsyncFunction,isFunction,isGenerator,isGeneratorFunction,isPromise}from"./isFunction.js";export{isArray,isArrayBuffer,isBigInt64Array,isBigUint64Array,isEmptyArray,isFloat32Array,isFloat64Array,isInt16Array,isInt8Array,isSet,isSharedArrayBuffer,isUint16Array,isUint32Array,isUint8Array,isUint8ClampedArray,isWeakSet}from"./isArray.js";export{isDataView,isDate,isEmptyObject,isMap,isPlainObject,isWeakMap}from"./isObject.js";export{isSymbol}from"./isSymbol.js";export{isIntlCollator,isIntlDateTimeFormat,isIntlDisplayNames,isIntlListFormat,isIntlLocale,isIntlNumberFormat}from"./intl.js";export{isAggregateError,isError,isEvalError,isRangeError,isReferenceError,isSyntaxError,isTypeError,isURIError}from"./error.js";export{isType}from"./isType.js";
+export { typeOf } from './typeOf.js';
+export { isBusinessEmptyString, isEmptyString, isRegExp, isString } from './isString.js';
+export { isBigInt, isNaN, isNegativeInteger, isNumber, isPositiveInteger, isZero } from './isNumber.js';
+export { isBoolean, isFalse, isTrue } from './isBoolean.js';
+export { isNull, isUndefined } from './isNull.js';
+export { isAsyncFunction, isFunction, isGenerator, isGeneratorFunction, isPromise } from './isFunction.js';
+export { isArray, isArrayBuffer, isBigInt64Array, isBigUint64Array, isEmptyArray, isFloat32Array, isFloat64Array, isInt16Array, isInt8Array, isSet, isSharedArrayBuffer, isUint16Array, isUint32Array, isUint8Array, isUint8ClampedArray, isWeakSet } from './isArray.js';
+export { isDataView, isDate, isEmptyObject, isMap, isPlainObject, isWeakMap } from './isObject.js';
+export { isSymbol } from './isSymbol.js';
+export { isIntlCollator, isIntlDateTimeFormat, isIntlDisplayNames, isIntlListFormat, isIntlLocale, isIntlNumberFormat } from './intl.js';
+export { isAggregateError, isError, isEvalError, isRangeError, isReferenceError, isSyntaxError, isTypeError, isURIError } from './error.js';
+export { isType } from './isType.js';

package/es/intl.js

@@ -1 +1,145 @@
-import{typeOf as t}from"./typeOf.js";function n(n){return"intl.collator"===t(n)}function r(n){return"intl.datetimeformat"===t(n)}function i(n){return"intl.displaynames"===t(n)}function o(n){return"intl.listformat"===t(n)}function e(n){return"intl.locale"===t(n)}function u(n){return"intl.numberformat"===t(n)}export{n as isIntlCollator,r as isIntlDateTimeFormat,i as isIntlDisplayNames,o as isIntlListFormat,e as isIntlLocale,u as isIntlNumberFormat};
+import { typeOf } from './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(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(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(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(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(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(input) === 'intl.numberformat';
+}
+
+export { isIntlCollator, isIntlDateTimeFormat, isIntlDisplayNames, isIntlListFormat, isIntlLocale, isIntlNumberFormat };

package/es/isArray.js

@@ -1 +1,323 @@
-import{typeOf as r}from"./typeOf.js";function n(r){return Array.isArray(r)}function t(r){if(n(r))return 0===r.length;throw new TypeError("参数必须为数组")}function u(n){return"set"===r(n)}function a(n){return"weakset"===r(n)}function i(n){return"bigint64array"===r(n)}function e(n){return"biguint64array"===r(n)}function f(n){return"arraybuffer"===r(n)}function o(n){return"int8array"===r(n)}function c(n){return"uint8array"===r(n)}function y(n){return"int16array"===r(n)}function p(n){return"uint16array"===r(n)}function s(n){return"uint32array"===r(n)}function b(n){return"float32array"===r(n)}function l(n){return"float64array"===r(n)}function g(n){return"sharedarraybuffer"===r(n)}function h(n){return"uint8clampedarray"===r(n)}export{n as isArray,f as isArrayBuffer,i as isBigInt64Array,e as isBigUint64Array,t as isEmptyArray,b as isFloat32Array,l as isFloat64Array,y as isInt16Array,o as isInt8Array,u as isSet,g as isSharedArrayBuffer,p as isUint16Array,s as isUint32Array,c as isUint8Array,h as isUint8ClampedArray,a as isWeakSet};
+import { typeOf } from './typeOf.js';
+
+/**
+ * 检测 Javascript 数据类型工具之: array
+ */
+/**
+ * # 检测 `input` 是否是 `Array` 类型
+ *
+ * @param input - 待检测的数据，任意类型
+ * @returns 返回 `true` 则说明该数据 `input` 类型为 `ReferenceError` ，且在 Typescript 中进行类型收缩
+ * @example
+ *
+ * ```ts
+ * import  { isArray } from '@mudbean/is';
+ *
+ * console.log(isArray([1,2,3])) // true
+ * console.log(isArray({})) // false
+ * console.log(isArray(new Set())) // false
+ * ```
+ */
+function isArray(input) {
+    return Array.isArray(input);
+}
+/**
+ * # 检测 `input` 是否是空数组
+ *
+ * @param input - 待检测的数据，任意数组
+ * @returns 返回 `true` 则说明该数据 `input` 为长度为 0 的空数组 ，且在 Typescript 中进行类型收缩
+ * @example
+ *
+ * ```ts
+ * import  { isEmptyArray } from '@mudbean/is';
+ *
+ * console.log(isEmptyArray([])) // true
+ *
+ * console.log(isEmptyArray([1,2,3])) // false
+ * console.log(isEmptyArray({})) // TypeError
+ * console.log(isEmptyArray(new Set())) // false
+ * ```
+ */
+function isEmptyArray(input) {
+    if (isArray(input)) {
+        return input.length === 0;
+    }
+    throw new TypeError('参数必须为数组');
+}
+/**
+ * # 检测 `input` 是否是 `Set` 类型
+ *
+ * @param input - 待检测的数据，任意类型
+ * @returns 返回 `true` 则说明该数据 `input` 类型为 `ReferenceError` ，且在 Typescript 中进行类型收缩
+ * @example
+ *
+ * ```ts
+ * import  { isSet } from '@mudbean/is';
+ *
+ * console.log(isSet(new Set())) // true
+ * console.log(isSet({})) // false
+ * console.log(isSet([])) // false
+ * ```
+ */
+function isSet(input) {
+    return typeOf(input) === 'set';
+}
+/**
+ * # 检测 `input` 是否是 `WeakSet` 类型
+ *
+ * @param input - 待检测的数据，任意类型
+ * @returns 返回 `true` 则说明该数据 `input` 类型为 `WeakSet` ，且在 Typescript 中进行类型收缩
+ * @example
+ *
+ * ```ts
+ * import  { isWeakSet } from '@mudbean/is';
+ *
+ * console.log(isWeakSet(new WeakSet())) // true
+ *
+ * console.log(isWeakSet({})) // false
+ * console.log(isWeakSet([])) // false
+ * console.log(isWeakSet(1)) // false
+ * ```
+ */
+function isWeakSet(input) {
+    return typeOf(input) === 'weakset';
+}
+/**
+ * # 检测 `input` 是否是 `Bigint64Array` 类型
+ *
+ * @param input - 待检测的数据，任意类型
+ * @returns 返回 `true` 则说明该数据 `input` 类型为 `BigInt64Array` ，且在 Typescript 中进行类型收缩
+ * @example
+ *
+ * ```ts
+ * import  { isBigInt64Array } from '@mudbean/is';
+ *
+ * console.log(isBigInt64Array(new BigInt64Array())) // true
+ *
+ * console.log(isBigInt64Array({})) // false
+ * console.log(isBigInt64Array([])) // false
+ *
+ * ```
+ */
+function isBigInt64Array(input) {
+    return typeOf(input) === 'bigint64array';
+}
+/**
+ * # 检测 `input` 是否是 `BigUint64Array` 类型
+ *
+ * @param input - 待检测的数据，任意类型
+ * @returns 返回 `true` 则说明该数据 `input` 类型为 `BigUint64Array` ，且在 Typescript 中进行类型收缩
+ * @example
+ *
+ * ```ts
+ * import  { isBigUint64Array } from '@mudbean/is';
+ *
+ * console.log(isBigUint64Array(new BigUint64Array())) // true
+ *
+ * console.log(isBigUint64Array({})) // false
+ * console.log(isBigUint64Array([])) // false
+ * console.log(isBigUint64Array(1)) // false
+ * ```
+ */
+function isBigUint64Array(input) {
+    return typeOf(input) === 'biguint64array';
+}
+/**
+ * # 检测 `input` 是否是 `ArrayBuffer` 类型
+ *
+ * @param input - 待检测的数据，任意类型
+ * @returns 返回 `true` 则说明该数据 `input` 类型为 `ArrayBuffer` ，且在 Typescript 中进行类型收缩
+ * @example
+ *
+ * ```ts
+ * import  { isArrayBuffer } from '@mudbean/is';
+ *
+ * console.log(isArrayBuffer(new ArrayBuffer(8))) // true
+ *
+ * console.log(isArrayBuffer({})) // false
+ * ```
+ */
+function isArrayBuffer(input) {
+    return typeOf(input) === 'arraybuffer';
+}
+/**
+ * # 检测 `input` 是否是 `int8Array` 类型
+ *
+ * @param input - 待检测的数据，任意类型
+ * @returns 返回 `true` 则说明该数据 `input` 类型为 `Int8Array` ，且在 Typescript 中进行类型收缩
+ * @example
+ *
+ * ```ts
+ * import  { isInt8Array } from '@mudbean/is';
+ *
+ * console.log(isInt8Array(new Int8Array())) // true
+ *
+ * console.log(isInt8Array({})) // false
+ * console.log(isInt8Array([])) // false
+ * console.log(isInt8Array(1)) // false
+ * ```
+ */
+function isInt8Array(input) {
+    return typeOf(input) === 'int8array';
+}
+/**
+ * # 检测 `input` 是否是 `uint8Array` 类型
+ *
+ * @param input - 待检测的数据，任意类型
+ * @returns 返回 `true` 则说明该数据 `input` 类型为 `Uint8Array` ，且在 Typescript 中进行类型收缩
+ * @example
+ *
+ * ```ts
+ * import  { isUint8Array } from '@mudbean/is';
+ *
+ * console.log(isUint8Array(new Uint8Array())) // true
+ *
+ * console.log(isUint8Array({})) // false
+ * console.log(isUint8Array([])) // false
+ * console.log(isUint8Array(1)) // false
+ * ```
+ */
+function isUint8Array(input) {
+    return typeOf(input) === 'uint8array';
+}
+/**
+ * # 检测 `input` 是否是 `int16Array` 类型
+ *
+ * @param input - 待检测的数据，任意类型
+ * @returns 返回 `true` 则说明该数据 `input` 类型为 `Int16Array` ，且在 Typescript 中进行类型收缩
+ * @example
+ *
+ * ```ts
+ * import  { isInt16Array } from '@mudbean/is';
+ *
+ * console.log(isInt16Array(new Int16Array())) // true
+ *
+ * console.log(isInt16Array({})) // false
+ * console.log(isInt16Array([])) // false
+ * console.log(isInt16Array(1)) // false
+ * ```
+ */
+function isInt16Array(input) {
+    return typeOf(input) === 'int16array';
+}
+/**
+ * # 检测 `input` 是否是 `uint16Array` 类型
+ *
+ * @param input - 待检测的数据，任意类型
+ * @returns 返回 `true` 则说明该数据 `input` 类型为 `Uint16Array` ，且在 Typescript 中进行类型收缩
+ * @example
+ *
+ * ```ts
+ *
+ * import  { isUint16Array } from '@mudbean/is';
+ *
+ * console.log(isUint16Array(new Uint16Array())) // true
+ *
+ * console.log(isUint16Array({})) // false
+ * console.log(isUint16Array([])) // false
+ * console.log(isUint16Array(1)) // false
+ * ```
+ */
+function isUint16Array(input) {
+    return typeOf(input) === 'uint16array';
+}
+/**
+ * # 检测 `input` 是否是 `uint32Array` 类型
+ *
+ * @param input - 待检测的数据，任意类型
+ * @returns 返回 `true` 则说明该数据 `input` 类型为 `Uint32Array` ，且在 Typescript 中进行类型收缩
+ * @example
+ *
+ * ```ts
+ * import  { isUint32Array } from '@mudbean/is';
+ *
+ * console.log(isUint32Array(new Uint32Array())) // true
+ *
+ * console.log(isUint32Array({})) // false
+ * console.log(isUint32Array([])) // false
+ * console.log(isUint32Array(1)) // false
+ * ```
+ */
+function isUint32Array(input) {
+    return typeOf(input) === 'uint32array';
+}
+/**
+ * # 检测 `input` 是否是 `float32Array` 类型
+ *
+ * @param input - 待检测的数据，任意类型
+ * @returns 返回 `true` 则说明该数据 `input` 类型为 `Float32Array` ，且在 Typescript 中进行类型收缩
+ * @example
+ *
+ * ```ts
+ * import  { isFloat32Array } from '@mudbean/is';
+ *
+ * console.log(isFloat32Array(new Float32Array())) // true
+ *
+ * console.log(isFloat32Array({})) // false
+ * console.log(isFloat32Array([])) // false
+ * console.log(isFloat32Array(1)) // false
+ * ```
+ */
+function isFloat32Array(input) {
+    return typeOf(input) === 'float32array';
+}
+/**
+ * # 检测 `input` 是否是 `float64Array` 类型
+ *
+ * @param input - 待检测的数据，任意类型
+ * @returns 返回 `true` 则说明该数据 `input` 类型为 `Float64Array` ，且在 Typescript 中进行类型收缩
+ * @example
+ *
+ * ```ts
+ * import  { isFloat64Array } from '@mudbean/is';
+ *
+ * console.log(isFloat64Array(new Float64Array())) // true
+ *
+ * console.log(isFloat64Array({})) // false
+ * console.log(isFloat64Array([])) // false
+ * console.log(isFloat64Array(1)) // false
+ * ```
+ */
+function isFloat64Array(input) {
+    return typeOf(input) === 'float64array';
+}
+/**
+ * # 检测 `input` 是否是 `sharedArrayBuffer` 类型
+ *
+ * @param input - 待检测的数据，任意类型
+ * @returns 返回 `true` 则说明该数据 `input` 类型为 `SharedArrayBuffer` ，且在 Typescript 中进行类型收缩
+ * @example
+ *
+ * ```ts
+ * import  { isSharedArrayBuffer } from '@mudbean/is';
+ *
+ * console.log(isSharedArrayBuffer(new SharedArrayBuffer(8))) // true
+ *
+ * console.log(isSharedArrayBuffer({})) // false
+ * ```
+ */
+function isSharedArrayBuffer(input) {
+    return typeOf(input) === 'sharedarraybuffer';
+}
+/**
+ * # 检测 `input` 是否是 `uint8ClampedArray` 类型
+ *
+ * @param input - 待检测的数据，任意类型
+ * @returns 返回 `true` 则说明该数据 `input` 类型为 `Uint8ClampedArray` ，且在 Typescript 中进行类型收缩
+ * @example
+ *
+ * ```ts
+ * import  { isUint8ClampedArray } from '@mudbean/is';
+ *
+ * console.log(isUint8ClampedArray(new Uint8ClampedArray())) // true
+ *
+ * console.log(isUint8ClampedArray({})) // false
+ * console.log(isUint8ClampedArray([])) // false
+ * console.log(isUint8ClampedArray(1)) // false
+ * ```
+ */
+function isUint8ClampedArray(input) {
+    return typeOf(input) === 'uint8clampedarray';
+}
+
+export { isArray, isArrayBuffer, isBigInt64Array, isBigUint64Array, isEmptyArray, isFloat32Array, isFloat64Array, isInt16Array, isInt8Array, isSet, isSharedArrayBuffer, isUint16Array, isUint32Array, isUint8Array, isUint8ClampedArray, isWeakSet };