@jblib/is 0.0.2 → 0.0.4

package/dist/is-plain-object.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-plain-object.d.ts","names":[],"sources":["../src/is-plain-object.ts"],"mappings":";;;;;;;;;;;;;;;;;;cAiBM,aAAA,GAAiB,CAAA,cAAa,CAAA,IAAK,MAAA,CAAO,WAAA"}

package/dist/is-plain-object.js

@@ -0,0 +1,27 @@
+//#region src/is-plain-object.ts
+/**
+* isPlainObject checks if a value is a plain object, that is,
+* an object created by the Object constructor or with a null prototype.
+*
+* @param v value to check.
+* @returns {v is Record<PropertyKey, unknown>} returns true if the value is a plain object or otherwise false.
+*
+* @example
+* ```ts
+* isPlainObject({}) // true
+* isPlainObject(Object.create(null)) // true
+* isPlainObject([]) // false
+* isPlainObject(null) // false
+* isPlainObject('hello') // false
+* isPlainObject(42) // false
+* ```
+*/
+const isPlainObject = (v) => {
+	if (typeof v !== "object" || v === null) return false;
+	const proto = Object.getPrototypeOf(v);
+	return proto === Object.prototype || proto === null;
+};
+
+//#endregion
+export { isPlainObject };
+//# sourceMappingURL=is-plain-object.js.map

package/dist/is-plain-object.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-plain-object.js","names":[],"sources":["../src/is-plain-object.ts"],"sourcesContent":["/**\n * isPlainObject checks if a value is a plain object, that is,\n * an object created by the Object constructor or with a null prototype.\n *\n * @param v value to check.\n * @returns {v is Record<PropertyKey, unknown>} returns true if the value is a plain object or otherwise false.\n *\n * @example\n * ```ts\n * isPlainObject({}) // true\n * isPlainObject(Object.create(null)) // true\n * isPlainObject([]) // false\n * isPlainObject(null) // false\n * isPlainObject('hello') // false\n * isPlainObject(42) // false\n * ```\n */\nconst isPlainObject = (v: unknown): v is Record<PropertyKey, unknown> => {\n  if (typeof v !== 'object' || v === null) {\n    return false\n  }\n\n  const proto = Object.getPrototypeOf(v) as unknown\n\n  return proto === Object.prototype || proto === null\n}\n\nexport { isPlainObject }\n"],"mappings":";;;;;;;;;;;;;;;;;;AAiBA,MAAM,iBAAiB,MAAkD;AACvE,KAAI,OAAO,MAAM,YAAY,MAAM,KACjC,QAAO;CAGT,MAAM,QAAQ,OAAO,eAAe,EAAE;AAEtC,QAAO,UAAU,OAAO,aAAa,UAAU"}

package/dist/is-primitive.d.ts

@@ -0,0 +1,27 @@
+//#region src/is-primitive.d.ts
+/**
+ * Primitive type represents the primitive values.
+ */
+type Primitive = string | number | boolean | bigint | symbol | null | undefined;
+/**
+ * isPrimitive checks if a value is a primitive.
+ *
+ * @param v value to check.
+ * @returns {v is Primitive} returns true if the value is a primitive or otherwise false.
+ *
+ * @example
+ * ```ts
+ * isPrimitive(42) // true
+ * isPrimitive('hello') // true
+ * isPrimitive(true) // true
+ * isPrimitive(null) // true
+ * isPrimitive(undefined) // true
+ * isPrimitive({}) // false
+ * isPrimitive([]) // false
+ * isPrimitive(() => {}) // false
+ * ```
+ */
+declare const isPrimitive: (v: unknown) => v is Primitive;
+//#endregion
+export { isPrimitive };
+//# sourceMappingURL=is-primitive.d.ts.map

package/dist/is-primitive.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-primitive.d.ts","names":[],"sources":["../src/is-primitive.ts"],"mappings":";;;;KAGK,SAAA;;;AAAS;;;;;;;;;;;;;;;;cAoBR,WAAA,GAAe,CAAA,cAAa,CAAA,IAAK,SAAA"}

package/dist/is-primitive.js

@@ -0,0 +1,24 @@
+//#region src/is-primitive.ts
+/**
+* isPrimitive checks if a value is a primitive.
+*
+* @param v value to check.
+* @returns {v is Primitive} returns true if the value is a primitive or otherwise false.
+*
+* @example
+* ```ts
+* isPrimitive(42) // true
+* isPrimitive('hello') // true
+* isPrimitive(true) // true
+* isPrimitive(null) // true
+* isPrimitive(undefined) // true
+* isPrimitive({}) // false
+* isPrimitive([]) // false
+* isPrimitive(() => {}) // false
+* ```
+*/
+const isPrimitive = (v) => v === null || typeof v !== "object" && typeof v !== "function";
+
+//#endregion
+export { isPrimitive };
+//# sourceMappingURL=is-primitive.js.map

package/dist/is-primitive.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-primitive.js","names":[],"sources":["../src/is-primitive.ts"],"sourcesContent":["/**\n * Primitive type represents the primitive values.\n */\ntype Primitive = string | number | boolean | bigint | symbol | null | undefined\n\n/**\n * isPrimitive checks if a value is a primitive.\n *\n * @param v value to check.\n * @returns {v is Primitive} returns true if the value is a primitive or otherwise false.\n *\n * @example\n * ```ts\n * isPrimitive(42) // true\n * isPrimitive('hello') // true\n * isPrimitive(true) // true\n * isPrimitive(null) // true\n * isPrimitive(undefined) // true\n * isPrimitive({}) // false\n * isPrimitive([]) // false\n * isPrimitive(() => {}) // false\n * ```\n */\nconst isPrimitive = (v: unknown): v is Primitive => v === null || (typeof v !== 'object' && typeof v !== 'function')\n\nexport { isPrimitive }\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAuBA,MAAM,eAAe,MAA+B,MAAM,QAAS,OAAO,MAAM,YAAY,OAAO,MAAM"}

package/dist/is-string.d.ts

@@ -1,9 +1,16 @@
 //#region src/is-string.d.ts
 /**
- * Checks if a value is a string.
+ * isString checks if the provided value is a string.
  *
- * @param v value to check
- * @returns boolean indicating if the value is a string
+ * @param v value to check.
+ * @returns {v is string} returns true if v is a string or otherwise false.
+ *
+ * @example
+ * ```ts
+ * isString('hello') // true
+ * isString(123) // false
+ * isString({}) // false
+ * ```
  */
 declare const isString: (v: unknown) => v is string;
 //#endregion

package/dist/is-string.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"is-string.d.ts","names":[],"sources":["../src/is-string.ts"],"mappings":";;;;;;;cAMM,QAAA,GAAY,CAAA,cAAa,CAAA"}
+{"version":3,"file":"is-string.d.ts","names":[],"sources":["../src/is-string.ts"],"mappings":";;;;;;;;;;;;;;cAaM,QAAA,GAAY,CAAA,cAAa,CAAA"}

package/dist/is-string.js

@@ -1,9 +1,16 @@
 //#region src/is-string.ts
 /**
-* Checks if a value is a string.
+* isString checks if the provided value is a string.
 *
-* @param v value to check
-* @returns boolean indicating if the value is a string
+* @param v value to check.
+* @returns {v is string} returns true if v is a string or otherwise false.
+*
+* @example
+* ```ts
+* isString('hello') // true
+* isString(123) // false
+* isString({}) // false
+* ```
 */
 const isString = (v) => typeof v === "string";
 

package/dist/is-string.js.map

@@ -1 +1 @@
-{"version":3,"file":"is-string.js","names":[],"sources":["../src/is-string.ts"],"sourcesContent":["/**\n * Checks if a value is a string.\n *\n * @param v value to check\n * @returns boolean indicating if the value is a string\n */\nconst isString = (v: unknown): v is string => typeof v === 'string'\n\nexport { isString }\n"],"mappings":";;;;;;;AAMA,MAAM,YAAY,MAA4B,OAAO,MAAM"}
+{"version":3,"file":"is-string.js","names":[],"sources":["../src/is-string.ts"],"sourcesContent":["/**\n * isString checks if the provided value is a string.\n *\n * @param v value to check.\n * @returns {v is string} returns true if v is a string or otherwise false.\n *\n * @example\n * ```ts\n * isString('hello') // true\n * isString(123) // false\n * isString({}) // false\n * ```\n */\nconst isString = (v: unknown): v is string => typeof v === 'string'\n\nexport { isString }\n"],"mappings":";;;;;;;;;;;;;;AAaA,MAAM,YAAY,MAA4B,OAAO,MAAM"}

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "@jblib/is",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "description": "is, condition checks",
   "type": "module",
   "devDependencies": {
-    "vitest": "^4.1.5",
-    "typescript": "^6.0.3",
     "prettier": "^3.8.3",
     "tsdown": "^0.21.10",
-    "@jblib/eslint": "0.0.1"
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.5",
+    "@jblib/eslint": "0.0.4"
   },
   "keywords": [
     "is"

package/src/index.ts

@@ -1,4 +1,14 @@
-import { isNumber } from './is-number.js'
-import { isString } from './is-string.js'
-
-export { isNumber, isString }
+export { isArray } from './is-array.js'
+export { isBoolean } from './is-boolean.js'
+export { isDate } from './is-date.js'
+export { isDefined } from './is-defined.js'
+export { isEmptyObject } from './is-empty-object.js'
+export { isError } from './is-error.js'
+export { isFunction } from './is-function.js'
+export { isNil } from './is-nil.js'
+export { isNonEmptyArray } from './is-non-empty-array.js'
+export { isNumber } from './is-number.js'
+export { isObject } from './is-object.js'
+export { isPlainObject } from './is-plain-object.js'
+export { isPrimitive } from './is-primitive.js'
+export { isString } from './is-string.js'

package/src/is-array.spec.ts

@@ -0,0 +1,18 @@
+import { describe, expect, it } from 'vitest'
+
+import { isArray } from './is-array.js'
+
+describe('is array', () => {
+  it('should return true for arrays', () => {
+    expect(isArray([])).toBe(true)
+    expect(isArray([1, 2, 3])).toBe(true)
+  })
+
+  it('should return false for non-arrays', () => {
+    expect(isArray('hello')).toBe(false)
+    expect(isArray({})).toBe(false)
+    expect(isArray(123)).toBe(false)
+    expect(isArray(null)).toBe(false)
+    expect(isArray(undefined)).toBe(false)
+  })
+})

package/src/is-array.ts

@@ -0,0 +1,19 @@
+/**
+ * isArray checks if the provided value is an array.
+ *
+ * @param v value to check.
+ * @returns {v is unknown[]} returns true if the value is an array or otherwise false.
+ *
+ * @example
+ * ```ts
+ * isArray([]) // true
+ * isArray([1, 2, 3]) // true
+ * isArray('hello') // false
+ * isArray({}) // false
+ * isArray(123) // false
+ * isArray(undefined) // false
+ * ```
+ */
+const isArray = (v: unknown): v is unknown[] => Array.isArray(v)
+
+export { isArray }

package/src/is-boolean.spec.ts

@@ -0,0 +1,18 @@
+import { describe, expect, it } from 'vitest'
+
+import { isBoolean } from './is-boolean.js'
+
+describe('is boolean', () => {
+  it('should return true for booleans', () => {
+    expect(isBoolean(true)).toBe(true)
+    expect(isBoolean(false)).toBe(true)
+  })
+
+  it('should return false for non-booleans', () => {
+    expect(isBoolean('hello')).toBe(false)
+    expect(isBoolean({})).toBe(false)
+    expect(isBoolean(123)).toBe(false)
+    expect(isBoolean(null)).toBe(false)
+    expect(isBoolean(undefined)).toBe(false)
+  })
+})

package/src/is-boolean.ts

@@ -0,0 +1,19 @@
+/**
+ * isBoolean checks if a value is a boolean.
+ *
+ * @param v value to check.
+ * @returns {v is boolean} returns true if the value is a boolean or otherwise false.
+ *
+ * @example
+ * ```ts
+ * isBoolean(true) // true
+ * isBoolean(false) // true
+ * isBoolean('hello') // false
+ * isBoolean(42) // false
+ * isBoolean(null) // false
+ * isBoolean(undefined) // false
+ * ```
+ */
+const isBoolean = (v: unknown): v is boolean => typeof v === 'boolean'
+
+export { isBoolean }

package/src/is-date.spec.ts

@@ -0,0 +1,21 @@
+import { describe, expect, it } from 'vitest'
+
+import { isDate } from './is-date.js'
+
+describe('is date', () => {
+  it('should return true for valid dates', () => {
+    expect(isDate(new Date())).toBe(true)
+  })
+
+  it('should return false for invalid dates', () => {
+    expect(isDate(new Date('invalid date'))).toBe(false)
+  })
+
+  it('should return false for non-date values', () => {
+    expect(isDate('2022-01-01')).toBe(false)
+    expect(isDate(1640995200000)).toBe(false)
+    expect(isDate({})).toBe(false)
+    expect(isDate(null)).toBe(false)
+    expect(isDate(undefined)).toBe(false)
+  })
+})

package/src/is-date.ts

@@ -0,0 +1,19 @@
+/**
+ * isDate checks if the value is an instance of Date and is a valid date.
+ *
+ * @param v value to check.
+ * @returns {v instanceof Date} returns true if the value is an instance of Date and is a valid date or otherwise false.
+ *
+ * @example
+ * ```ts
+ * isDate(new Date()) // true
+ * isDate(new Date('invalid date')) // false
+ * isDate('2022-01-01') // false
+ * isDate(1640995200000) // false
+ * isDate(null) // false
+ * isDate(undefined) // false
+ * ```
+ */
+const isDate = (v: unknown): v is Date => v instanceof Date && !isNaN(v.getTime())
+
+export { isDate }

package/src/is-defined.spec.ts

@@ -0,0 +1,15 @@
+import { describe, expect, it } from 'vitest'
+
+import { isDefined } from './is-defined.js'
+
+describe('is defined', () => {
+  it('should return true for defined values', () => {
+    expect(isDefined(42)).toBe(true)
+    expect(isDefined('hello')).toBe(true)
+  })
+
+  it('should return false for null or undefined', () => {
+    expect(isDefined(null)).toBe(false)
+    expect(isDefined(undefined)).toBe(false)
+  })
+})

package/src/is-defined.ts

@@ -0,0 +1,17 @@
+/**
+ * isDefined checks if a value is not null or undefined.
+ *
+ * @param v value to check.
+ * @returns {v is T} returns true if the value is defined (not null or undefined) or otherwise false.
+ *
+ * @example
+ * ```ts
+ * isDefined(42) // true
+ * isDefined('hello') // true
+ * isDefined(null) // false
+ * isDefined(undefined) // false
+ * ```
+ */
+const isDefined = <T>(v: T | null | undefined): v is T => v !== null && v !== undefined
+
+export { isDefined }

package/src/is-empty-object.spec.ts

@@ -0,0 +1,25 @@
+import { describe, expect, it } from 'vitest'
+
+import { isEmptyObject } from './is-empty-object.js'
+
+describe('is empty object', () => {
+  it('should return true for empty objects', () => {
+    expect(isEmptyObject({})).toBe(true)
+    expect(isEmptyObject(Object.create(null))).toBe(true)
+  })
+
+  it('should return false for non-empty objects', () => {
+    expect(
+      isEmptyObject({
+        a: 1,
+      }),
+    ).toBe(false)
+  })
+
+  it('should return false for non-object values', () => {
+    expect(isEmptyObject([])).toBe(false)
+    expect(isEmptyObject(null)).toBe(false)
+    expect(isEmptyObject('hello')).toBe(false)
+    expect(isEmptyObject(42)).toBe(false)
+  })
+})

package/src/is-empty-object.ts

@@ -0,0 +1,24 @@
+import { isPlainObject } from './is-plain-object.js'
+
+/**
+ * isEmptyObject checks if a value is an empty object, that is,
+ * a plain object with no own properties.
+ *
+ * @param v value to check.
+ * @returns {v is Record<PropertyKey, never>} returns true if the value is an empty object or otherwise false.
+ *
+ * @example
+ * ```ts
+ * isEmptyObject({}) // true
+ * isEmptyObject(Object.create(null)) // true
+ * isEmptyObject({ a: 1 }) // false
+ * isEmptyObject([]) // false
+ * isEmptyObject(null) // false
+ * isEmptyObject('hello') // false
+ * isEmptyObject(42) // false
+ * ```
+ */
+const isEmptyObject = (v: unknown): v is Record<PropertyKey, never> =>
+  isPlainObject(v) && Reflect.ownKeys(v).length === 0
+
+export { isEmptyObject }

package/src/is-error.spec.ts

@@ -0,0 +1,19 @@
+import { describe, expect, it } from 'vitest'
+
+import { isError } from './is-error.js'
+
+describe('is error', () => {
+  it('should return true for errors', () => {
+    expect(isError(new Error())).toBe(true)
+    expect(isError(new Error('error message'))).toBe(true)
+  })
+
+  it('should return false for non-errors', () => {
+    expect(isError('hello')).toBe(false)
+    expect(isError({})).toBe(false)
+    expect(isError(123)).toBe(false)
+    expect(isError(null)).toBe(false)
+    expect(isError(undefined)).toBe(false)
+    expect(isError([])).toBe(false)
+  })
+})

package/src/is-error.ts

@@ -0,0 +1,18 @@
+/**
+ * isError checks if the value is an instance of Error.
+ *
+ * @param v value to check.
+ * @returns {v is Error} returns true if the value is an instance of Error or otherwise false.
+ *
+ * @example
+ * ```ts
+ * isError(new Error()) // true
+ * isError('hello') // false
+ * isError({}) // false
+ * isError(123) // false
+ * isError(null) // false
+ * ```
+ */
+const isError = (v: unknown): v is Error => v instanceof Error
+
+export { isError }

package/src/is-function.spec.ts

@@ -0,0 +1,35 @@
+import { describe, expect, it } from 'vitest'
+
+import { isFunction } from './is-function.js'
+
+describe('is function', () => {
+  it('should return true for functions', () => {
+    expect(
+      isFunction(() => {
+        void 0
+      }),
+    ).toBe(true)
+
+    expect(
+      isFunction(function () {
+        void 0
+      }),
+    ).toBe(true)
+
+    expect(
+      // eslint-disable-next-line @typescript-eslint/require-await
+      isFunction(async function () {
+        void 0
+      }),
+    ).toBe(true)
+  })
+
+  it('should return false for non-functions', () => {
+    expect(isFunction('hello')).toBe(false)
+    expect(isFunction({})).toBe(false)
+    expect(isFunction(123)).toBe(false)
+    expect(isFunction(null)).toBe(false)
+    expect(isFunction(undefined)).toBe(false)
+    expect(isFunction([])).toBe(false)
+  })
+})

package/src/is-function.ts

@@ -0,0 +1,18 @@
+/**
+ * isFunction checks if the provided value is a function.
+ *
+ * @param v value to check.
+ * @returns {v is (...args: unknown[]) => unknown} returns true if v is a function or otherwise false.
+ *
+ * @example
+ * ```ts
+ * isFunction(() => {}) // true
+ * isFunction(function() {}) // true
+ * isFunction(async function() {}) // true
+ * isFunction('hello') // false
+ * isFunction({}) // false
+ * ```
+ */
+const isFunction = (v: unknown): v is (...args: unknown[]) => unknown => typeof v === 'function'
+
+export { isFunction }

package/src/is-nil.spec.ts

@@ -0,0 +1,17 @@
+import { describe, expect, it } from 'vitest'
+
+import { isNil } from './is-nil.js'
+
+describe('is nil', () => {
+  it('should return true for null and undefined', () => {
+    expect(isNil(null)).toBe(true)
+    expect(isNil(undefined)).toBe(true)
+  })
+
+  it('should return false for non-nil values', () => {
+    expect(isNil(42)).toBe(false)
+    expect(isNil('hello')).toBe(false)
+    expect(isNil({})).toBe(false)
+    expect(isNil([])).toBe(false)
+  })
+})

package/src/is-nil.ts

@@ -0,0 +1,19 @@
+/**
+ * isNil checks if a value is null or undefined.
+ *
+ * @param v value to check.
+ * @returns {v is null | undefined} returns true if the value is null or undefined or otherwise false.
+ *
+ * @example
+ * ```ts
+ * isNil(null) // true
+ * isNil(undefined) // true
+ * isNil(42) // false
+ * isNil('hello') // false
+ * isNil({}) // false
+ * isNil([]) // false
+ * ```
+ */
+const isNil = (v: unknown): v is null | undefined => v === null || v === undefined
+
+export { isNil }

package/src/is-non-empty-array.spec.ts

@@ -0,0 +1,21 @@
+import { describe, expect, it } from 'vitest'
+
+import { isNonEmptyArray } from './is-non-empty-array.js'
+
+describe('is non empty array', () => {
+  it('should return true for non-empty arrays', () => {
+    expect(isNonEmptyArray([1, 2, 3])).toBe(true)
+  })
+
+  it('should return false for empty arrays', () => {
+    expect(isNonEmptyArray([])).toBe(false)
+  })
+
+  it('should return false for non-arrays', () => {
+    expect(isNonEmptyArray('hello')).toBe(false)
+    expect(isNonEmptyArray({})).toBe(false)
+    expect(isNonEmptyArray(123)).toBe(false)
+    expect(isNonEmptyArray(null)).toBe(false)
+    expect(isNonEmptyArray(undefined)).toBe(false)
+  })
+})

package/src/is-non-empty-array.ts

@@ -0,0 +1,17 @@
+/**
+ * isNonEmptyArray checks if the provided value is an array and contains at least one element.
+ *
+ * @param v value to check.
+ * @returns {v is unknown[]} returns true if v is a non-empty array or otherwise false.
+ *
+ * @example
+ * ```ts
+ * isNonEmptyArray([1, 2, 3]) // true
+ * isNonEmptyArray([]) // false
+ * isNonEmptyArray('hello') // false
+ * isNonEmptyArray({}) // false
+ * ```
+ */
+const isNonEmptyArray = (v: unknown): v is unknown[] => Array.isArray(v) && v.length > 0
+
+export { isNonEmptyArray }

package/src/is-number.ts

@@ -1,8 +1,15 @@
 /**
- * Checks if a value is a number.
+ * isNumber checks if the provided value is a number.
  *
- * @param v value to check
- * @returns boolean indicating if the value is a number
+ * @param v value to check.
+ * @returns {v is number} returns true if v is a number or otherwise false.
+ *
+ * @example
+ * ```ts
+ * isNumber(123) // true
+ * isNumber('hello') // false
+ * isNumber({}) // false
+ * ```
  */
 const isNumber = (v: unknown): v is number => typeof v === 'number'
 

package/src/is-object.spec.ts

@@ -0,0 +1,17 @@
+import { describe, expect, it } from 'vitest'
+
+import { isObject } from './is-object.js'
+
+describe('is object', () => {
+  it('should return true for objects', () => {
+    expect(isObject({})).toBe(true)
+    expect(isObject([])).toBe(true)
+  })
+
+  it('should return false for non-objects', () => {
+    expect(isObject('hello')).toBe(false)
+    expect(isObject(123)).toBe(false)
+    expect(isObject(null)).toBe(false)
+    expect(isObject(undefined)).toBe(false)
+  })
+})

package/src/is-object.ts

@@ -0,0 +1,18 @@
+/**
+ * isObject checks if the value is an object.
+ *
+ * @param v value to check.
+ * @returns {v is object} returns true if the value is an object or otherwise false.
+ *
+ * @example
+ * ```ts
+ * isObject({}) // true
+ * isObject([]) // true
+ * isObject(null) // false
+ * isObject('hello') // false
+ * isObject(42) // false
+ * ```
+ */
+const isObject = (v: unknown): v is object => typeof v === 'object' && v !== null
+
+export { isObject }

package/src/is-plain-object.spec.ts

@@ -0,0 +1,18 @@
+import { describe, expect, it } from 'vitest'
+
+import { isPlainObject } from './is-plain-object.js'
+
+describe('is plain object', () => {
+  it('should return true for plain objects', () => {
+    expect(isPlainObject({})).toBe(true)
+    expect(isPlainObject(Object.create(null))).toBe(true)
+  })
+
+  it('should return false for non-plain objects', () => {
+    expect(isPlainObject([])).toBe(false)
+    expect(isPlainObject(null)).toBe(false)
+    expect(isPlainObject(undefined)).toBe(false)
+    expect(isPlainObject('hello')).toBe(false)
+    expect(isPlainObject(42)).toBe(false)
+  })
+})