@magic/types 0.1.39 → 0.1.41

package/README.md

@@ -3,24 +3,9 @@
 typechecking utilities
 
 [![NPM version][npm-image]][npm-url]
-[![Linux Build Status][travis-image]][travis-url]
-[![Windows Build Status][appveyor-image]][appveyor-url]
-[![Coverage Status][coveralls-image]][coveralls-url]
-[![Greenkeeper badge][greenkeeper-image]][greenkeeper-url]
-[![Known Vulnerabilities][snyk-image]][snyk-url]
 
 [npm-image]: https://img.shields.io/npm/v/@magic/types.svg
 [npm-url]: https://www.npmjs.com/package/@magic/types
-[travis-image]: https://img.shields.io/travis/com/magic/types/master
-[travis-url]: https://travis-ci.com/magic/types
-[appveyor-image]: https://img.shields.io/appveyor/ci/magic/types/master.svg
-[appveyor-url]: https://ci.appveyor.com/project/magic/types/branch/master
-[coveralls-image]: https://coveralls.io/repos/github/magic/types/badge.svg
-[coveralls-url]: https://coveralls.io/github/magic/types
-[greenkeeper-image]: https://badges.greenkeeper.io/magic/types.svg
-[greenkeeper-url]: https://badges.greenkeeper.io/magic/types.svg
-[snyk-image]: https://snyk.io/test/github/magic/types/badge.svg
-[snyk-url]: https://snyk.io/test/github/magic/types
 
 ##### install
 
@@ -45,6 +30,19 @@ import is from '@magic/types'
 is.array([]) // true
 ```
 
+##### import deep
+
+```javascript
+import { deep } from '@magic/types'
+
+deep.isDeepEqual([1, 2, 3], [1, 2, 3]) // true
+// also: deep.deepEqual, deep.deepEq, is.isDeepEqual
+deep.isDeepDifferent([1, 2, 3], [1, 2, 3]) // false
+// also: deep.deepDifferent, deep.deepDiff, is.isDeepDifferent
+deep.isEqual([1, 2, 3], [1, 2, 3]) // true
+// also: is.deep.isEqual, is.deep.equal, is.deep.eq
+```
+
 ##### functions
 
 ```javascript
@@ -52,13 +50,20 @@ is.array([]) // true
 // comparisons
 
 // test a value for multiple types
-is(ele, ...types)
-// alias is.eq, isEq, test
+is.is(ele, ...types)
+// alias is.type, is.testType, is.types, test
 
 // test if a value is not of a type
 not(ele, ...types)
 // alias is.neq, isNeq, isNot
 
+// not (and is.not) is also a namespace with negated versions of every check:
+is.not.array([]) // false
+is.not.len.eq('abc', 'def') // false
+is.not.case.upper('lowercase') // true
+is.not.deep.eq([1], [1]) // false
+is.not.ip.v4('192.168.1.1') // false
+
 isSameType('string', 'string')
 // alias isSame, is.same, is.sameType
 
@@ -74,7 +79,7 @@ isBoolean(true) // true
 isDefined(undefined) //false
 // alias isDef, is.defined, is.def
 
-isUndefined(undefined) //false
+isUndefined(undefined) //true
 // alias isUndef, is.undefined, is.undef
 
 isFunction(() => {}) // true
@@ -84,7 +89,7 @@ isAsyncFunction(async () => {}) // true
 // alias isAsyncFunc, isAsyncFn, is.asyncFunction, is.asyncFunc, is.asyncFn
 
 isGeneratorFunction(* () => {}) // true
-// alias isGeneratorFunc, isGeneratorFunc, is.generatorFunction, is.generatorFunc, is.generatorFn
+// alias isGeneratorFunc, isGeneratorFn, isGenerator, is.generatorFunction, is.generatorFunc, is.generatorFn, generator, generatorFn, generatorFunc, generatorFunction
 
 isNumber(1) // true
 // alias isNum, is.number, is.num
@@ -98,21 +103,41 @@ isFloat(1.1) // true
 isObject({}) // true
 // alias isObj, is.object, is.obj
 
+isObjectNative({}) // true
+isObjectNative([]) // false
+// alias is.objectNative
+
 isString('') // true
 // alias isStr, is.string, is.str
 
 isRGBAObject({ r: 1, g: 1, b: 1, a: 1 }) // true
 // alias isRGBA, is.rgbaObject, is.rgba
 
-isRGBObject
+isRGBObject({ r: 1, g: 1, b: 1 }) // true
 // alias isRGB, is.rgbObject, is.rgb
 
+isRGBValue({ r: 1, g: 1, b: 1 }) // true
+// alias isRGBObject, is.rgbValue
+
+isRGBAValue({ r: 1, g: 1, b: 1, a: 1 }) // true
+// alias isRGBAObject, is.rgbaValue
+
 isHexColor('#333') // true
 // alias isHex, is.hex, is.hexColor
 
+isHexColor3('#333') // true
+isHexColor4('#3333') // true
+isHexColor6('#333333') // true
+isHexColor8('#33333333') // true
+// aliases is.hex3, is.hexColor3, is.hex4, is.hexColor4, is.hex6, is.hexColor6, is.hex8, is.hexColor8
+
 isHexAlphaColor('#3333') // true
 // alias isHexa, is.hexa, is.hexAlphaColor
 
+isHexAlphaColor4('#3333') // true
+isHexAlphaColor8('#33333333') // true
+// aliases is.hexa4, is.hexAlphaColor4, is.hexa8, is.hexAlphaColor8
+
 isColor('#444') // true
 // alias isCol, is.color, is.col
 
@@ -135,14 +160,39 @@ isError(new Error('')) // true
 // alias isErr, is.error, is.err
 
 isIterable([]) // true
-// alias is.iterable
+// alias is.iterable, is.iter, isIter
 
 isEmail('a@b.c') // true
 // alias isMail, is.email, is.mail
 
+isIP('192.168.1.1') // true
+isIP('::1') // true
+// alias ip, is.ip, isIp, isIP
+
 isIp('192.168.1.1') // true
 isIp('::1') // true
-// alias ip, is.ip, ipV4, ipV6, isIPv4, isIPv6
+// alias ip, is.ip
+
+isIp.v4('192.168.1.1') // true
+isIp.v6('::1') // true
+
+isIPv4('192.168.1.1') // true
+// aliases ipV4, is.ipV4, is.ipv4, is.v4
+
+isIPv6('::1') // true
+// aliases ipV6, is.ipV6, is.ipv6, is.v6
+
+isMap(new Map()) // true
+// alias is.map, is.map, map
+
+isSet(new Set()) // true
+// alias is.set, is.set, set
+
+isWeakMap(new WeakMap()) // true
+// alias is.weakMap, is.weakMap, weakMap
+
+isWeakSet(new WeakSet()) // true
+// alias is.weakSet, is.weakSet, weakSet
 
 isNull(null) // true
 // alias isNil, is.nil, is.null
@@ -150,41 +200,49 @@ isNull(null) // true
 isUndefinedOrNull(undefined || null) // true
 // alias is.undefinedOrNull, is.undefinedOrNil, is.undefOrNull, is.undefOrNil
 
-isBuffer(new Buffer('test')) // true
+isBuffer(Buffer.from('test')) // true
 // alias isBuff, is.buffer, is.buff
 
-isPromise(new Promise()) // true
+isPromise(new Promise(r => r())) // true
 // alias is.promise, isThenable, isThen, is.thenable, is.then
 
-// removed (for now?)!
-isArguments(() => return arguments) // true
+// (call with a function's arguments object)
+(function () {
+  isArguments(arguments) // true
+})()
 // alias isArgs, is.arguments, is.args
 
 isUUID(uuid) // true
 // alias is.uuid
 
-testType(42, 'number') // true
-// alias is.type
+isType(42, 'number') // true
+// alias is.type, is.testType, isType
 
-test(42, ['string', 'object']) // false
+is.test(42, ['string', 'object']) // false
 // alias is.types
 
-isEq(42, 'number') // true
+is.eq('abc', 'def') // true
 // alias is.eq
+// is.eq compares lengths, see "length" section below
 
-isNot = isNeq = is.not(42, 'number') // true
+isNot = isNeq = is.not(42, 'string') // true
 // alias is.neq
 
-isDeepEqual([1, 2, 3], [1, 2, 3]) // true
+deep.isDeepEqual([1, 2, 3], [1, 2, 3]) // true
 // alias is.deep.eq, is.deep.equal
-isDeepDifferent([1, 2, 3], [1, 2, 3]) // false
+// also deep.deepEqual, deep.deepEq, is.isDeepEqual
+deep.isDeepDifferent([1, 2, 3], [1, 2, 3]) // false
 // alias is.deep.diff, is.deep.different
+// also deep.deepDifferent, deep.deepDiff, is.isDeepDifferent
 
-isDeepEqual([1, 2, 3], [3, 2, 1]) // true
-isDeepEqual([1, 2, 3], [3, 2, 1], { strict: true }) // false
+deep.isDifferent([1, 2, 3], [1, 2, 3]) // false
+// alias is.deep.isDifferent, is.deep.different, is.deep.diff
 
-isDeepEqual({a: 1, b: 2, c: 3 }, { c: 3, b: 2, a: 1 }) // true
-isDeepEqual({a: 1, b: 2, c: 3 }, { c: 3, b: 2, a: 1 }, { strict: true }) // false
+deep.isDeepEqual([1, 2, 3], [3, 2, 1]) // true
+deep.isDeepEqual([1, 2, 3], [3, 2, 1], { strict: true }) // false
+
+deep.isDeepEqual({a: 1, b: 2, c: 3 }, { c: 3, b: 2, a: 1 }) // true
+deep.isDeepEqual({a: 1, b: 2, c: 3 }, { c: 3, b: 2, a: 1 }, { strict: true }) // false
 
 isEvery([1, 2, 3], 'number') // true
 isEvery([1, 2, 3], is.number) // true
@@ -194,7 +252,7 @@ isSome([1, 'str', {}], 'number') // true
 isSome([1, 'str', {}], is.number) // true
 // alias is.some
 
-isSymbol(Symbol('testing)) // true
+isSymbol(Symbol('testing')) // true
 // alias is.symbol, is.sym
 
 isNone([1, 2, 3], 'string') // true
@@ -209,10 +267,10 @@ isCase('lowercase', 'low') // true
 // alias is.case
 
 isUpperCase('UPPERCASE') // true
-// alias is.case.upper, is.isCase.upper
+// alias is.case.upper, isCase.upper
 
 isLowerCase('lowercase') // true
-// alias is.case.lower, is.isCase.lower
+// alias is.case.lower, isCase.lower
 
 isMergeableObject({}) // true
 // alias is.mergeable, is.mergeableObject, isMergeable
@@ -221,9 +279,47 @@ const mod = await import('path/to/file')
 isModule(mod) // true
 // alias is.module
 
+isComparable(1) // true
+isComparable('str') // true
+isComparable(true) // true
+isComparable({}) // false
+// aliases is.comparable, is.Comparable
+
 isOwnProp({ test: undefined }, 'test') // true
 // alias isOwnProperty, is.ownProperty, is.ownProp, is.prop
 
+// length
+
+// get the length of a string, array, map, set, regexp, or object
+// numbers return themselves
+getLength('test') // 4
+getLength([1, 2, 3]) // 3
+getLength(new Set([1, 2])) // 2
+getLength(123) // 123
+// aliases is.len, is.count, is.length, is.ln
+
+// compare lengths, both arguments can be anything with a length
+// these can also be curried: is.gt('abcd')('ab') // true
+is.eq('abc', 'def') // true
+is.gt('abcd', 'ab') // true
+is.gte('abc', 'ab') // true
+is.lt('ab', 'abc') // true
+is.lte('abc', 'abc') // true
+// aliases is.equal, is.greater, is.bigger, is.greaterequal, is.biggerequal,
+// is.gteq, is.lower, is.smaller, is.lowerequal, is.smallerequal, is.lteq
+
+isLengthEqual('abc', 3) // true
+isLengthGreater('abc', 2) // true
+isLengthGreaterOrEqual('ab', 2) // true
+isLengthSmaller('ab', 3) // true
+isLengthSmallerOrEqual('abc', 3) // true
+// aliases is.isLengthEqual, is.isLengthGreater, is.isLengthGreaterOrEqual,
+// is.isLengthSmaller, is.isLengthSmallerOrEqual
+
+compareCount('abc', 3) // true
+
+// the length functions also exist as methods on the length checks:
+is.len.eq('abc', 'def') // true
 ```
 
 #### Changelog
@@ -416,6 +512,24 @@ update dependencies
 - add isIp and variants to allow ip v4 and v6 checks
 - update dependencies
 
-##### 0.1.40 - unreleased
+##### 0.1.40
+
+- add is.not negations of all type functions
+- update docs
+- update dependencies
+
+##### 0.1.41
+
+- isArray accepts type predicates and narrows the element type: `isArray(arr, isString, isNumber)` → `e is (string | number)[]`, falling back to `unknown[]` without predicates
+- change isArray return type from `unknown[]` to `any[]` in generated types
+- add `scripts/add-node-reference.mjs` and run it after tsc in the build so `Buffer` resolves in the generated `.d.ts` files
+- move `@types/node` from dependencies to devDependencies
+- add `oxlint.config.ts` and lint fixes (curly braces, unused `@ts-expect-error` removals)
+- use bundler module resolution in tsconfig, disable strict, add separate `tsconfig.test.json` for fixtures
+- update dependencies (@magic/core, @magic/format, @magic/lint, @magic/test, @swc/core)
+- update docs
+- update dependencies
+
+##### 0.1.42 - unreleased
 
-...
+- ...

package/package.json

@@ -1,13 +1,35 @@
 {
   "name": "@magic/types",
-  "version": "0.1.39",
-  "author": "Wizards & Witches",
+  "version": "0.1.41",
+  "description": "typechecking library",
+  "keywords": [
+    "magic",
+    "typechecking",
+    "types"
+  ],
   "homepage": "https://github.com/magic/types",
+  "bugs": {
+    "url": "https://github.com/magic/types/issues"
+  },
   "license": "AGPL-3.0",
-  "description": "typechecking library",
+  "author": "Wizards & Witches",
+  "contributors": [
+    {
+      "name": "jascha ehrenreich",
+      "github": "jaeh"
+    }
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/magic/types.git"
+  },
+  "files": [
+    "src",
+    "types"
+  ],
+  "type": "module",
   "main": "src/index.js",
   "types": "./types/index.d.ts",
-  "type": "module",
   "exports": {
     ".": {
       "import": "./src/index.js",
@@ -16,7 +38,7 @@
   },
   "scripts": {
     "start": "t",
-    "build": "tsc && npm run format",
+    "build": "tsc && node scripts/add-node-reference.mjs && npm run format",
     "prepublishOnly": "npm run test && npm run build",
     "build:docs": "NODE_ENV=production magic build",
     "prod": "NODE_ENV=production magic build serve",
@@ -27,50 +49,30 @@
     "format": "f -w --exclude docs",
     "format:check": "f --exclude docs",
     "calls": "calls",
-    "lint": "tsc --noEmit"
+    "tsc": "tsc --noEmit",
+    "tsc:test": "tsc --noEmit -p tsconfig.test.json",
+    "lint": "lint",
+    "check": "npm run tsc && npm run tsc:test && npm run lint"
   },
-  "engines": {
-    "node": ">=18"
-  },
-  "engineStrict": true,
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/magic/types.git"
-  },
-  "bugs": {
-    "url": "https://github.com/magic/types/issues"
-  },
-  "files": [
-    "src",
-    "types"
-  ],
   "devDependencies": {
     "@magic-modules/git-badges": "0.0.12",
     "@magic-modules/light-switch": "0.0.12",
     "@magic-modules/no-spy": "0.0.9",
     "@magic-modules/pre": "0.0.12",
     "@magic-themes/docs": "0.0.15",
-    "@magic/core": "0.0.159",
-    "@magic/format": "0.0.75",
-    "@magic/test": "0.3.23",
-    "typescript": "6.0.3"
+    "@magic/core": "0.0.161",
+    "@magic/format": "0.0.79",
+    "@magic/lint": "0.0.5",
+    "@magic/test": "0.3.55",
+    "@types/node": "26.6.6",
+    "typescript": "npm:@typescript/typescript6"
   },
-  "keywords": [
-    "magic",
-    "types",
-    "typechecking"
-  ],
-  "contributors": [
-    {
-      "name": "jascha ehrenreich",
-      "github": "jaeh"
-    }
-  ],
-  "dependencies": {
-    "@types/node": "26.1.0"
+  "engines": {
+    "node": ">=18"
   },
+  "engineStrict": true,
   "allowScripts": {
-    "@swc/core@1.3.41": true,
-    "canvas@3.2.3": true
+    "canvas@3.2.3": true,
+    "@swc/core@1.15.47": true
   }
 }

package/src/deep/index.js

@@ -11,10 +11,10 @@ export const deepDiff = different
 
 export const deep = {
   isDifferent: different,
-  different: different,
+  different,
   diff: different,
 
   isEqual: equal,
-  equal: equal,
+  equal,
   eq: equal,
 }

package/src/fns.js

@@ -1,9 +1,21 @@
+/// <reference types="node" />
 /**
  * Check if a value is an Array
- * @param {unknown} e - value to test
- * @returns {e is unknown[]} - true if value is an array
+ * @type {<P extends readonly ((e: unknown) => e is unknown)[]>(e: unknown, ...predicates: P) => e is P extends readonly [] ? unknown[] : (P[number] extends (e: unknown) => e is infer U ? U : never)[]}
  */
-export const isArray = e => Array.isArray(e)
+export const isArray = (e, ...predicates) => {
+  if (!Array.isArray(e)) {
+    return false
+  }
+
+  // If no predicates provided, just check if it's an array
+  if (predicates.length === 0) {
+    return true
+  }
+
+  // Each element must pass at least one predicate
+  return e.every(element => predicates.some(predicate => predicate(element)))
+}
 
 /**
  * Check if a value is a boolean
@@ -432,16 +444,26 @@ export const isArguments = e => Object.prototype.toString.call(e) === '[object A
  * @returns {boolean}
  */
 export const isUUID = e => {
-  if (!isDefined(e)) return false
-  if (!isString(e)) return false
+  if (!isDefined(e)) {
+    return false
+  }
+  if (!isString(e)) {
+    return false
+  }
 
   const split = e.split('-')
-  if (!isLengthEqual(split, 5)) return false
+  if (!isLengthEqual(split, 5)) {
+    return false
+  }
 
   const lengths = [8, 4, 4, 4, 12]
-  if (lengths.some((l, i) => split[i].length !== l)) return false
+  if (lengths.some((l, i) => split[i].length !== l)) {
+    return false
+  }
 
-  if (Object.values(e).some(s => s > 'f')) return false
+  if (Object.values(e).some(s => s > 'f')) {
+    return false
+  }
 
   return true
 }
@@ -638,9 +660,13 @@ isCase.lower = isLowerCase
  * @returns {boolean} - true if value is an IPv4 address
  */
 export const isIPv4 = a => {
-  if (!isString(a)) return false
+  if (!isString(a)) {
+    return false
+  }
   const parts = a.split('.')
-  if (parts.length !== 4) return false
+  if (parts.length !== 4) {
+    return false
+  }
   return parts.every(part => {
     const num = Number(part)
     return /^(\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5])$/.test(part) && String(num) === part

package/src/index.js

@@ -4,5 +4,6 @@ export * from './fns.js'
 export * as deep from './deep/index.js'
 
 export const is = def
+export const not = is.not
 
 export default is

package/src/lib.js

@@ -30,6 +30,16 @@ import * as deep from './deep/index.js'
  * }} EnhancedLengthFunction
  */
 
+/**
+ * The `is.not` namespace: the original `isNot` check function, extended at
+ * runtime (by `addNotFunctions`) with a negated version of every `is.*` check
+ * and their nested sub-checks (e.g. `.upper`, `.eq`, `.v4`, `deep`). Each
+ * added property is either a negated check function or an object of them.
+ * @typedef {((e: unknown, ...types: string[]) => boolean) & {
+ *   [key: string]: any
+ * }} NotNamespace
+ */
+
 // Create enhanced length functions with comparison methods
 const lengthFunctions = {
   eq: fns.isLengthEqual,
@@ -126,7 +136,7 @@ export const is = /** @type {const} */ {
   empty: fns.isEmpty,
 
   isNot: fns.isNot,
-  not: fns.isNot,
+  not: /** @type {NotNamespace} */ (fns.isNot),
   isNeq: fns.isNot,
   neq: fns.isNot,
 
@@ -343,4 +353,100 @@ export const is = /** @type {const} */ {
   ...deep,
 }
 
+/**
+ * Negation helper: creates a function that returns the logical NOT of fn
+ * @param {any} fn - function to negate
+ * @returns {(...args: any[]) => boolean} - negated function
+ */
+const negate =
+  fn =>
+  (...args) =>
+    !fn(...args)
+
+/**
+ * Add negated functions to the existing is.not namespace
+ * @param {any} obj - source object (the is namespace)
+ * @param {any} target - target object (the is.not namespace)
+ */
+const addNotFunctions = (obj, target) => {
+  // Skip certain properties that shouldn't be copied
+  const skipKeys = new Set(['length', 'name', 'prototype', 'caller', 'callee', 'arguments'])
+
+  for (const [key, value] of Object.entries(obj)) {
+    if (key === 'not' || skipKeys.has(key)) {
+      continue
+    }
+    if (fns.isFunction(value)) {
+      target[key] = negate(value)
+      // Handle function sub-properties (e.g., isCase.upper, isIp.v4)
+      if (value.upper) {
+        target[key].upper = negate(value.upper)
+      }
+      if (value.lower) {
+        target[key].lower = negate(value.lower)
+      }
+      if (value.v4) {
+        target[key].v4 = negate(value.v4)
+      }
+      if (value.v6) {
+        target[key].v6 = negate(value.v6)
+      }
+      // Handle all length comparison functions
+      if (value.eq) {
+        target[key].eq = negate(value.eq)
+      }
+      if (value.equal) {
+        target[key].equal = negate(value.equal)
+      }
+      if (value.gt) {
+        target[key].gt = negate(value.gt)
+      }
+      if (value.bigger) {
+        target[key].bigger = negate(value.bigger)
+      }
+      if (value.biggerequal) {
+        target[key].biggerequal = negate(value.biggerequal)
+      }
+      if (value.greater) {
+        target[key].greater = negate(value.greater)
+      }
+      if (value.greaterequal) {
+        target[key].greaterequal = negate(value.greaterequal)
+      }
+      if (value.gte) {
+        target[key].gte = negate(value.gte)
+      }
+      if (value.gteq) {
+        target[key].gteq = negate(value.gteq)
+      }
+      if (value.lower) {
+        target[key].lower = negate(value.lower)
+      }
+      if (value.smaller) {
+        target[key].smaller = negate(value.smaller)
+      }
+      if (value.lt) {
+        target[key].lt = negate(value.lt)
+      }
+      if (value.lowerequal) {
+        target[key].lowerequal = negate(value.lowerequal)
+      }
+      if (value.smallerequal) {
+        target[key].smallerequal = negate(value.smallerequal)
+      }
+      if (value.lte) {
+        target[key].lte = negate(value.lte)
+      }
+      if (value.lteq) {
+        target[key].lteq = negate(value.lteq)
+      }
+    } else if (fns.isObjectNative(value)) {
+      target[key] = {}
+      addNotFunctions(value, target[key])
+    }
+  }
+}
+
+addNotFunctions(is, is.not)
+
 export default is

package/types/fns.d.ts

@@ -1,4 +1,14 @@
-export function isArray(e: unknown): e is unknown[]
+/// <reference types="node" />
+/**
+ * Check if a value is an Array
+ * @type {<P extends readonly ((e: unknown) => e is unknown)[]>(e: unknown, ...predicates: P) => e is P extends readonly [] ? unknown[] : (P[number] extends (e: unknown) => e is infer U ? U : never)[]}
+ */
+export const isArray: <P extends readonly ((e: unknown) => e is unknown)[]>(
+  e: unknown,
+  ...predicates: P
+) => e is P extends readonly []
+  ? unknown[]
+  : (P[number] extends ((e: unknown) => e is infer U) ? U : never)[]
 export function isBoolean(e: unknown): e is boolean
 export function isDefined(e: unknown): e is NonNullable<unknown>
 export function isUndefined(e: unknown): e is undefined

package/types/index.d.ts

@@ -1,3 +1,4 @@
+/// <reference types="node" />
 export * from './fns.js'
 export * as deep from './deep/index.js'
 export const is: {
@@ -234,13 +235,33 @@ export const is: {
   isEmpty: (e: unknown) => boolean
   empty: (e: unknown) => boolean
   isNot: (e: unknown, ...types: string[]) => boolean
-  not: (e: unknown, ...types: string[]) => boolean
+  not: import('./lib.js').NotNamespace
   isNeq: (e: unknown, ...types: string[]) => boolean
   neq: (e: unknown, ...types: string[]) => boolean
-  isArray: (e: unknown) => e is unknown[]
-  isArr: (e: unknown) => e is unknown[]
-  array: (e: unknown) => e is unknown[]
-  arr: (e: unknown) => e is unknown[]
+  isArray: <P extends readonly ((e: unknown) => e is unknown)[]>(
+    e: unknown,
+    ...predicates: P
+  ) => e is P extends readonly []
+    ? unknown[]
+    : (P[number] extends ((e: unknown) => e is infer U) ? U : never)[]
+  isArr: <P extends readonly ((e: unknown) => e is unknown)[]>(
+    e: unknown,
+    ...predicates: P
+  ) => e is P extends readonly []
+    ? unknown[]
+    : (P[number] extends ((e: unknown) => e is infer U) ? U : never)[]
+  array: <P extends readonly ((e: unknown) => e is unknown)[]>(
+    e: unknown,
+    ...predicates: P
+  ) => e is P extends readonly []
+    ? unknown[]
+    : (P[number] extends ((e: unknown) => e is infer U) ? U : never)[]
+  arr: <P extends readonly ((e: unknown) => e is unknown)[]>(
+    e: unknown,
+    ...predicates: P
+  ) => e is P extends readonly []
+    ? unknown[]
+    : (P[number] extends ((e: unknown) => e is infer U) ? U : never)[]
   isBoolean: (e: unknown) => e is boolean
   isBool: (e: unknown) => e is boolean
   boolean: (e: unknown) => e is boolean
@@ -769,4 +790,5 @@ export const is: {
     (a: unknown): (c: unknown) => boolean
   }
 }
+export const not: import('./lib.js').NotNamespace
 export default is

package/types/lib.d.ts

@@ -1,3 +1,4 @@
+/// <reference types="node" />
 export const is: {
   isDeepEqual: {
     /**
@@ -232,13 +233,33 @@ export const is: {
   isEmpty: (e: unknown) => boolean
   empty: (e: unknown) => boolean
   isNot: (e: unknown, ...types: string[]) => boolean
-  not: (e: unknown, ...types: string[]) => boolean
+  not: NotNamespace
   isNeq: (e: unknown, ...types: string[]) => boolean
   neq: (e: unknown, ...types: string[]) => boolean
-  isArray: (e: unknown) => e is unknown[]
-  isArr: (e: unknown) => e is unknown[]
-  array: (e: unknown) => e is unknown[]
-  arr: (e: unknown) => e is unknown[]
+  isArray: <P extends readonly ((e: unknown) => e is unknown)[]>(
+    e: unknown,
+    ...predicates: P
+  ) => e is P extends readonly []
+    ? unknown[]
+    : (P[number] extends ((e: unknown) => e is infer U) ? U : never)[]
+  isArr: <P extends readonly ((e: unknown) => e is unknown)[]>(
+    e: unknown,
+    ...predicates: P
+  ) => e is P extends readonly []
+    ? unknown[]
+    : (P[number] extends ((e: unknown) => e is infer U) ? U : never)[]
+  array: <P extends readonly ((e: unknown) => e is unknown)[]>(
+    e: unknown,
+    ...predicates: P
+  ) => e is P extends readonly []
+    ? unknown[]
+    : (P[number] extends ((e: unknown) => e is infer U) ? U : never)[]
+  arr: <P extends readonly ((e: unknown) => e is unknown)[]>(
+    e: unknown,
+    ...predicates: P
+  ) => e is P extends readonly []
+    ? unknown[]
+    : (P[number] extends ((e: unknown) => e is infer U) ? U : never)[]
   isBoolean: (e: unknown) => e is boolean
   isBool: (e: unknown) => e is boolean
   boolean: (e: unknown) => e is boolean
@@ -787,4 +808,13 @@ export type EnhancedLengthFunction = typeof fns.getLength & {
   lte: LengthComparison
   lteq: LengthComparison
 }
+/**
+ * The `is.not` namespace: the original `isNot` check function, extended at
+ * runtime (by `addNotFunctions`) with a negated version of every `is.*` check
+ * and their nested sub-checks (e.g. `.upper`, `.eq`, `.v4`, `deep`). Each
+ * added property is either a negated check function or an object of them.
+ */
+export type NotNamespace = ((e: unknown, ...types: string[]) => boolean) & {
+  [key: string]: any
+}
 import * as fns from './fns.js'