@magic/types 0.1.14 → 0.1.18

package/README.md

@@ -45,6 +45,8 @@ is.array([]) // true
 ##### functions
 ```javascript
 
+// comparisons
+
 // test a value for multiple types
 is(ele, ...types)
 // alias is.eq, isEq, test
@@ -53,7 +55,12 @@ is(ele, ...types)
 not(ele, ...types)
 // alias is.neq, isNeq, isNot
 
-type comparisons:
+isSameType('string', 'string')
+// alias isSame, is.same, is.sameType
+
+
+// type comparisons:
+
 isArray([]) // true
 // alias isArr, is.array, is.arr
 
@@ -190,6 +197,15 @@ isUpperCase('UPPERCASE') // true
 isLowerCase('lowercase') // true
 // alias is.case.lower, is.isCase.lower
 
+isMergeableObject({}) // true
+// alias is.mergeable, is.mergeableObject, isMergeable
+
+const mod = await import('path/to/file')
+isModule(mod) // true
+// alias is.module
+
+isOwnProp({ test: undefined }, 'test') // true
+// alias isOwnProperty, is.ownProperty, is.ownProp, is.prop
 ```
 
 
@@ -251,5 +267,19 @@ bump required node version to 14.2.0
 * bump required node version to 14.15.4
 * update dependencies
 
-##### 0.1.15 - unreleased
+##### 0.1.15
+deep.equal now does return true for objects that have undefined property values
+
+##### 0.1.16
+* remove circular dependencies
+
+##### 0.1.17
+* add isSameType, isSame, same, sameType
+* update dev dependencies
+
+##### 0.1.18
+* add isModule and isOwnProperty
+* update dependencies
+
+##### 0.1.19 - unreleased
 ...

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "@magic/types",
-  "version": "0.1.14",
+  "version": "0.1.18",
   "author": "Wizards & Witches",
   "homepage": "https://github.com/magic/types",
   "license": "AGPL-3.0",
   "description": "typechecking library",
   "main": "src/index.mjs",
+  "type": "module",
   "scripts": {
     "start": "t",
     "build": "NODE_ENV=production magic build",
@@ -36,11 +37,11 @@
     "@magic-modules/git-badges": "0.0.11",
     "@magic-modules/light-switch": "0.0.10",
     "@magic-modules/no-spy": "0.0.6",
-    "@magic-modules/pre": "0.0.10",
-    "@magic-themes/docs": "0.0.12",
-    "@magic/core": "0.0.101",
-    "@magic/format": "0.0.20",
-    "@magic/test": "0.1.59"
+    "@magic-modules/pre": "0.0.11",
+    "@magic-themes/docs": "0.0.14",
+    "@magic/core": "0.0.133",
+    "@magic/format": "0.0.35",
+    "@magic/test": "0.2.0"
   },
   "keywords": [
     "magic",

package/src/deep/different.mjs

@@ -1,4 +1,4 @@
-import is from '../index.mjs'
+import is from '../lib.mjs'
 
 import equal from './equal.mjs'
 

package/src/deep/equal.mjs

@@ -1,6 +1,6 @@
 // Written by Substack <3
 
-import is from '../index.mjs'
+import is from '../lib.mjs'
 
 export const equal = (a, b) => {
   // curry
@@ -90,6 +90,13 @@ export const equal = (a, b) => {
   let key
   for (let i = ka.length - 1; i >= 0; i--) {
     key = ka[i]
+
+    // in the first line of this function we assume that two undefined values are a bug.
+    // here we have to assume that two undefined properties in an object are intentional.
+    if (is.undefined(a[key])) {
+      return a[key] === b[key]
+    }
+
     if (!equal(a[key], b[key])) {
       return false
     }

package/src/deep/index.mjs

@@ -1,7 +1,20 @@
 import { equal } from './equal.mjs'
 import { different } from './different.mjs'
 
-export default {
-  equal,
-  different,
+export const isDeepEqual = equal
+export const deepEqual = equal
+export const deepEq = equal
+
+export const isDeepDifferent = different
+export const deepDifferent = different
+export const deepDiff = different
+
+export const deep = {
+  isDifferent: different,
+  different: different,
+  diff: different,
+
+  isEqual: equal,
+  equal: equal,
+  eq: equal,
 }

package/src/fns.mjs

@@ -0,0 +1,222 @@
+export const isArray = e => Array.isArray(e)
+
+export const isBoolean = e => typeof e === 'boolean'
+
+export const isDefined = e => typeof e !== 'undefined'
+
+export const isUndefined = e => !isDefined(e)
+
+export const isFunction = e => typeof e === 'function'
+
+export const isAsyncFunction = e => Object.prototype.toString.call(e) === '[object AsyncFunction]'
+
+export const isGeneratorFunction = e =>
+  Object.prototype.toString.call(e) === '[object GeneratorFunction]'
+
+export const isNumber = e => typeof e !== 'object' && e === +e
+
+export const isInteger = e => e === +e && e === (e | 0)
+
+export const isFloat = e => e === +e
+
+export const isObject = e => typeof e === 'object' && !isNull(e)
+
+export const isObjectNative = e => Object.prototype.toString.call(e) === '[object Object]'
+
+export const isMergeableObject = e => isObject(e) && !isDate(e) && !isRegExp(e)
+export const isMergeable = isMergeableObject
+
+export const isString = e => typeof e === 'string'
+
+export const isRGBValue = e => ![e.r, e.g, e.b].some(n => !isNumber(n))
+export const isRGBAValue = e => ![e.r, e.g, e.b, e.a].some(n => !isNumber(n))
+
+export const isRGBAObject = e => isObject(e) && isRGBAValue(e)
+
+export const isRGBObject = e => isObject(e) && isRGBValue(e)
+
+export const hexRegex = /#\b([a-f0-9]{3}|[a-f0-9]{4}|[a-f0-9]{6}|[a-f0-9]{8})\b/i
+export const isHexColor = e => hexRegex.test(e)
+
+export const isHexColor3 = e => /#\b([a-f0-9]{3})\b/i.test(e)
+
+export const isHexColor4 = e => /#\b([a-f0-9]{4})\b/i.test(e)
+
+export const isHexColor6 = e => /#\b([a-f0-9]{6})\b/i.test(e)
+
+export const isHexColor8 = e => /#\b([a-f0-9]{8})\b/i.test(e)
+
+export const isHexAlphaColor = e => /#\b([a-f0-9]{4}|[a-f0-9]{8})\b/i.test(e)
+
+export const isHexAlphaColor4 = e => /#\b([a-f0-9]{4})\b/i.test(e)
+
+export const isHexAlphaColor8 = e => /#\b([a-f0-9]{8})\b/i.test(e)
+
+export const isColor = e => isRGBAObject(e) || isRGBObject(e) || isHexColor(e) || isHexAlphaColor(e)
+
+export const isTruthy = e => !!e
+
+export const isFalsy = e => !e || isEmpty(e)
+
+export const isEmpty = e => {
+  if (isError(e)) {
+    return false
+  } else if (isDate(e)) {
+    return false
+  } else if (isNull(e)) {
+    return true
+  } else if (isUndefined(e)) {
+    return true
+  } else if (isArray(e)) {
+    return isLengthSmaller(e, 1)
+  } else if (isRegExp(e)) {
+    return isLengthSmaller(e, 1)
+  } else if (isObject(e)) {
+    return isLengthSmaller(e, 1)
+  }
+
+  return e === 0 || e === '' || !e
+}
+
+export const getLength = arg => {
+  if (isOwnProp(arg, 'length') && isNumber(arg.length)) {
+    return arg.length
+  } else if (isNumber(arg)) {
+    return arg
+  } else if (arg && isNumber(arg.length)) {
+    // arrays, strings
+    return arg.length
+  } else if (arg && isNumber(arg.size)) {
+    // Set, Map, WeakMap etc
+    return arg.size
+  } else if (isRegExp(arg)) {
+    const str = arg.toString()
+    if (str === '/(?:)/') {
+      return 0
+    } else {
+      return str.length > 2
+    }
+  } else if (isObjectNative(arg)) {
+    return Object.keys(arg).length
+  }
+
+  // unknown things
+  return -1
+}
+
+export const compareCount = (len, e) => getLength(len) === getLength(e)
+export const isLengthEqual = (a, b) => (isDefined(b) ? compareCount(a, b) : b => compareCount(a, b))
+
+export const isLengthGreater = (a, b) =>
+  isDefined(b) ? getLength(a) > getLength(b) : c => isLengthGreater(a, c)
+
+export const isLengthGreaterOrEqual = (a, b) =>
+  isDefined(b) ? getLength(a) >= getLength(b) : c => isLengthGreaterOrEqual(a, c)
+
+export const isLengthSmaller = (a, b) =>
+  isDefined(b) ? getLength(a) < getLength(b) : c => isLengthSmaller(a, c)
+
+export const isLengthSmallerOrEqual = (a, b) =>
+  isDefined(b) ? getLength(a) <= getLength(b) : c => isLengthSmallerOrEqual(a, c)
+
+export const isIterable = e => isDefined(e) && !isNull(e) && isFunction(e.forEach)
+
+export const isEmail = e => isString(e) && e.indexOf('@') > -1
+
+export const isNull = e => e === null
+
+export const isUndefinedOrNull = e => isNull(e) || !isDefined(e)
+
+export const isBuffer = e => {
+  if (!e) {
+    return false
+  } else if (isEmpty(e)) {
+    return false
+  } else if (!isObject(e)) {
+    return false
+  } else if (!isFunction(e.copy)) {
+    return false
+  } else if (!isNumber(e[0])) {
+    return false
+  }
+
+  return true
+}
+
+export const isPromise = e => e && isFunction(e.then)
+export const isThenable = isPromise
+
+export const isArguments = e => Object.prototype.toString.call(e) === '[object Arguments]'
+
+export const isUUID = e => {
+  if (!isDefined(e)) {
+    return false
+  }
+
+  if (!isString(e)) {
+    return false
+  }
+
+  const split = e.split('-')
+  if (!isLengthEqual(split, 5)) {
+    return false
+  }
+
+  const lengths = [8, 4, 4, 4, 12]
+  if (lengths.some((l, i) => split[i].length !== l)) {
+    return false
+  }
+
+  // hex strings end with 'f'
+  if (Object.values(e).some(s => s > 'f' || s < 0)) {
+    return false
+  }
+
+  return true
+}
+
+export const isType = (e, type) => typeof e === type || Object.prototype.toString(e) === type
+
+export const isTypes = (e, ...types) => types.some(k => isType(e, k))
+
+export const isEqual = (e, ...types) => isTypes(e, ...types)
+
+export const isNot = (e, ...types) => !isTypes(e, ...types)
+
+export const isComparable = a => isBoolean(a) || isString(a) || isNumber(a)
+
+export const isSameType = (a, b) => typeof a === typeof b
+
+const isElementCheck = (e, t) => (isFunction(t) ? t(e) : typeof e === t)
+
+export const isEvery = (arr, t) =>
+  !isArray(arr) ? isElementCheck(arr, t) : arr.every(e => isElementCheck(e, t))
+
+export const isSome = (arr, t) =>
+  !isArray(arr) ? isElementCheck(arr, t) : arr.some(e => isElementCheck(e, t))
+
+export const isNone = (arr, t) => !isSome(arr, t)
+
+export const isInstanceOf = (e, t) => (!t ? false : e instanceof t)
+
+export const isError = e => isInstanceOf(e, Error)
+export const isDate = e => isInstanceOf(e, Date)
+export const isRegExp = e => isInstanceOf(e, RegExp)
+export const isMap = a => isInstanceOf(a, Map)
+export const isSet = a => isInstanceOf(a, Set)
+export const isWeakMap = a => isInstanceOf(a, WeakMap)
+export const isWeakSet = a => isInstanceOf(a, WeakSet)
+
+export const isUpperCase = s => (isString(s) ? s === s.toUpperCase() : false)
+export const isLowerCase = s => (isString(s) ? s === s.toLowerCase() : false)
+
+export const isOwnProp = (o, k) =>
+  isDefined(o) && isFunction(o.hasOwnProperty) && o.hasOwnProperty(k)
+
+export const isOwnProperty = isOwnProp
+
+export const isModule = s => Object.prototype.toString.call(s) === '[object Module]'
+
+export const isCase = (s, c = 'up') => (c === 'up' ? isUpperCase(s) : isLowerCase(s))
+isCase.upper = isUpperCase
+isCase.lower = isLowerCase

package/src/index.mjs

@@ -1,520 +1,12 @@
-import deep from './deep/index.mjs'
+import def from './lib.mjs'
 
-export const isArray = e => Array.isArray(e)
+import * as deep from './deep/index.mjs'
 
-export const isBoolean = e => typeof e === 'boolean'
-
-export const isDefined = e => typeof e !== 'undefined'
-
-export const isUndefined = e => !isDefined(e)
-
-export const isFunction = e => typeof e === 'function'
-
-export const isAsyncFunction = e => Object.prototype.toString.call(e) === '[object AsyncFunction]'
-
-export const isGeneratorFunction = e => Object.prototype.toString.call(e) === '[object GeneratorFunction]'
-
-export const isNumber = e => typeof e !== 'object' && e === +e
-
-export const isInteger = e => e === +e && e === (e | 0)
-
-export const isFloat = e => e === +e
-
-export const isObject = e => typeof e === 'object' && !isNull(e)
-
-export const isObjectNative = e => Object.prototype.toString.call(e) === '[object Object]'
-
-export const isMergeableObject = e => isObject(e) && !isDate(e) && !isRegExp(e)
-
-export const isString = e => typeof e === 'string'
-
-export const isRGBValue = e => ![e.r, e.g, e.b].some(n => !isNumber(n))
-export const isRGBAValue = e => ![e.r, e.g, e.b, e.a].some(n => !isNumber(n))
-
-export const isRGBAObject = e => isObject(e) && isRGBAValue(e)
-
-export const isRGBObject = e => isObject(e) && isRGBValue(e)
-
-export const hexRegex = /#\b([a-f0-9]{3}|[a-f0-9]{4}|[a-f0-9]{6}|[a-f0-9]{8})\b/i
-export const isHexColor = e => hexRegex.test(e)
-
-export const isHexColor3 = e => /#\b([a-f0-9]{3})\b/i.test(e)
-
-export const isHexColor4 = e => /#\b([a-f0-9]{4})\b/i.test(e)
-
-export const isHexColor6 = e => /#\b([a-f0-9]{6})\b/i.test(e)
-
-export const isHexColor8 = e => /#\b([a-f0-9]{8})\b/i.test(e)
-
-export const isHexAlphaColor = e => /#\b([a-f0-9]{4}|[a-f0-9]{8})\b/i.test(e)
-
-export const isHexAlphaColor4 = e => /#\b([a-f0-9]{4})\b/i.test(e)
-
-export const isHexAlphaColor8 = e => /#\b([a-f0-9]{8})\b/i.test(e)
-
-export const isColor = e => isRGBAObject(e) || isRGBObject(e) || isHexColor(e) || isHexAlphaColor(e)
-
-export const isTruthy = e => !!e
-
-export const isFalsy = e => !e || isEmpty(e)
-
-export const isEmpty = e => {
-  if (isError(e)) {
-    return false
-  } else if (isDate(e)) {
-    return false
-  } else if (isNull(e)) {
-    return true
-  } else if (isUndefined(e)) {
-    return true
-  } else if (isArray(e)) {
-    return isLengthSmaller(e, 1)
-  } else if (isRegExp(e)) {
-    return isLengthSmaller(e, 1)
-  } else if (isObject(e)) {
-    return isLengthSmaller(e, 1)
-  }
-
-  return e === 0 || e === '' || !e
-}
-
-export const getLength = arg => {
-  if (isNumber(arg)) {
-    return arg
-  } else if (isNumber(arg.length)) {
-    // arrays, strings
-    return arg.length
-  } else if (isNumber(arg.size)) {
-    // Set, Map, WeakMap etc
-    return arg.size
-  } else if (isRegExp(arg)) {
-    const str = arg.toString()
-    if (str === '/(?:)/') {
-      return 0
-    } else {
-      return str.length > 2
-    }
-  }
-
-  // objects
-  return Object.keys(arg).length
-}
-
-export const compareCount = (len, e) => getLength(len) === getLength(e)
-export const isLengthEqual = (a, b) => (isDefined(b) ? compareCount(a, b) : b => compareCount(a, b))
-
-export const isLengthGreater = (a, b) =>
-  isDefined(b) ? getLength(a) > getLength(b) : c => isLengthGreater(a, c)
-
-export const isLengthGreaterOrEqual = (a, b) =>
-  isDefined(b) ? getLength(a) >= getLength(b) : c => isLengthGreaterOrEqual(a, c)
-
-export const isLengthSmaller = (a, b) =>
-  isDefined(b) ? getLength(a) < getLength(b) : c => isLengthSmaller(a, c)
-
-export const isLengthSmallerOrEqual = (a, b) =>
-  isDefined(b) ? getLength(a) <= getLength(b) : c => isLengthSmallerOrEqual(a, c)
-
-export const isIterable = e => isDefined(e) && !isNull(e) && isFunction(e.forEach)
-
-export const isEmail = e => isString(e) && e.indexOf('@') > -1
-
-export const isNull = e => e === null
-
-export const isUndefinedOrNull = e => e === null || !isDefined(e)
-
-export const isBuffer = e => {
-  if (!e) {
-    return false
-  } else if (isEmpty(e)) {
-    return false
-  } else if (!isObject(e)) {
-    return false
-  } else if (!isFunction(e.copy)) {
-    return false
-  } else if (!isNumber(e[0])) {
-    return false
-  }
-
-  return true
-}
-
-export const isPromise = e => e && isFunction(e.then)
-
-export const isArguments = e => Object.prototype.toString.call(e) === '[object Arguments]'
-
-export const isUUID = e => {
-  if (!isDefined(e)) {
-    return false
-  }
-
-  if (!isString(e)) {
-    return false
-  }
-
-  const split = e.split('-')
-  if (!is.len.equal(split, 5)) {
-    return false
-  }
-
-  const lengths = [8, 4, 4, 4, 12]
-  if (lengths.some((l, i) => split[i].length !== l)) {
-    return false
-  }
-
-  // hex strings end with 'f'
-  if (Object.values(e).some(s => s > 'f' || s < 0)) {
-    return false
-  }
-
-  return true
-}
-
-export const isType = (e, type) => typeof e === type || Object.prototype.toString(e) === type
-
-export const isTypes = (e, ...types) => types.some(k => isType(e, k))
-
-export const isEqual = (e, ...types) => isTypes(e, ...types)
-
-export const isNot = (e, ...types) => !isTypes(e, ...types)
-
-export const isComparable = a => isBoolean(a) || isString(a) || isNumber(a)
-
-const isElementCheck = (e, t) => (isFunction(t) ? t(e) : typeof e === t)
-
-export const isEvery = (arr, t) =>
-  !isArray(arr) ? isElementCheck(arr, t) : arr.every(e => isElementCheck(e, t))
-
-export const isSome = (arr, t) =>
-  !isArray(arr) ? isElementCheck(arr, t) : arr.some(e => isElementCheck(e, t))
-
-export const isNone = (arr, t) => !isSome(arr, t)
-
-export const isInstanceOf = (e, t) => e instanceof t
-
-export const isError = e => isInstanceOf(e, Error)
-export const isDate = e => isInstanceOf(e, Date)
-export const isRegExp = e => isInstanceOf(e, RegExp)
-export const isMap = a => isInstanceOf(a, Map)
-export const isSet = a => isInstanceOf(a, Set)
-export const isWeakMap = a => isInstanceOf(a, WeakMap)
-export const isWeakSet = a => isInstanceOf(a, WeakSet)
-
-export const isUpperCase = s => (isString(s) ? s === s.toUpperCase() : false)
-export const isLowerCase = s => (isString(s) ? s === s.toLowerCase() : false)
-
-export const isCase = (s, c = 'up') => (c === 'up' ? isUpperCase(s) : isLowerCase(s))
-
-isCase.upper = isUpperCase
-isCase.lower = isLowerCase
+export * from './fns.mjs'
 
 export const is = {
-  count: getLength,
-  length: getLength,
-  len: getLength,
-  ln: getLength,
-
-  isError,
-  error: isError,
-  err: isError,
-
-  isIterable,
-  isIter: isIterable,
-  iterable: isIterable,
-  iter: isIterable,
-
-  isEmail,
-  isMail: isEmail,
-  email: isEmail,
-  mail: isEmail,
-
-  isNull,
-  isNil: isNull,
-  null: isNull,
-  nil: isNull,
-
-  isUndefinedOrNull,
-  undefinedOrNull: isUndefinedOrNull,
-  undefinedOrNil: isUndefinedOrNull,
-  undefOrNull: isUndefinedOrNull,
-  undefOrNil: isUndefinedOrNull,
-
-  isBuffer,
-  buffer: isBuffer,
-  buff: isBuffer,
-
-  isPromise,
-  promise: isPromise,
-  isThenable: isPromise,
-  isThen: isPromise,
-  thenable: isPromise,
-  then: isPromise,
-
-  // isArguments,
-  // isArgs: isArguments,
-  // arguments: isArguments,
-  // args: isArguments,
-
-  isUUID,
-  uuid: isUUID,
-
-  isType,
-  testType: isType,
-  type: isType,
-
-  isTypes,
-  test: isTypes,
-  types: isTypes,
-
-  isEmpty,
-  empty: isEmpty,
-
-  isEqual,
-  isEq: isEqual,
-  equal: isEqual,
-  eq: isEqual,
-  is: isEqual,
-
-  isNot,
-  not: isNot,
-  isNeq: isNot,
-  neq: isNot,
-
-  isArray,
-  isArr: isArray,
-  array: isArray,
-  arr: isArray,
-
-  isBoolean,
-  isBool: isBoolean,
-  boolean: isBoolean,
-  bool: isBoolean,
-
-  isDefined,
-  isDef: isDefined,
-  defined: isDefined,
-  def: isDefined,
-
-  isUndefined,
-  isUndef: isUndefined,
-  undefined: isUndefined,
-  undef: isUndefined,
-
-  isFunction,
-  isFunc: isFunction,
-  isFn: isFunction,
-  function: isFunction,
-  func: isFunction,
-  fn: isFunction,
-
-  isAsyncFunction,
-  isAsyncFunc: isAsyncFunction,
-  isAsyncFn: isAsyncFunction,
-  asyncFunction: isAsyncFunction,
-  asyncFunc: isAsyncFunction,
-  asyncFn: isAsyncFunction,
-
-  isGeneratorFunction,
-  isGeneratorFn: isGeneratorFunction,
-  isGeneratorFunc: isGeneratorFunction,
-  isGeneratorFn: isGeneratorFunction,
-  generator: isGeneratorFunction,
-  isGenerator: isGeneratorFunction,
-  generatorFn: isGeneratorFunction,
-  generatorFunc: isGeneratorFunction,
-  generatorFunction: isGeneratorFunction,
-
-  isNumber,
-  isNum: isNumber,
-  number: isNumber,
-  num: isNumber,
-
-  isInteger,
-  isInt: isInteger,
-  integer: isInteger,
-  int: isInteger,
-
-  isFloat,
-  float: isFloat,
-
-  isObject,
-  isObj: isObject,
-  object: isObject,
-  obj: isObject,
-
-  isObjectNative,
-  objectNative: isObjectNative,
-
-  isMergeableObject,
-  mergeableObject: isMergeableObject,
-  isMergeable: isMergeableObject,
-  mergeable: isMergeableObject,
-
-  isString,
-  isStr: isString,
-  string: isString,
-  str: isString,
-
-  isRGBAObject,
-  isRGBA: isRGBAObject,
-  rgbaObject: isRGBAObject,
-  rgba: isRGBAObject,
-
-  isRGBObject,
-  isRGB: isRGBObject,
-  rgbObject: isRGBObject,
-  rgb: isRGBObject,
-
-  isHexColor,
-  isHex: isHexColor,
-  hexColor: isHexColor,
-  hex: isHexColor,
-
-  isHexColor3,
-  isHex3: isHexColor3,
-  hexColor3: isHexColor3,
-  hex3: isHexColor3,
-
-  isHexColor4,
-  isHex4: isHexColor4,
-  hexColor4: isHexColor4,
-  hex4: isHexColor4,
-
-  isHexColor6,
-  isHex6: isHexColor6,
-  hexColor6: isHexColor6,
-  hex6: isHexColor6,
-
-  isHexColor8,
-  isHex8: isHexColor8,
-  hexColor8: isHexColor8,
-  hex8: isHexColor8,
-
-  isHexAlphaColor,
-  isHexa: isHexAlphaColor,
-  hexAlphaColor: isHexAlphaColor,
-  hexa: isHexAlphaColor,
-
-  isHexAlphaColor4,
-  isHexa4: isHexAlphaColor4,
-  hexAlphaColor4: isHexAlphaColor4,
-  hexa4: isHexAlphaColor4,
-
-  isHexAlphaColor8,
-  isHexa8: isHexAlphaColor8,
-  hexAlphaColor8: isHexAlphaColor8,
-  hexa8: isHexAlphaColor8,
-
-  isColor,
-  isCol: isColor,
-  color: isColor,
-  col: isColor,
-
-  isComparable,
-  Comparable: isComparable,
-  comparable: isComparable,
-
-  isDate,
-  isTime: isDate,
-  date: isDate,
-  time: isDate,
-
-  isRegExp,
-  isRegex: isRegExp,
-  regExp: isRegExp,
-  regexp: isRegExp,
-  regex: isRegExp,
-
-  isTruthy,
-  truthy: isTruthy,
-
-  isFalsy,
-  falsy: isFalsy,
-
-  isDeepEqual: deep.equal,
-  deepEqual: deep.equal,
-  deepEq: deep.equal,
-
-  isDeepDifferent: deep.different,
-  deepDifferent: deep.different,
-  deepDiff: deep.different,
-
-  deep: {
-    isDifferent: deep.different,
-    different: deep.different,
-    diff: deep.different,
-
-    isEqual: deep.equal,
-    equal: deep.equal,
-    eq: deep.equal,
-  },
-
-  isLengthGreater,
-  isLengthGreaterOrEqual,
-  isLengthSmaller,
-  isLengthSmallerOrEqual,
-  isLengthEqual,
-
-  isMap,
-  map: isMap,
-
-  isSet,
-  set: isSet,
-
-  isWeakMap,
-  weakMap: isWeakMap,
-
-  isWeakSet,
-  weakSet: isWeakSet,
-
-  every: isEvery,
-  all: isEvery,
-  some: isSome,
-  none: isNone,
-
-  instance: isInstanceOf,
-  instanceof: isInstanceOf,
-  instanceOf: isInstanceOf,
-
-  isCase,
-  case: isCase,
-
-  isUpperCase,
-  upperCase: isUpperCase,
-  isLowerCase,
-  lowerCase: isLowerCase,
-}
-
-// assign ln as properties of the getLength function
-const ln = {
-  eq: isLengthEqual,
-  equal: isLengthEqual,
-  greater: isLengthGreater,
-  gt: isLengthGreater,
-  bigger: isLengthGreater,
-  biggerequal: isLengthGreaterOrEqual,
-  greater: isLengthGreater,
-  greaterequal: isLengthGreaterOrEqual,
-  gte: isLengthGreaterOrEqual,
-  gteq: isLengthGreaterOrEqual,
-
-  lower: isLengthSmaller,
-  smaller: isLengthSmaller,
-  lt: isLengthSmaller,
-  lowerequal: isLengthSmallerOrEqual,
-  smallerequal: isLengthSmallerOrEqual,
-  lte: isLengthSmallerOrEqual,
-  lteq: isLengthSmallerOrEqual,
+  ...deep,
+  ...def,
 }
 
-// count, length, len and ln are functions, returning the length.
-// the code below assigns all keys in the ln object to each of those functions,
-// allowing users of this library to call is.length.equal and other subfunctions.
-
-const applyLenKey = (k, fn) => key => (is[key][k] = fn)
-
-const applyLenKeys = ([k, fn]) => ['count', 'length', 'len', 'ln'].forEach(applyLenKey(k, fn))
-
-Object.entries(ln).forEach(applyLenKeys)
-
 export default is

package/src/lib.mjs

@@ -0,0 +1,308 @@
+import * as fns from './fns.mjs'
+
+export const is = {
+  count: fns.getLength,
+  length: fns.getLength,
+  len: fns.getLength,
+  ln: fns.getLength,
+
+  isError: fns.isError,
+  error: fns.isError,
+  err: fns.isError,
+
+  isIterable: fns.isIterable,
+  isIter: fns.isIterable,
+  iterable: fns.isIterable,
+  iter: fns.isIterable,
+
+  isEmail: fns.isEmail,
+  isMail: fns.isEmail,
+  email: fns.isEmail,
+  mail: fns.isEmail,
+
+  isNull: fns.isNull,
+  isNil: fns.isNull,
+  null: fns.isNull,
+  nil: fns.isNull,
+
+  isUndefinedOrNull: fns.isUndefinedOrNull,
+  undefinedOrNull: fns.isUndefinedOrNull,
+  undefinedOrNil: fns.isUndefinedOrNull,
+  undefOrNull: fns.isUndefinedOrNull,
+  undefOrNil: fns.isUndefinedOrNull,
+
+  isBuffer: fns.isBuffer,
+  buffer: fns.isBuffer,
+  buff: fns.isBuffer,
+
+  isPromise: fns.isPromise,
+  promise: fns.isPromise,
+  isThenable: fns.isPromise,
+  isThen: fns.isPromise,
+  thenable: fns.isPromise,
+  then: fns.isPromise,
+
+  // isArguments: fns.isArguments,
+  // isArgs: fns.isArguments,
+  // arguments: fns.isArguments,
+  // args: fns.isArguments,
+
+  isUUID: fns.isUUID,
+  uuid: fns.isUUID,
+
+  isType: fns.isType,
+  testType: fns.isType,
+  type: fns.isType,
+
+  isTypes: fns.isTypes,
+  test: fns.isTypes,
+  types: fns.isTypes,
+
+  isEmpty: fns.isEmpty,
+  empty: fns.isEmpty,
+
+  isEqual: fns.isEqual,
+  isEq: fns.isEqual,
+  equal: fns.isEqual,
+  eq: fns.isEqual,
+  is: fns.isEqual,
+
+  isNot: fns.isNot,
+  not: fns.isNot,
+  isNeq: fns.isNot,
+  neq: fns.isNot,
+
+  isArray: fns.isArray,
+  isArr: fns.isArray,
+  array: fns.isArray,
+  arr: fns.isArray,
+
+  isBoolean: fns.isBoolean,
+  isBool: fns.isBoolean,
+  boolean: fns.isBoolean,
+  bool: fns.isBoolean,
+
+  isDefined: fns.isDefined,
+  isDef: fns.isDefined,
+  defined: fns.isDefined,
+  def: fns.isDefined,
+
+  isUndefined: fns.isUndefined,
+  isUndef: fns.isUndefined,
+  undefined: fns.isUndefined,
+  undef: fns.isUndefined,
+
+  isFunction: fns.isFunction,
+  isFunc: fns.isFunction,
+  isFn: fns.isFunction,
+  function: fns.isFunction,
+  func: fns.isFunction,
+  fn: fns.isFunction,
+
+  isAsyncFunction: fns.isAsyncFunction,
+  isAsyncFunc: fns.isAsyncFunction,
+  isAsyncFn: fns.isAsyncFunction,
+  asyncFunction: fns.isAsyncFunction,
+  asyncFunc: fns.isAsyncFunction,
+  asyncFn: fns.isAsyncFunction,
+
+  isGeneratorFunction: fns.isGeneratorFunction,
+  isGeneratorFn: fns.isGeneratorFunction,
+  isGeneratorFunc: fns.isGeneratorFunction,
+  isGeneratorFn: fns.isGeneratorFunction,
+  generator: fns.isGeneratorFunction,
+  isGenerator: fns.isGeneratorFunction,
+  generatorFn: fns.isGeneratorFunction,
+  generatorFunc: fns.isGeneratorFunction,
+  generatorFunction: fns.isGeneratorFunction,
+
+  isNumber: fns.isNumber,
+  isNum: fns.isNumber,
+  number: fns.isNumber,
+  num: fns.isNumber,
+
+  isInteger: fns.isInteger,
+  isInt: fns.isInteger,
+  integer: fns.isInteger,
+  int: fns.isInteger,
+
+  isFloat: fns.isFloat,
+  float: fns.isFloat,
+
+  isObject: fns.isObject,
+  isObj: fns.isObject,
+  object: fns.isObject,
+  obj: fns.isObject,
+
+  isObjectNative: fns.isObjectNative,
+  objectNative: fns.isObjectNative,
+
+  isMergeableObject: fns.isMergeableObject,
+  mergeableObject: fns.isMergeableObject,
+  isMergeable: fns.isMergeableObject,
+  mergeable: fns.isMergeableObject,
+
+  isString: fns.isString,
+  isStr: fns.isString,
+  string: fns.isString,
+  str: fns.isString,
+
+  isRGBAObject: fns.isRGBAObject,
+  isRGBA: fns.isRGBAObject,
+  rgbaObject: fns.isRGBAObject,
+  rgba: fns.isRGBAObject,
+
+  isRGBObject: fns.isRGBObject,
+  isRGB: fns.isRGBObject,
+  rgbObject: fns.isRGBObject,
+  rgb: fns.isRGBObject,
+
+  isHexColor: fns.isHexColor,
+  isHex: fns.isHexColor,
+  hexColor: fns.isHexColor,
+  hex: fns.isHexColor,
+
+  isHexColor3: fns.isHexColor3,
+  isHex3: fns.isHexColor3,
+  hexColor3: fns.isHexColor3,
+  hex3: fns.isHexColor3,
+
+  isHexColor4: fns.isHexColor4,
+  isHex4: fns.isHexColor4,
+  hexColor4: fns.isHexColor4,
+  hex4: fns.isHexColor4,
+
+  isHexColor6: fns.isHexColor6,
+  isHex6: fns.isHexColor6,
+  hexColor6: fns.isHexColor6,
+  hex6: fns.isHexColor6,
+
+  isHexColor8: fns.isHexColor8,
+  isHex8: fns.isHexColor8,
+  hexColor8: fns.isHexColor8,
+  hex8: fns.isHexColor8,
+
+  isHexAlphaColor: fns.isHexAlphaColor,
+  isHexa: fns.isHexAlphaColor,
+  hexAlphaColor: fns.isHexAlphaColor,
+  hexa: fns.isHexAlphaColor,
+
+  isHexAlphaColor4: fns.isHexAlphaColor4,
+  isHexa4: fns.isHexAlphaColor4,
+  hexAlphaColor4: fns.isHexAlphaColor4,
+  hexa4: fns.isHexAlphaColor4,
+
+  isHexAlphaColor8: fns.isHexAlphaColor8,
+  isHexa8: fns.isHexAlphaColor8,
+  hexAlphaColor8: fns.isHexAlphaColor8,
+  hexa8: fns.isHexAlphaColor8,
+
+  isColor: fns.isColor,
+  isCol: fns.isColor,
+  color: fns.isColor,
+  col: fns.isColor,
+
+  isComparable: fns.isComparable,
+  Comparable: fns.isComparable,
+  comparable: fns.isComparable,
+
+  isDate: fns.isDate,
+  isTime: fns.isDate,
+  date: fns.isDate,
+  time: fns.isDate,
+
+  isRegExp: fns.isRegExp,
+  isRegex: fns.isRegExp,
+  regExp: fns.isRegExp,
+  regexp: fns.isRegExp,
+  regex: fns.isRegExp,
+
+  isTruthy: fns.isTruthy,
+  truthy: fns.isTruthy,
+
+  isFalsy: fns.isFalsy,
+  falsy: fns.isFalsy,
+
+  isLengthGreater: fns.isLengthGreater,
+  isLengthGreaterOrEqual: fns.isLengthGreaterOrEqual,
+  isLengthSmaller: fns.isLengthSmaller,
+  isLengthSmallerOrEqual: fns.isLengthSmallerOrEqual,
+  isLengthEqual: fns.isLengthEqual,
+
+  isMap: fns.isMap,
+  map: fns.isMap,
+
+  isSet: fns.isSet,
+  set: fns.isSet,
+
+  isWeakMap: fns.isWeakMap,
+  weakMap: fns.isWeakMap,
+
+  isWeakSet: fns.isWeakSet,
+  weakSet: fns.isWeakSet,
+
+  every: fns.isEvery,
+  all: fns.isEvery,
+  some: fns.isSome,
+  none: fns.isNone,
+
+  instance: fns.isInstanceOf,
+  instanceof: fns.isInstanceOf,
+  instanceOf: fns.isInstanceOf,
+
+  isCase: fns.isCase,
+  case: fns.isCase,
+
+  isUpperCase: fns.isUpperCase,
+  upperCase: fns.isUpperCase,
+  isLowerCase: fns.isLowerCase,
+  lowerCase: fns.isLowerCase,
+
+  same: fns.isSameType,
+  sameType: fns.isSameType,
+  isSameType: fns.isSameType,
+  isSame: fns.isSameType,
+
+  ownProp: fns.isOwnProp,
+  prop: fns.isOwnProp,
+  ownProperty: fns.isOwnProp,
+  isOwnProp: fns.isOwnProp,
+  isOwnProperty: fns.isOwnProp,
+
+  isModule: fns.isModule,
+  module: fns.isModule,
+}
+
+// assign ln as properties of the getLength function
+const ln = {
+  eq: fns.isLengthEqual,
+  equal: fns.isLengthEqual,
+  greater: fns.isLengthGreater,
+  gt: fns.isLengthGreater,
+  bigger: fns.isLengthGreater,
+  biggerequal: fns.isLengthGreaterOrEqual,
+  greater: fns.isLengthGreater,
+  greaterequal: fns.isLengthGreaterOrEqual,
+  gte: fns.isLengthGreaterOrEqual,
+  gteq: fns.isLengthGreaterOrEqual,
+
+  lower: fns.isLengthSmaller,
+  smaller: fns.isLengthSmaller,
+  lt: fns.isLengthSmaller,
+  lowerequal: fns.isLengthSmallerOrEqual,
+  smallerequal: fns.isLengthSmallerOrEqual,
+  lte: fns.isLengthSmallerOrEqual,
+  lteq: fns.isLengthSmallerOrEqual,
+}
+
+// count, length, len and ln are functions, returning the length.
+// the code below assigns all keys in the ln object to each of those functions,
+// allowing users of this library to call is.length.equal and other subfunctions.
+
+const applyLenKey = (k, fn) => key => (is[key][k] = fn)
+
+const applyLenKeys = ([k, fn]) => ['count', 'length', 'len', 'ln'].forEach(applyLenKey(k, fn))
+
+Object.entries(ln).forEach(applyLenKeys)
+
+export default is