@mudbean/is 2.0.2

package/es/types/isNumber.d.ts

@@ -0,0 +1,125 @@
+/**
+ * 检测 Javascript 数据类型工具之: number
+ */
+/**
+ *
+ * 检测 `input` 是否是 `number` 类型
+ *
+ * @param input - 待检测的数据，任意类型
+ * @returns 返回 `true` 则说明该数据 `input` 类型为 `number` ，且在 Typescript 中进行类型收缩
+ * @example
+ *
+ * ```ts
+ * import { isNumber } from '@mudbean/is';
+ *
+ * isNumber(123); // true
+ *
+ * isNumber('123'); // false
+ * ```
+ */
+export declare function isNumber(input: any): input is number;
+/**
+ *
+ * 检测 `input` 是否是 `BigInt` 类型
+ *
+ * @param input - 待检测的数据，任意类型
+ * @returns 返回 `true` 则说明该数据 `input` 类型为 `bigint` ，且在 Typescript 中进行类型收缩
+ * @example
+ *
+ * ```ts
+ * import { isBigInt } from '@mudbean/is';
+ *
+ * isBigInt(123n); // true
+ *
+ * isBigInt('123'); // false
+ * isBigInt(123); // false
+ * isBigInt(true); // false
+ * ```
+ */
+export declare function isBigInt(input: any): input is bigint;
+/**
+ *
+ * 检测 `input` 是否是 `NaN` 类型
+ *
+ * @param input - 待检测的数据，任意类型
+ * @returns 返回 `true` 则说明该数据 `input` 类型为 `NaN` ，且在 Typescript 中进行类型收缩
+ * @example
+ *
+ * ```ts
+ * import { isNaN } from '@mudbean/is';
+ *
+ * isNaN(NaN); // true
+ *
+ * isNaN('123'); // false
+ * ```
+ */
+export declare function isNaN(input: any): input is typeof NaN;
+/**
+ *
+ * 是否为正整数
+ *
+ * @param input - 待检测的数据，任意类型
+ * @returns 返回 `true` 则说明该数据 `input` 类型为正整数
+ * @example
+ *
+ * ```ts
+ * import { isPositiveInteger } from '@mudbean/is';
+ *
+ * isPositiveInteger(123); // true
+ * isPositiveInteger(1); // true
+ *
+ * isPositiveInteger(0); // false
+ * isPositiveInteger(-1); // true
+ * isPositiveInteger(false); // false
+ * isPositiveInteger(Infinity); // false
+ * isPositiveInteger('123'); // false
+ * isPositiveInteger(NaN); // false
+ * ```
+ */
+export declare function isPositiveInteger(input: any): input is number;
+/**
+ *
+ * 是否为负整数
+ *
+ * @param input - 待检测的数据，任意类型
+ * @returns 返回 `true` 则说明该数据 `input` 类型为负整数
+ * @example
+ *
+ * ```ts
+ * import { isPositiveInteger } from '@mudbean/is';
+ *
+ * isPositiveInteger(-123); // true
+ * isPositiveInteger(-1); // true
+ *
+ * isPositiveInteger(0); // false
+ * isPositiveInteger(1); // true
+ * isPositiveInteger(false); // false
+ * isPositiveInteger(Infinity); // false
+ * isPositiveInteger('123'); // false
+ * isPositiveInteger(NaN); // false
+ * ```
+ */
+export declare function isNegativeInteger(input: any): input is number;
+/**
+ *
+ * 是否为正整数
+ *
+ * @param input - 待检测的数据，任意类型
+ * @returns 返回 `true` 则说明该数据 `input` 类型为 0
+ * @example
+ *
+ * ```ts
+ * import { isZero } from '@mudbean/is';
+ *
+ * isZero(0); // true
+ *
+ *
+ * isZero(123); // false
+ * isZero(1); // false
+ * isZero(false); // false
+ * isZero(Infinity); // false
+ * isZero('123'); // false
+ * isZero(NaN); // false
+ * ```
+ */
+export declare function isZero(input: any): input is 0;

package/es/types/isObject.d.ts

@@ -0,0 +1,174 @@
+/**
+ * # 检测 `input` 是否是类型 `plain object` （自定义的对象）
+ *
+ * @param input - 待检测的数据，任意类型
+ * @returns 返回 `true` 则说明该数据 `input` 类型为 `object` ，且在 Typescript 中进行类型收缩
+ * @example
+ *
+ * ```ts
+ * import { isPlainObject } from '@mudbean/is';
+ *
+ * console.log(isPlainObject({})); // true
+ *
+ * // false ( Array is not an plain object )
+ * console.log(isPlainObject([]));
+ * // false ( Date is not an plain object )
+ * console.log(isPlainObject(new Date()));
+ * // false ( Map is not an plain object )
+ * console.log(isPlainObject(new Map()));
+ * ```
+ */
+export declare function isPlainObject<T extends object>(input: any): input is T;
+/**
+ * # 检测 `input` 是否是否是一个没有自己私有键的对象
+ *
+ * @param input - 待检测的数据，任意类型
+ * @returns 是否为空的对象。不包含任何属性，包括 Symbol 或是不可被枚举的属性
+ * @example
+ *
+ * ```ts
+ * import { isEmptyObject } from '@mudbean/is';
+ *
+ * const a = new Object();
+ *
+ * console.log(isEmptyObject(a)); // true
+ * console.log(Reflect.ownKeys(input).length); // 0
+ * console.log(Object.keys(a).length); // 0
+ * console.log(Object.getOwnPropertyNames(a).length); // 0
+ * console.log(Object.getOwnPropertySymbols(a).length); // 0
+ *
+ * Object.defineProperties(a, {
+ *     a: {
+ *       value: 10,
+ *       enumerable: false,
+ *       writable: false,
+ *       configurable: false,
+ *     },
+ * });
+ *
+ * console.log(isEmptyObject(a)); // false
+ * console.log(Reflect.ownKeys(input).length); // 1
+ * console.log(Object.keys(a).length); // 0
+ * console.log(Object.getOwnPropertyNames(a).length); // 1
+ * console.log(Object.getOwnPropertySymbols(a).length); // 0
+ *
+ * const b = Symbol('private proto');
+ *
+ * a[b] = b;
+ *
+ * console.log(isEmptyObject(a)); // false
+ * console.log(Reflect.ownKeys(input).length); // 2
+ * console.log(Object.keys(a).length); // 0
+ * console.log(Object.getOwnPropertyNames(a).length); // 1
+ * console.log(Object.getOwnPropertySymbols(a).length); // 1
+ *
+ * delete a[a];
+ *
+ * console.log(isEmptyObject(a)); // false
+ * console.log(Reflect.ownKeys(input).length); // 1
+ * console.log(Object.keys(a).length); // 0
+ * console.log(Object.getOwnPropertyNames(a).length); // 0
+ * console.log(Object.getOwnPropertySymbols(a).length); // 1
+ *
+ *
+ * delete a[b];
+ *
+ * console.log(isEmptyObject(a)); // true
+ * console.log(Reflect.ownKeys(input).length); // 0
+ * console.log(Object.keys(a).length); // 0
+ * console.log(Object.getOwnPropertyNames(a).length); // 0
+ * console.log(Object.getOwnPropertySymbols(a).length); // 0
+ *
+ * ```
+ */
+export declare function isEmptyObject(input: any): input is Record<string, never>;
+/**
+ * #  检测 data 是否是  类型{@link Date}
+ *
+ * @param input - 待检测的数据，任意类型
+ * @returns 返回 `true` 则说明该数据 `input` 类型为 `Date` ，且在 Typescript 中进行类型收缩
+ * @example
+ *
+ * ```ts
+ * import { isDate } from '@mudbean/is';
+ *
+ * console.log(isDate(new Date())); // true
+ * console.log(isDate(new Date(0))); // true
+ * console.log(isDate(new Date('2025-03-19'))); // true
+ * console.log(isDate(new Date(NaN))); // true
+ * console.log(isDate(new Date(undefined))); // true
+ * console.log(isDate(new Date(null))); // true
+ *
+ * // false ( Number 不是 Date )
+ * console.log(isDate(1));
+ * // false ( String 不是 Date )
+ * console.log(isDate('1'));
+ * ```
+ */
+export declare function isDate(input: any): input is Date;
+/**
+ *
+ * 检测 `input` 是否是 `DataView` 类型
+ *
+ * @param input - 待检测的数据，任意类型
+ * @returns 返回 `true` 则说明该数据 `input` 类型为 `DataView` ，且在 Typescript 中进行类型收缩
+ * @example
+ *
+ * ```ts
+ * import { isDataView } from '@mudbean/is';
+ *
+ * console.log(isDataView(new DataView(new ArrayBuffer(8)))); // true
+ *
+ * // false (ArrayBuffer 不是 DataView)
+ * console.log(isDataView(new ArrayBuffer(8)));
+ * ```
+ */
+export declare function isDataView<T extends ArrayBufferLike = ArrayBufferLike>(input: any): input is DataView<T>;
+/**
+ *
+ * 检测 `input` 是否是 `Map` 类型
+ *
+ * @param input - 待检测的数据，任意类型
+ * @returns 返回 `true` 则说明该数据 `input` 类型为 `Map` ，且在 Typescript 中进行类型收缩
+ * @example
+ *
+ * ```ts
+ * import { isMap } from '@mudbean/is';
+ *
+ * console.log(isMap(new Map())); // true
+ *
+ * // false (WeakMap 不是 Map)
+ * console.log(isMap(new WeakMap()));
+ * // false (Set 不是 Map)
+ * console.log(isMap(new Set()));
+ * // false (WeakSet 不是 Map)
+ * console.log(isMap(new WeakSet()));
+ * // false (Array 不是 Map)
+ * console.log(isMap(new Array()));
+ * ```
+ */
+export declare function isMap<K extends string, V = any>(input: any): input is Map<K, V>;
+/**
+ *
+ * 检测 `input` 是否是 `WeakMap` 类型
+ *
+ * @param input - 待检测的数据，任意类型
+ * @returns 返回 `true` 则说明该数据 `input` 类型为 `WeakMap` ，且在 Typescript 中进行类型收缩
+ * @example
+ *
+ * ```ts
+ * import { isWeakMap } from '@mudbean/is';
+ *
+ * console.log(isWeakMap(new WeakMap())); // true
+ *
+ * // false (Map is not WeakMap)
+ * console.log(isWeakMap(new Map()));
+ * // false (Set is not WeakMap)
+ * console.log(isWeakMap(new Set()));
+ * // false (WeakSet is not WeakMap)
+ * console.log(isWeakMap(new WeakSet()));
+ * // false (Array is not WeakMap)
+ * console.log(isWeakMap(new Array()));
+ * ```
+ */
+export declare function isWeakMap(input: any): input is WeakMap<object, any>;

package/es/types/isString.d.ts

@@ -0,0 +1,101 @@
+/**
+ * # 当前数据类型是否为 string
+ *
+ * @param input - 待检测的数据，任意类型
+ * @returns 返回 `true` 则说明该数据 `input` 类型为 `string` ，且在 Typescript 中进行类型收缩
+ * @example
+ *
+ * ```ts
+ * import { isString } from '@mudbean/is';
+ *
+ * console.log(isString('hello')); // true
+ *
+ * // false (number 不是 string)
+ * console.log(isString(123));
+ * // false (boolean 不是 string)
+ * console.log(isString(true));
+ * // false (null 不是 string)
+ * console.log(isString(null));
+ * ```
+ */
+export declare function isString(input: any): input is string;
+/**
+ * # 检测 `input` 是否是 `RegExp` 类型
+ *
+ * @param input - 待检测的数据，任意类型
+ * @returns 返回 `true` 则说明该数据 `input` 类型为 `RegExp` ，且在 Typescript 中进行类型收缩
+ * @example
+ *
+ * ```ts
+ * import { isRegExp } from '@mudbean/is';
+ *
+ * console.log(isRegExp(/abc/)); // true
+ * console.log(isRegExp(new RegExp('abc'))); // true
+ *
+ * // false (number 不是 RegExp)
+ * console.log(isRegExp(123));
+ * // false (string 不是 RegExp)
+ * console.log(isRegExp('abc'));
+ * // false (null 不是 RegExp)
+ * console.log(isRegExp(null));
+ * ```
+ */
+export declare function isRegExp(input: any): input is RegExp;
+/**
+ * # 检测 `input` 是否是（绝对）空字符串
+ *
+ * @param input - 待检测的数据，任意类型
+ * @returns 返回 `true` 则说明该数据 `input` 类型为 `string` 且为 空字符串，且在 Typescript 中进行类型收缩
+ *
+ * @example
+ *
+ * ```ts
+ * import { isEmptyString } from '@mudbean/is';
+ *
+ * console.log(isEmptyString('')); // true
+ * const.log(isEmptyString(new String())); // true
+ * const.log(isEmptyString(new String(''))); // true
+ *
+ *
+ * // 以下情况返回 false
+ * console.log(isEmptyString(' ')); // false
+ * console.log(isEmptyString('abc')); // false
+ * // false (number 不是 string)
+ * console.log(isEmptyString(123));
+ * // false (boolean 不是 string)
+ * console.log(isEmptyString(true));
+ * // false (null 不是 string)
+ * console.log(isEmptyString(null));
+ * ```
+ */
+export declare function isEmptyString(input: any): input is '';
+/**
+ * # 检测 `input` 是否是（业务）空字符串
+ *
+ * 业务空字符串：指字符串开头和结尾的空格，以及中间连续的空格，都算作空字符串
+ *
+ * @param input - 待检测的数据，任意类型
+ * @returns 返回 `true` 则说明该数据 `input` 类型为 `string` 且为 业务空字符串，且在 Typescript 中进行类型收缩
+ * @example
+ *
+ * ```ts
+ * import { isBusinessEmptyString } from '@mudbean/is';
+ *
+ * console.log(isBusinessEmptyString('')); // true
+ * console.log(isBusinessEmptyString(' ')); // true
+ * console.log(isBusinessEmptyString('  ')); // true
+ * console.log(isBusinessEmptyString(new String())); // true
+ * console.log(isBusinessEmptyString(new String(''))); // true
+ * console.log(isBusinessEmptyString(new String(' '))); // true
+ *
+ * // 以下情况返回 false
+ * console.log(isBusinessEmptyString('abc')); // false
+ * // false (number 不是 string)
+ * console.log(isBusinessEmptyString(123));
+ * // false (boolean 不是 string)
+ * console.log(isBusinessEmptyString(true));
+ * // false (null 不是 string)
+ * console.log(isBusinessEmptyString(null));
+ * ```
+ */
+export declare function isBusinessEmptyString(input: any): input is '';

package/es/types/isSymbol.d.ts

@@ -0,0 +1,25 @@
+/**
+ * #  检测 `input` 是否是 `Symbol` 类型
+ *
+ * @param input - 待检测的数据，任意类型
+ * @returns 返回 `true` 则说明该数据 `input` 类型为 `symbol` ，且在 Typescript 中进行类型收缩
+ * @example
+ *
+ * ```ts
+ * import { isSymbol } from '@mudbean/is';
+ *
+ * console.log(isSymbol(Symbol('test'))); // true
+ *
+ * // false (string 非 symbol)
+ * console.log(isSymbol('test'));
+ * // false (number 非 symbol)
+ * console.log(isSymbol(123));
+ * // false (boolean 非 symbol)
+ * console.log(isSymbol(true));
+ * // false (null 非 symbol)
+ * console.log(isSymbol(null));
+ * // false (undefined 非 symbol)
+ * console.log(isSymbol(undefined));
+ * ```
+ */
+export declare function isSymbol(input: any): input is symbol;

package/es/types/isType.d.ts

@@ -0,0 +1,77 @@
+/**
+ *  `input` 类型收缩
+ */
+/**
+ * # 给出一个类型 `T` ，以返回值真假来判断 `input` 是否为 `T` 类型
+ *
+ * @param  input 待检测的数据
+ * @returns 返回 `true` 则说明该数据 `input` 类型为 `ReferenceError` ，且在 Typescript 中进行类型收缩
+ * @example
+ *
+ * ```ts
+ * import  { isType } from '@mudbean/is';
+ *
+ * console.log(isType<number>(1)); // true
+ * console.log(isType<string>('1')); // true
+ * ```
+ */
+export declare function isType<T = string>(input: any): input is T;
+/**
+ * # 给出一个类型 `T` ，以返回值真假来判断 `input` 是否为 `T` 类型
+ *
+ * @param  input 待检测的数据
+ * @param  judgingConditions 返回 boolean 来反向确认该值的类型
+ * @returns 返回 `true` 则说明该数据 `input` 类型为 `ReferenceError` ，且在 Typescript 中进行类型收缩
+ * @example
+ *
+ * ```ts
+ * import  { isType } from '@mudbean/is';
+ *
+ * console.log(isType<number>(1, true)); // true
+ * console.log(isType<number>(1, () => true)); // true
+ * console.log(isType<string>(1, false)); // false
+ * console.log(isType<string>(1, () => false)); // false
+ *
+ * console.log(isType<string>('1')); // true
+ * console.log(isType<string>('1', true)); // true
+ * console.log(isType<string>('1', () => true)); // true
+ *
+ * console.log(isType<number>('1', false)); // false
+ * console.log(isType<number>('1', () => false)); // false
+ * // 下面的例子尽然有些画蛇添足，但是在实际使用的时候却是方便的很
+ * console.log(isType<number>(1, (input) => typeof input === 'number' )); // true
+ *
+ * // 譬如 (下面的用法 （需求出自于 \@qqi/table ）)
+ *
+ * type BorderStyle = "dash" | "bold" | "double" | "simple";
+ *
+ * type UnilateralBorder = {
+ *   color: string | undefined;
+ *   style: BorderStyle
+ * }
+ *
+ * type Border = {
+ *   left: UnilateralBorder;
+ *   right: UnilateralBorder;
+ *   top: UnilateralBorder;
+ *   bottom: UnilateralBorder;
+ * }
+ *
+ *
+ * function fn (border: BorderStyle |  UnilateralBorder | Border) {
+ *    if (isType<BorderStyle>(border, input => isString(input))) {
+ *      // 然后这里 `border` 就可以当 `BorderStyle` 使用了
+ *      // 而不是每一次使用都添加上 `as BorderStyle`
+ *    } else if (
+ *      isType<UnilateralBorder>(border, input =>
+ *          isString(input.color) || isString(input.style))) {
+ *      // 然后这里 `border` 就可以当 `UnilateralBorder` 使用了
+ *      // 而不是每一次使用都添加上 `as UnilateralBorder`
+ *      // 更关键的是上面的判断区域中不会报错，即 `input` 类型也是 `UnilateralBorder`
+ *
+ *    }
+ *    ...
+ * }
+ * ```
+ */
+export declare function isType<T = string>(input: any, judgingConditions: boolean | ((input: T) => boolean)): input is T;

package/es/types/typeOf.d.ts

@@ -0,0 +1,29 @@
+/**
+ * 检测 Javascript 数据类型工具
+ */
+import { Typeof } from './types';
+/**
+ *  # 数据类型检测
+ *
+ * @param input - 待检测的数据，任意类型
+ * @returns 检测数据类型的字符串表示（小写字母）
+ * @example
+ * ```ts
+ * import  { typeOf } from '@mudbean/is';
+ *
+ *  console.log(typeOf(1) === 'number'); // true
+ *  console.log(typeOf('1') === 'string'); // true
+ *  console.log(typeOf(null) === 'null'); // true
+ *  console.log(typeOf(undefined) === 'undefined'); // true
+ *  console.log(typeOf(true) === 'boolean'); // true
+ *  console.log(typeOf(Symbol()) === 'symbol');
+ *  console.log(typeOf(new Date()) === 'date');
+ *  console.log(typeOf([]) === 'array');
+ *  console.log(typeOf(new Set()) === 'set');
+ *  console.log(typeOf(new Map()) === 'map');
+ *  console.log(typeOf(new Error()) === 'error');
+ *  console.log(typeOf(new Promise(() => {})) === 'promise');
+ *    ...
+ * ```
+ */
+export declare function typeOf(input: any): Typeof;

package/es/types/types.d.ts

@@ -0,0 +1,4 @@
+/**
+ * # 支持的类型值
+ */
+export type Typeof = 'number' | 'function' | 'string' | 'boolean' | 'object' | 'undefined' | 'null' | 'array' | 'date' | 'set' | 'map' | 'symbol' | 'bigint' | 'bigint64array' | 'biguint64array' | 'regexp' | 'int8array' | 'uint8array' | 'int16array' | 'uint16array' | 'float32array' | 'float64array' | 'int32array' | 'uint32array' | 'weakmap' | 'weakset' | 'generatorfunction' | 'generator' | 'error' | 'evalerror' | 'rangeerror' | 'referenceerror' | 'syntaxerror' | 'typeerror' | 'urierror' | 'aggregateerror' | 'uint8clampedarray' | 'sharedarraybuffer' | 'promise' | 'asyncfunction' | 'dataview' | 'arraybuffer' | 'audiobuffer' | 'intl.collator' | 'intl.datetimeformat' | 'intl.displaynames' | 'intl.listformat' | 'intl.locale' | 'intl.numberformat' | 'intl.pluralrules' | 'intl.relativetimeformat' | 'intl.segmenter';

package/package.json

@@ -0,0 +1,133 @@
+{
+  "name": "@mudbean/is",
+  "type": "module",
+  "version": "2.0.2",
+  "main": "cjs/index.js",
+  "module": "es/index.js",
+  "types": "es/types/index.d.ts",
+  "author": {
+    "name": "泥豆君",
+    "email": "Mr.MudBean@outlook.com",
+    "url": "https://lmssee.com"
+  },
+  "description": "JavaScript/TypeScript 的类型检测工具，支持 TypeScript 类型收缩",
+  "sideEffects": false,
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "license": "MIT",
+  "files": [
+    "cjs",
+    "es",
+    "es/types",
+    "CHANGELOG.md",
+    "README.md",
+    "LICENSE"
+  ],
+  "exports": {
+    ".": {
+      "import": "./es/index.js",
+      "default": "./es/index.js",
+      "require": "./cjs/index.js",
+      "types": "./es/types/index.d.ts"
+    },
+    "./error": {
+      "default": "./es/error.js",
+      "import": "./es/error.js",
+      "require": "./cjs/error.js",
+      "types": "./es/types/error.d.ts"
+    },
+    "./index": {
+      "default": "./es/index.js",
+      "import": "./es/index.js",
+      "require": "./cjs/index.js",
+      "types": "./es/types/index.d.ts"
+    },
+    "./intl": {
+      "default": "./es/intl.js",
+      "import": "./es/intl.js",
+      "require": "./cjs/intl.js",
+      "types": "./es/types/intl.d.ts"
+    },
+    "./isArray": {
+      "default": "./es/isArray.js",
+      "import": "./es/isArray.js",
+      "require": "./cjs/isArray.js",
+      "types": "./es/types/isArray.d.ts"
+    },
+    "./isBoolean": {
+      "default": "./es/isBoolean.js",
+      "import": "./es/isBoolean.js",
+      "require": "./cjs/isBoolean.js",
+      "types": "./es/types/isBoolean.d.ts"
+    },
+    "./isFunction": {
+      "default": "./es/isFunction.js",
+      "import": "./es/isFunction.js",
+      "require": "./cjs/isFunction.js",
+      "types": "./es/types/isFunction.d.ts"
+    },
+    "./isNull": {
+      "default": "./es/isNull.js",
+      "import": "./es/isNull.js",
+      "require": "./cjs/isNull.js",
+      "types": "./es/types/isNull.d.ts"
+    },
+    "./isNumber": {
+      "default": "./es/isNumber.js",
+      "import": "./es/isNumber.js",
+      "require": "./cjs/isNumber.js",
+      "types": "./es/types/isNumber.d.ts"
+    },
+    "./isObject": {
+      "default": "./es/isObject.js",
+      "import": "./es/isObject.js",
+      "require": "./cjs/isObject.js",
+      "types": "./es/types/isObject.d.ts"
+    },
+    "./isString": {
+      "default": "./es/isString.js",
+      "import": "./es/isString.js",
+      "require": "./cjs/isString.js",
+      "types": "./es/types/isString.d.ts"
+    },
+    "./isSymbol": {
+      "default": "./es/isSymbol.js",
+      "import": "./es/isSymbol.js",
+      "require": "./cjs/isSymbol.js",
+      "types": "./es/types/isSymbol.d.ts"
+    },
+    "./isType": {
+      "default": "./es/isType.js",
+      "import": "./es/isType.js",
+      "require": "./cjs/isType.js",
+      "types": "./es/types/isType.d.ts"
+    },
+    "./typeOf": {
+      "default": "./es/typeOf.js",
+      "import": "./es/typeOf.js",
+      "require": "./cjs/typeOf.js",
+      "types": "./es/types/typeOf.d.ts"
+    }
+  },
+  "keywords": [
+    "is",
+    "mudbean",
+    "typeof",
+    "javascript type",
+    "类型检测"
+  ],
+  "homepage": "https://npm.lmssee.com/is",
+  "bugs": {
+    "url": "https://github.com/MrMudBean/is/issues",
+    "email": "Mr.MudBean@outlook.com"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/MrMudBean/is.git"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  }
+}