is 3.0.1 → 3.3.0

package/CHANGELOG.md

@@ -1,3 +1,39 @@
+3.3.0 / 2018-12-14
+==================
+  * [New] add `is.bigint` (#36)
+  * [Docs] change jsdoc comments "Mixed" to wildcards (#34)
+  * [Tests] up to `node` `v11.4`, `v10.14`, `v9.11`, `v8.14`, `v7.10`, `v6.15`, `v4.9`; use `nvm install-latest-npm`
+  * [Dev Deps] update `eslint`, `@ljharb/eslint-config`, `safe-publish-latest`, `tape`
+
+3.2.1 / 2017-02-27
+==================
+  * [Fix] `is.fn`: recognize generator and async functions too (#28)
+  * [Tests] up to `node` `v7.5`, `v4.7`; improve test matrix
+  * [Dev Deps] update `@ljharb/eslint-config`, `eslint`, `tape`
+  * [Docs] improve readme formatting (#27)
+
+3.2.0 / 2016-10-24
+==================
+  * [Fix] fix infinite loop when comparing two empty arrays + fix skipping first element (#24, #25)
+  * [New] add `is.primitive`
+  * [New] Add `is.date.valid` function and tests (#19)
+  * [Tests] use `pretest` for `npm run lint`; add `npm run tests-only`
+  * [Tests] up to `node` `v4.6`, `v5.12`, `v6.9`; improve test matrix
+  * [Tests] fix description (#18)
+  * [Dev Deps] update `tape`, `jscs`, `eslint`, `@ljharb/eslint-config`
+
+3.1.0 / 2015-09-20
+==================
+  * [Enhancement]: `is.array`: Prefer `Array.isArray` when present
+  * [Fix] Deprecate `is.boolean`/`is.int` (ES3 syntax errors)
+  * [Docs] Switch from vb.teelaun.ch to versionbadg.es for the npm version badge SVG
+  * [Refactor] Don't use yoda conditions
+  * [Refactor] `is.equal` can return earlier in some cases (#16)
+  * [Tests] Quote "throws" (ES3 syntax error)
+  * [Tests] up to `io.js` `v3.3`, up to `node` `v4.1`
+  * [Dev Deps] add `npm run eslint`
+  * [Dev Deps] update `tape`, `covert`, `jscs`
+
 3.0.1 / 2015-02-22
 ==================
   * Version bump to resolve npm bug with v3.0.0

package/README.md

@@ -57,7 +57,8 @@ $ component install enricomarino/is
 
 ### boolean
 
- - ``is.boolean`` (value)
+ - ``is.bool`` (value)
+ - ``is.boolean`` (value) - deprecated, because in ES3 browsers, "boolean" is a reserved word
  - ``is.false`` (value) - deprecated, because in ES3 browsers, "false" is a reserved word
  - ``is.true`` (value) - deprecated, because in ES3 browsers, "true" is a reserved word
 
@@ -71,7 +72,7 @@ $ component install enricomarino/is
 
 ### error
 
- - is.error (value)
+ - ``is.error`` (value)
 
 ### function
 
@@ -84,7 +85,8 @@ $ component install enricomarino/is
  - ``is.infinite`` (value)
  - ``is.decimal`` (value)
  - ``is.divisibleBy`` (value, n)
- - ``is.int`` (value)
+ - ``is.integer`` (value)
+ - ``is.int`` (value) - deprecated, because in ES3 browsers, "int" is a reserved word
  - ``is.maximum`` (value, others)
  - ``is.minimum`` (value, others)
  - ``is.nan`` (value)
@@ -113,16 +115,18 @@ $ component install enricomarino/is
  - ``is.base64`` (value)
  - ``is.hex`` (value)
 
-### ES6 Symbols
+### Symbols
  - ``is.symbol`` (value)
 
+### BigInts
+ - ``is.bigint`` (value)
 
 ## Contributors
 
 - [Jordan Harband](https://github.com/ljharb)
 
 [npm-url]: https://npmjs.org/package/is
-[npm-version-svg]: http://vb.teelaun.ch/enricomarino/is.svg
+[npm-version-svg]: http://versionbadg.es/enricomarino/is.svg
 [travis-svg]: https://travis-ci.org/enricomarino/is.svg
 [travis-url]: https://travis-ci.org/enricomarino/is
 [deps-svg]: https://david-dm.org/enricomarino/is.svg

package/index.js

@@ -1,3 +1,6 @@
+/* globals window, HTMLElement */
+
+'use strict';
 
 /**!
  * is
@@ -14,11 +17,15 @@ var symbolValueOf;
 if (typeof Symbol === 'function') {
   symbolValueOf = Symbol.prototype.valueOf;
 }
+var bigIntValueOf;
+if (typeof BigInt === 'function') {
+  bigIntValueOf = BigInt.prototype.valueOf;
+}
 var isActualNaN = function (value) {
   return value !== value;
 };
 var NON_HOST_TYPES = {
-  boolean: 1,
+  'boolean': 1,
   number: 1,
   string: 1,
   undefined: 1
@@ -31,7 +38,7 @@ var hexRegex = /^[A-Fa-f0-9]+$/;
  * Expose `is`
  */
 
-var is = module.exports = {};
+var is = {};
 
 /**
  * Test general.
@@ -41,7 +48,7 @@ var is = module.exports = {};
  * is.type
  * Test if `value` is a type of `type`.
  *
- * @param {Mixed} value value to test
+ * @param {*} value value to test
  * @param {String} type type
  * @return {Boolean} true if `value` is a type of `type`, false otherwise
  * @api public
@@ -55,7 +62,7 @@ is.a = is.type = function (value, type) {
  * is.defined
  * Test if `value` is defined.
  *
- * @param {Mixed} value value to test
+ * @param {*} value value to test
  * @return {Boolean} true if 'value' is defined, false otherwise
  * @api public
  */
@@ -68,7 +75,7 @@ is.defined = function (value) {
  * is.empty
  * Test if `value` is empty.
  *
- * @param {Mixed} value value to test
+ * @param {*} value value to test
  * @return {Boolean} true if `value` is empty, false otherwise
  * @api public
  */
@@ -77,13 +84,15 @@ is.empty = function (value) {
   var type = toStr.call(value);
   var key;
 
-  if ('[object Array]' === type || '[object Arguments]' === type || '[object String]' === type) {
+  if (type === '[object Array]' || type === '[object Arguments]' || type === '[object String]') {
     return value.length === 0;
   }
 
-  if ('[object Object]' === type) {
+  if (type === '[object Object]') {
     for (key in value) {
-      if (owns.call(value, key)) { return false; }
+      if (owns.call(value, key)) {
+        return false;
+      }
     }
     return true;
   }
@@ -95,14 +104,13 @@ is.empty = function (value) {
  * is.equal
  * Test if `value` is equal to `other`.
  *
- * @param {Mixed} value value to test
- * @param {Mixed} other value to compare with
+ * @param {*} value value to test
+ * @param {*} other value to compare with
  * @return {Boolean} true if `value` is equal to `other`, false otherwise
  */
 
-is.equal = function (value, other) {
-  var strictlyEqual = value === other;
-  if (strictlyEqual) {
+is.equal = function equal(value, other) {
+  if (value === other) {
     return true;
   }
 
@@ -113,7 +121,7 @@ is.equal = function (value, other) {
     return false;
   }
 
-  if ('[object Object]' === type) {
+  if (type === '[object Object]') {
     for (key in value) {
       if (!is.equal(value[key], other[key]) || !(key in other)) {
         return false;
@@ -127,12 +135,12 @@ is.equal = function (value, other) {
     return true;
   }
 
-  if ('[object Array]' === type) {
+  if (type === '[object Array]') {
     key = value.length;
     if (key !== other.length) {
       return false;
     }
-    while (--key) {
+    while (key--) {
       if (!is.equal(value[key], other[key])) {
         return false;
       }
@@ -140,23 +148,23 @@ is.equal = function (value, other) {
     return true;
   }
 
-  if ('[object Function]' === type) {
+  if (type === '[object Function]') {
     return value.prototype === other.prototype;
   }
 
-  if ('[object Date]' === type) {
+  if (type === '[object Date]') {
     return value.getTime() === other.getTime();
   }
 
-  return strictlyEqual;
+  return false;
 };
 
 /**
  * is.hosted
  * Test if `value` is hosted by `host`.
  *
- * @param {Mixed} value to test
- * @param {Mixed} host host to test with
+ * @param {*} value to test
+ * @param {*} host host to test with
  * @return {Boolean} true if `value` is hosted by `host`, false otherwise
  * @api public
  */
@@ -170,7 +178,7 @@ is.hosted = function (value, host) {
  * is.instance
  * Test if `value` is an instance of `constructor`.
  *
- * @param {Mixed} value value to test
+ * @param {*} value value to test
  * @return {Boolean} true if `value` is an instance of `constructor`
  * @api public
  */
@@ -183,7 +191,7 @@ is.instance = is['instanceof'] = function (value, constructor) {
  * is.nil / is.null
  * Test if `value` is null.
  *
- * @param {Mixed} value value to test
+ * @param {*} value value to test
  * @return {Boolean} true if `value` is null, false otherwise
  * @api public
  */
@@ -196,7 +204,7 @@ is.nil = is['null'] = function (value) {
  * is.undef / is.undefined
  * Test if `value` is undefined.
  *
- * @param {Mixed} value value to test
+ * @param {*} value value to test
  * @return {Boolean} true if `value` is undefined, false otherwise
  * @api public
  */
@@ -213,13 +221,13 @@ is.undef = is.undefined = function (value) {
  * is.args
  * Test if `value` is an arguments object.
  *
- * @param {Mixed} value value to test
+ * @param {*} value value to test
  * @return {Boolean} true if `value` is an arguments object, false otherwise
  * @api public
  */
 
 is.args = is.arguments = function (value) {
-  var isStandardArguments = '[object Arguments]' === toStr.call(value);
+  var isStandardArguments = toStr.call(value) === '[object Arguments]';
   var isOldArguments = !is.array(value) && is.arraylike(value) && is.object(value) && is.fn(value.callee);
   return isStandardArguments || isOldArguments;
 };
@@ -232,20 +240,20 @@ is.args = is.arguments = function (value) {
  * is.array
  * Test if 'value' is an array.
  *
- * @param {Mixed} value value to test
+ * @param {*} value value to test
  * @return {Boolean} true if `value` is an array, false otherwise
  * @api public
  */
 
-is.array = function (value) {
-  return '[object Array]' === toStr.call(value);
+is.array = Array.isArray || function (value) {
+  return toStr.call(value) === '[object Array]';
 };
 
 /**
  * is.arguments.empty
  * Test if `value` is an empty arguments object.
  *
- * @param {Mixed} value value to test
+ * @param {*} value value to test
  * @return {Boolean} true if `value` is an empty arguments object, false otherwise
  * @api public
  */
@@ -257,7 +265,7 @@ is.args.empty = function (value) {
  * is.array.empty
  * Test if `value` is an empty array.
  *
- * @param {Mixed} value value to test
+ * @param {*} value value to test
  * @return {Boolean} true if `value` is an empty array, false otherwise
  * @api public
  */
@@ -269,13 +277,13 @@ is.array.empty = function (value) {
  * is.arraylike
  * Test if `value` is an arraylike object.
  *
- * @param {Mixed} value value to test
+ * @param {*} value value to test
  * @return {Boolean} true if `value` is an arguments object, false otherwise
  * @api public
  */
 
 is.arraylike = function (value) {
-  return !!value && !is.boolean(value)
+  return !!value && !is.bool(value)
     && owns.call(value, 'length')
     && isFinite(value.length)
     && is.number(value.length)
@@ -287,42 +295,42 @@ is.arraylike = function (value) {
  */
 
 /**
- * is.boolean
+ * is.bool
  * Test if `value` is a boolean.
  *
- * @param {Mixed} value value to test
+ * @param {*} value value to test
  * @return {Boolean} true if `value` is a boolean, false otherwise
  * @api public
  */
 
-is.boolean = function (value) {
-  return '[object Boolean]' === toStr.call(value);
+is.bool = is['boolean'] = function (value) {
+  return toStr.call(value) === '[object Boolean]';
 };
 
 /**
  * is.false
  * Test if `value` is false.
  *
- * @param {Mixed} value value to test
+ * @param {*} value value to test
  * @return {Boolean} true if `value` is false, false otherwise
  * @api public
  */
 
 is['false'] = function (value) {
-  return is.boolean(value) && Boolean(Number(value)) === false;
+  return is.bool(value) && Boolean(Number(value)) === false;
 };
 
 /**
  * is.true
  * Test if `value` is true.
  *
- * @param {Mixed} value value to test
+ * @param {*} value value to test
  * @return {Boolean} true if `value` is true, false otherwise
  * @api public
  */
 
 is['true'] = function (value) {
-  return is.boolean(value) && Boolean(Number(value)) === true;
+  return is.bool(value) && Boolean(Number(value)) === true;
 };
 
 /**
@@ -333,13 +341,24 @@ is['true'] = function (value) {
  * is.date
  * Test if `value` is a date.
  *
- * @param {Mixed} value value to test
+ * @param {*} value value to test
  * @return {Boolean} true if `value` is a date, false otherwise
  * @api public
  */
 
 is.date = function (value) {
-  return '[object Date]' === toStr.call(value);
+  return toStr.call(value) === '[object Date]';
+};
+
+/**
+ * is.date.valid
+ * Test if `value` is a valid date.
+ *
+ * @param {*} value value to test
+ * @returns {Boolean} true if `value` is a valid date, false otherwise
+ */
+is.date.valid = function (value) {
+  return is.date(value) && !isNaN(Number(value));
 };
 
 /**
@@ -350,7 +369,7 @@ is.date = function (value) {
  * is.element
  * Test if `value` is an html element.
  *
- * @param {Mixed} value value to test
+ * @param {*} value value to test
  * @return {Boolean} true if `value` is an HTML Element, false otherwise
  * @api public
  */
@@ -370,13 +389,13 @@ is.element = function (value) {
  * is.error
  * Test if `value` is an error object.
  *
- * @param {Mixed} value value to test
+ * @param {*} value value to test
  * @return {Boolean} true if `value` is an error object, false otherwise
  * @api public
  */
 
 is.error = function (value) {
-  return '[object Error]' === toStr.call(value);
+  return toStr.call(value) === '[object Error]';
 };
 
 /**
@@ -387,14 +406,18 @@ is.error = function (value) {
  * is.fn / is.function (deprecated)
  * Test if `value` is a function.
  *
- * @param {Mixed} value value to test
+ * @param {*} value value to test
  * @return {Boolean} true if `value` is a function, false otherwise
  * @api public
  */
 
 is.fn = is['function'] = function (value) {
   var isAlert = typeof window !== 'undefined' && value === window.alert;
-  return isAlert || '[object Function]' === toStr.call(value);
+  if (isAlert) {
+    return true;
+  }
+  var str = toStr.call(value);
+  return str === '[object Function]' || str === '[object GeneratorFunction]' || str === '[object AsyncFunction]';
 };
 
 /**
@@ -405,20 +428,20 @@ is.fn = is['function'] = function (value) {
  * is.number
  * Test if `value` is a number.
  *
- * @param {Mixed} value value to test
+ * @param {*} value value to test
  * @return {Boolean} true if `value` is a number, false otherwise
  * @api public
  */
 
 is.number = function (value) {
-  return '[object Number]' === toStr.call(value);
+  return toStr.call(value) === '[object Number]';
 };
 
 /**
  * is.infinite
  * Test if `value` is positive or negative infinity.
  *
- * @param {Mixed} value value to test
+ * @param {*} value value to test
  * @return {Boolean} true if `value` is positive or negative Infinity, false otherwise
  * @api public
  */
@@ -430,7 +453,7 @@ is.infinite = function (value) {
  * is.decimal
  * Test if `value` is a decimal number.
  *
- * @param {Mixed} value value to test
+ * @param {*} value value to test
  * @return {Boolean} true if `value` is a decimal number, false otherwise
  * @api public
  */
@@ -457,7 +480,7 @@ is.divisibleBy = function (value, n) {
 };
 
 /**
- * is.int
+ * is.integer
  * Test if `value` is an integer.
  *
  * @param value to test
@@ -465,7 +488,7 @@ is.divisibleBy = function (value, n) {
  * @api public
  */
 
-is.int = function (value) {
+is.integer = is['int'] = function (value) {
   return is.number(value) && !isActualNaN(value) && value % 1 === 0;
 };
 
@@ -527,7 +550,7 @@ is.minimum = function (value, others) {
  * is.nan
  * Test if `value` is not a number.
  *
- * @param {Mixed} value value to test
+ * @param {*} value value to test
  * @return {Boolean} true if `value` is not a number, false otherwise
  * @api public
  */
@@ -658,20 +681,37 @@ is.within = function (value, start, finish) {
  * is.object
  * Test if `value` is an object.
  *
- * @param {Mixed} value value to test
+ * @param {*} value value to test
  * @return {Boolean} true if `value` is an object, false otherwise
  * @api public
  */
-
 is.object = function (value) {
-  return '[object Object]' === toStr.call(value);
+  return toStr.call(value) === '[object Object]';
+};
+
+/**
+ * is.primitive
+ * Test if `value` is a primitive.
+ *
+ * @param {*} value value to test
+ * @return {Boolean} true if `value` is a primitive, false otherwise
+ * @api public
+ */
+is.primitive = function isPrimitive(value) {
+  if (!value) {
+    return true;
+  }
+  if (typeof value === 'object' || is.object(value) || is.fn(value) || is.array(value)) {
+    return false;
+  }
+  return true;
 };
 
 /**
  * is.hash
  * Test if `value` is a hash - a plain object literal.
  *
- * @param {Mixed} value value to test
+ * @param {*} value value to test
  * @return {Boolean} true if `value` is a hash, false otherwise
  * @api public
  */
@@ -688,13 +728,13 @@ is.hash = function (value) {
  * is.regexp
  * Test if `value` is a regular expression.
  *
- * @param {Mixed} value value to test
+ * @param {*} value value to test
  * @return {Boolean} true if `value` is a regexp, false otherwise
  * @api public
  */
 
 is.regexp = function (value) {
-  return '[object RegExp]' === toStr.call(value);
+  return toStr.call(value) === '[object RegExp]';
 };
 
 /**
@@ -705,13 +745,13 @@ is.regexp = function (value) {
  * is.string
  * Test if `value` is a string.
  *
- * @param {Mixed} value value to test
+ * @param {*} value value to test
  * @return {Boolean} true if 'value' is a string, false otherwise
  * @api public
  */
 
 is.string = function (value) {
-  return '[object String]' === toStr.call(value);
+  return toStr.call(value) === '[object String]';
 };
 
 /**
@@ -722,7 +762,7 @@ is.string = function (value) {
  * is.base64
  * Test if `value` is a valid base64 encoded string.
  *
- * @param {Mixed} value value to test
+ * @param {*} value value to test
  * @return {Boolean} true if 'value' is a base64 encoded string, false otherwise
  * @api public
  */
@@ -739,7 +779,7 @@ is.base64 = function (value) {
  * is.hex
  * Test if `value` is a valid hex encoded string.
  *
- * @param {Mixed} value value to test
+ * @param {*} value value to test
  * @return {Boolean} true if 'value' is a hex encoded string, false otherwise
  * @api public
  */
@@ -752,7 +792,7 @@ is.hex = function (value) {
  * is.symbol
  * Test if `value` is an ES6 Symbol
  *
- * @param {Mixed} value value to test
+ * @param {*} value value to test
  * @return {Boolean} true if `value` is a Symbol, false otherise
  * @api public
  */
@@ -760,3 +800,19 @@ is.hex = function (value) {
 is.symbol = function (value) {
   return typeof Symbol === 'function' && toStr.call(value) === '[object Symbol]' && typeof symbolValueOf.call(value) === 'symbol';
 };
+
+/**
+ * is.bigint
+ * Test if `value` is an ES-proposed BigInt
+ *
+ * @param {*} value value to test
+ * @return {Boolean} true if `value` is a BigInt, false otherise
+ * @api public
+ */
+
+is.bigint = function (value) {
+  // eslint-disable-next-line valid-typeof
+  return typeof BigInt === 'function' && toStr.call(value) === '[object BigInt]' && typeof bigIntValueOf.call(value) === 'bigint';
+};
+
+module.exports = is;

package/package.json

@@ -1,12 +1,17 @@
 {
   "name": "is",
-  "version": "3.0.1",
+  "version": "3.3.0",
   "main": "index.js",
   "scripts": {
-    "test": "npm run lint && node test/index.js",
+    "prepublish": "safe-publish-latest",
+    "pretest": "npm run lint",
+    "test": "npm run --silent tests-only",
+    "tests-only": "node test/index.js",
     "coverage": "covert test/index.js",
     "coverage-quiet": "covert test/index.js --quiet",
-    "lint": "jscs *.js */*.js"
+    "lint": "npm run jscs && npm run eslint",
+    "jscs": "jscs *.js */*.js",
+    "eslint": "eslint ."
   },
   "author": {
     "name": "Enrico Marino",
@@ -32,10 +37,14 @@
   ],
   "dependencies": {},
   "devDependencies": {
-    "tape": "^3.5.0",
+    "@ljharb/eslint-config": "^13.0.0",
+    "covert": "^1.1.0",
+    "eslint": "^5.10.0",
     "foreach": "^2.0.5",
-    "covert": "^1.0.1",
-    "jscs": "^1.11.3"
+    "jscs": "^3.0.7",
+    "make-generator-function": "^1.1.0",
+    "safe-publish-latest": "^1.1.2",
+    "tape": "^4.9.1"
   },
   "testling": {
     "files": "test/index.js",
@@ -58,4 +67,3 @@
     "node": "*"
   }
 }
-

package/test/index.js

@@ -1,9 +1,15 @@
+/* globals window, document, HTMLElement */
+
+'use strict';
+
 var test = require('tape');
 var is = require('../index.js');
 
 var forEach = require('foreach');
 var toStr = Object.prototype.toString;
 
+var genFn = require('make-generator-function');
+
 test('is.type', function (t) {
   var booleans = [true, false];
   forEach(booleans, function (boolean) {
@@ -41,13 +47,13 @@ test('is.undef', function (t) {
 test('is.defined', function (t) {
   t.notOk(is.defined(), 'undefined is not defined');
   t.ok(is.defined(null), 'null is defined');
-  t.ok(is.defined({}), 'object is undefined');
+  t.ok(is.defined({}), 'object is defined');
   t.end();
 });
 
 test('is.empty', function (t) {
   t.ok(is.empty(''), 'empty string is empty');
-  t.ok(is.empty(new String()), 'empty String object is empty');
+  t.ok(is.empty(Object('')), 'empty String object is empty');
   t.ok(is.empty([]), 'empty array is empty');
   t.ok(is.empty({}), 'empty object is empty');
   t.ok(is.empty(null), 'null is empty');
@@ -56,7 +62,9 @@ test('is.empty', function (t) {
   t.ok(is.empty(false), 'false is empty');
   t.ok(is.empty(0), '0 is empty');
   t.ok(is.empty(NaN), 'nan is empty');
-  (function () { t.ok(is.empty(arguments), 'empty arguments is empty'); }());
+  (function () {
+    t.ok(is.empty(arguments), 'empty arguments is empty');
+  }());
   t.notOk(is.empty({ a: 1 }), 'nonempty object is not empty');
   t.notOk(is.empty(true), 'true is not empty');
   t.notOk(is.empty(/a/g), 'regex is not empty');
@@ -77,8 +85,10 @@ test('is.equal', function (t) {
   t.test('arrays', function (at) {
     at.ok(is.equal([1, 2, 3], [1, 2, 3]), 'arrays are shallowly equal');
     at.ok(is.equal([1, 2, [3, 4]], [1, 2, [3, 4]]), 'arrays are deep equal');
+    at.notOk(is.equal([1, 2, 3], [5, 2, 3]), 'inequal arrays are not equal');
     at.notOk(is.equal([1, 2], [2, 3]), 'inequal arrays are not equal');
     at.notOk(is.equal([1, 2, 3], [2, 3]), 'inequal length arrays are not equal');
+    at.ok(is.equal([], []), 'empty arrays are equal');
 
     var arr = [1, 2];
     at.ok(is.equal(arr, arr), 'array is equal to itself');
@@ -175,11 +185,15 @@ test('is.nil', function (t) {
 
 test('is.args', function (t) {
   t.notOk(is.args([]), 'array is not arguments');
-  (function () { t.ok(is.args(arguments), 'arguments is arguments'); }());
-  (function () { t.notOk(is.args(Array.prototype.slice.call(arguments)), 'sliced arguments is not arguments'); }());
+  (function () {
+    t.ok(is.args(arguments), 'arguments is arguments');
+  }());
+  (function () {
+    t.notOk(is.args(Array.prototype.slice.call(arguments)), 'sliced arguments is not arguments');
+  }());
   var fakeOldArguments = {
-    length: 3,
-    callee: function () {}
+    callee: function () {},
+    length: 3
   };
   t.ok(is.args(fakeOldArguments), 'old-style arguments object is arguments');
   t.end();
@@ -187,22 +201,31 @@ test('is.args', function (t) {
 
 test('is.args.empty', function (t) {
   t.notOk(is.args.empty([]), 'empty array is not empty arguments');
-  (function () { t.ok(is.args.empty(arguments), 'empty arguments is empty arguments'); }());
-  (function () { t.notOk(is.args.empty(Array.prototype.slice.call(arguments)), 'empty sliced arguments is not empty arguments'); }());
+  (function () {
+    t.ok(is.args.empty(arguments), 'empty arguments is empty arguments');
+  }());
+  (function () {
+    t.notOk(is.args.empty(Array.prototype.slice.call(arguments)), 'empty sliced arguments is not empty arguments');
+  }());
   t.end();
 });
 
-
 test('is.array', function (t) {
   t.ok(is.array([]), 'array is array');
-  (function () { t.ok(is.array(Array.prototype.slice.call(arguments)), 'sliced arguments is array'); }());
+  (function () {
+    t.ok(is.array(Array.prototype.slice.call(arguments)), 'sliced arguments is array');
+  }());
   t.end();
 });
 
 test('is.array.empty', function (t) {
   t.ok(is.array.empty([]), 'empty array is empty array');
-  (function () { t.notOk(is.array.empty(arguments), 'empty arguments is not empty array'); }());
-  (function () { t.ok(is.array.empty(Array.prototype.slice.call(arguments)), 'empty sliced arguments is empty array'); }());
+  (function () {
+    t.notOk(is.array.empty(arguments), 'empty arguments is not empty array');
+  }());
+  (function () {
+    t.ok(is.array.empty(Array.prototype.slice.call(arguments)), 'empty sliced arguments is empty array');
+  }());
   t.end();
 });
 
@@ -218,25 +241,29 @@ test('is.isarraylike', function (t) {
   t.notOk(is.arraylike({ length: 'foo' }), 'object with string length is not array-like');
   t.notOk(is.arraylike({ length: '' }), 'object with empty string length is not array-like');
   t.ok(is.arraylike([]), 'array is array-like');
-  (function () { t.ok(is.arraylike(arguments), 'empty arguments is array-like'); }());
-  (function () { t.ok(is.arraylike(arguments), 'nonempty arguments is array-like'); }(1, 2, 3));
+  (function () {
+    t.ok(is.arraylike(arguments), 'empty arguments is array-like');
+  }());
+  (function () {
+    t.ok(is.arraylike(arguments), 'nonempty arguments is array-like');
+  }(1, 2, 3));
   t.end();
 });
 
-test('is.boolean', function (t) {
-  t.ok(is.boolean(true), 'literal true is a boolean');
-  t.ok(is.boolean(false), 'literal false is a boolean');
-  t.ok(is.boolean(new Boolean(true)), 'object true is a boolean');
-  t.ok(is.boolean(new Boolean(false)), 'object false is a boolean');
-  t.notOk(is.boolean(), 'undefined is not a boolean');
-  t.notOk(is.boolean(null), 'null is not a boolean');
+test('is.bool', function (t) {
+  t.ok(is.bool(true), 'literal true is a boolean');
+  t.ok(is.bool(false), 'literal false is a boolean');
+  t.ok(is.bool(Object(true)), 'object true is a boolean');
+  t.ok(is.bool(Object(false)), 'object false is a boolean');
+  t.notOk(is.bool(), 'undefined is not a boolean');
+  t.notOk(is.bool(null), 'null is not a boolean');
   t.end();
 });
 
 test('is.false', function (t) {
   var isFalse = is['false'];
   t.ok(isFalse(false), 'false is false');
-  t.ok(isFalse(new Boolean(false)), 'object false is false');
+  t.ok(isFalse(Object(false)), 'object false is false');
   t.notOk(isFalse(true), 'true is not false');
   t.notOk(isFalse(), 'undefined is not false');
   t.notOk(isFalse(null), 'null is not false');
@@ -247,7 +274,7 @@ test('is.false', function (t) {
 test('is.true', function (t) {
   var isTrue = is['true'];
   t.ok(isTrue(true), 'true is true');
-  t.ok(isTrue(new Boolean(true)), 'object true is true');
+  t.ok(isTrue(Object(true)), 'object true is true');
   t.notOk(isTrue(false), 'false is not true');
   t.notOk(isTrue(), 'undefined is not true');
   t.notOk(isTrue(null), 'null is not true');
@@ -268,15 +295,22 @@ test('is.date', function (t) {
   t.end();
 });
 
+test('is.date.valid', function (t) {
+  t.ok(is.date.valid(new Date()), 'new Date() is a valid date');
+  t.notOk(is.date.valid(new Date('')), 'new Date("") is not a valid date');
+  t.end();
+});
+
 test('is.element', function (t) {
   t.notOk(is.element(), 'undefined is not element');
-  if (typeof HTMLElement !== 'undefined') {
+
+  t.test('when HTMLElement exists', { skip: typeof HTMLElement === 'undefined' }, function (st) {
     var element = document.createElement('div');
-    t.ok(is.element(element), 'HTMLElement is element');
-    t.notOk(is.element({ nodeType: 1 }), 'object with nodeType is not element');
-  } else {
-    t.ok(true, 'Skipping is.element test in a non-browser environment');
-  }
+    st.ok(is.element(element), 'HTMLElement is element');
+    st.notOk(is.element({ nodeType: 1 }), 'object with nodeType is not element');
+    st.end();
+  });
+
   t.end();
 });
 
@@ -284,7 +318,11 @@ test('is.error', function (t) {
   var err = new Error('foo');
   t.ok(is.error(err), 'Error is error');
   t.notOk(is.error({}), 'object is not error');
-  var objWithErrorToString = { toString: function () { return '[object Error]'; } };
+  var objWithErrorToString = {
+    toString: function () {
+      return '[object Error]';
+    }
+  };
   t.equal(String(objWithErrorToString), toStr.call(new Error()), 'obj has Error\'s toString');
   t.notOk(is.error(objWithErrorToString), 'object with Error\'s toString is not error');
   t.end();
@@ -293,13 +331,18 @@ test('is.error', function (t) {
 test('is.fn', function (t) {
   t.equal(is['function'], is.fn, 'alias works');
   t.ok(is.fn(function () {}), 'function is function');
-  t.ok(is.fn(console.log), 'console.log is function');
   if (typeof window !== 'undefined') {
     // in IE7/8, typeof alert === 'object'
     t.ok(is.fn(window.alert), 'window.alert is function');
   }
   t.notOk(is.fn({}), 'object is not function');
   t.notOk(is.fn(null), 'null is not function');
+
+  t.test('generator functions', { skip: !genFn }, function (st) {
+    t.ok(is.fn(genFn), 'generator function is function');
+    st.end();
+  });
+
   t.end();
 });
 
@@ -310,7 +353,7 @@ test('is.number', function (t) {
   t.ok(is.number(NaN), 'NaN is number');
   t.ok(is.number(Infinity), 'infinity is number');
   t.ok(is.number(-Infinity), 'negative infinity is number');
-  t.ok(is.number(new Number(42)), 'object number is number');
+  t.ok(is.number(Object(42)), 'object number is number');
   t.notOk(is.number(), 'undefined is not number');
   t.notOk(is.number(null), 'null is not number');
   t.notOk(is.number(true), 'true is not number');
@@ -349,14 +392,14 @@ test('is.divisibleBy', function (t) {
   t.end();
 });
 
-test('is.int', function (t) {
-  t.ok(is.int(0), '0 is integer');
-  t.ok(is.int(3), '3 is integer');
-  t.notOk(is.int(1.1), '1.1 is not integer');
-  t.notOk(is.int(NaN), 'NaN is not integer');
-  t.notOk(is.int(Infinity), 'infinity is not integer');
-  t.notOk(is.int(null), 'null is not integer');
-  t.notOk(is.int(), 'undefined is not integer');
+test('is.integer', function (t) {
+  t.ok(is.integer(0), '0 is integer');
+  t.ok(is.integer(3), '3 is integer');
+  t.notOk(is.integer(1.1), '1.1 is not integer');
+  t.notOk(is.integer(NaN), 'NaN is not integer');
+  t.notOk(is.integer(Infinity), 'infinity is not integer');
+  t.notOk(is.integer(null), 'null is not integer');
+  t.notOk(is.integer(), 'undefined is not integer');
   t.end();
 });
 
@@ -368,11 +411,11 @@ test('is.maximum', function (t) {
   t.notOk(is.maximum(2, [1, 2, 3]), '2 is not maximum of [1,2,3]');
 
   var nanError = new TypeError('NaN is not a valid value');
-  t.throws(function () { return is.maximum(NaN); }, nanError, 'throws when first value is NaN');
+  t['throws'](function () { return is.maximum(NaN); }, nanError, 'throws when first value is NaN');
 
   var error = new TypeError('second argument must be array-like');
-  t.throws(function () { return is.maximum(2, null); }, error, 'throws when second value is not array-like');
-  t.throws(function () { return is.maximum(2, {}); }, error, 'throws when second value is not array-like');
+  t['throws'](function () { return is.maximum(2, null); }, error, 'throws when second value is not array-like');
+  t['throws'](function () { return is.maximum(2, {}); }, error, 'throws when second value is not array-like');
   t.end();
 });
 
@@ -383,11 +426,11 @@ test('is.minimum', function (t) {
   t.notOk(is.minimum(2, [1, 2, 3]), '2 is not minimum of [1,2,3]');
 
   var nanError = new TypeError('NaN is not a valid value');
-  t.throws(function () { return is.minimum(NaN); }, nanError, 'throws when first value is NaN');
+  t['throws'](function () { return is.minimum(NaN); }, nanError, 'throws when first value is NaN');
 
   var error = new TypeError('second argument must be array-like');
-  t.throws(function () { return is.minimum(2, null); }, error, 'throws when second value is not array-like');
-  t.throws(function () { return is.minimum(2, {}); }, error, 'throws when second value is not array-like');
+  t['throws'](function () { return is.minimum(2, null); }, error, 'throws when second value is not array-like');
+  t['throws'](function () { return is.minimum(2, {}); }, error, 'throws when second value is not array-like');
   t.end();
 });
 
@@ -438,8 +481,8 @@ test('is.ge', function (t) {
   t.notOk(is.ge(Infinity, 0), 'infinity is not greater than anything');
   t.notOk(is.ge(0, Infinity), 'anything is not greater than infinity');
   var error = new TypeError('NaN is not a valid value');
-  t.throws(function () { return is.ge(NaN, 2); }, error, 'throws when first value is NaN');
-  t.throws(function () { return is.ge(2, NaN); }, error, 'throws when second value is NaN');
+  t['throws'](function () { return is.ge(NaN, 2); }, error, 'throws when first value is NaN');
+  t['throws'](function () { return is.ge(2, NaN); }, error, 'throws when second value is NaN');
   t.end();
 });
 
@@ -453,8 +496,8 @@ test('is.gt', function (t) {
   t.notOk(is.gt(Infinity, 0), 'infinity is not greater than anything');
   t.notOk(is.gt(0, Infinity), 'anything is not greater than infinity');
   var error = new TypeError('NaN is not a valid value');
-  t.throws(function () { return is.gt(NaN, 2); }, error, 'throws when first value is NaN');
-  t.throws(function () { return is.gt(2, NaN); }, error, 'throws when second value is NaN');
+  t['throws'](function () { return is.gt(NaN, 2); }, error, 'throws when first value is NaN');
+  t['throws'](function () { return is.gt(2, NaN); }, error, 'throws when second value is NaN');
   t.end();
 });
 
@@ -468,8 +511,8 @@ test('is.le', function (t) {
   t.notOk(is.le(Infinity, 0), 'infinity is not lesser than or equal to anything');
   t.notOk(is.le(0, Infinity), 'anything is not lesser than or equal to infinity');
   var error = new TypeError('NaN is not a valid value');
-  t.throws(function () { return is.le(NaN, 2); }, error, 'throws when first value is NaN');
-  t.throws(function () { return is.le(2, NaN); }, error, 'throws when second value is NaN');
+  t['throws'](function () { return is.le(NaN, 2); }, error, 'throws when first value is NaN');
+  t['throws'](function () { return is.le(2, NaN); }, error, 'throws when second value is NaN');
   t.end();
 });
 
@@ -483,30 +526,36 @@ test('is.lt', function (t) {
   t.notOk(is.lt(Infinity, 0), 'infinity is not lesser than anything');
   t.notOk(is.lt(0, Infinity), 'anything is not lesser than infinity');
   var error = new TypeError('NaN is not a valid value');
-  t.throws(function () { return is.lt(NaN, 2); }, error, 'throws when first value is NaN');
-  t.throws(function () { return is.lt(2, NaN); }, error, 'throws when second value is NaN');
+  t['throws'](function () { return is.lt(NaN, 2); }, error, 'throws when first value is NaN');
+  t['throws'](function () { return is.lt(2, NaN); }, error, 'throws when second value is NaN');
   t.end();
 });
 
 test('is.within', function (t) {
-  var nanError = new TypeError('NaN is not a valid value');
-  t.throws(function () { return is.within(NaN, 0, 0); }, nanError, 'throws when first value is NaN');
-  t.throws(function () { return is.within(0, NaN, 0); }, nanError, 'throws when second value is NaN');
-  t.throws(function () { return is.within(0, 0, NaN); }, nanError, 'throws when third value is NaN');
-
-  var error = new TypeError('all arguments must be numbers');
-  t.throws(function () { return is.within('', 0, 0); }, error, 'throws when first value is string');
-  t.throws(function () { return is.within(0, '', 0); }, error, 'throws when second value is string');
-  t.throws(function () { return is.within(0, 0, ''); }, error, 'throws when third value is string');
-  t.throws(function () { return is.within({}, 0, 0); }, error, 'throws when first value is object');
-  t.throws(function () { return is.within(0, {}, 0); }, error, 'throws when second value is object');
-  t.throws(function () { return is.within(0, 0, {}); }, error, 'throws when third value is object');
-  t.throws(function () { return is.within(null, 0, 0); }, error, 'throws when first value is null');
-  t.throws(function () { return is.within(0, null, 0); }, error, 'throws when second value is null');
-  t.throws(function () { return is.within(0, 0, null); }, error, 'throws when third value is null');
-  t.throws(function () { return is.within(undefined, 0, 0); }, error, 'throws when first value is undefined');
-  t.throws(function () { return is.within(0, undefined, 0); }, error, 'throws when second value is undefined');
-  t.throws(function () { return is.within(0, 0, undefined); }, error, 'throws when third value is undefined');
+  t.test('throws on NaN', function (st) {
+    var nanError = new TypeError('NaN is not a valid value');
+    st['throws'](function () { return is.within(NaN, 0, 0); }, nanError, 'throws when first value is NaN');
+    st['throws'](function () { return is.within(0, NaN, 0); }, nanError, 'throws when second value is NaN');
+    st['throws'](function () { return is.within(0, 0, NaN); }, nanError, 'throws when third value is NaN');
+    st.end();
+  });
+
+  t.test('throws on non-number', function (st) {
+    var error = new TypeError('all arguments must be numbers');
+    st['throws'](function () { return is.within('', 0, 0); }, error, 'throws when first value is string');
+    st['throws'](function () { return is.within(0, '', 0); }, error, 'throws when second value is string');
+    st['throws'](function () { return is.within(0, 0, ''); }, error, 'throws when third value is string');
+    st['throws'](function () { return is.within({}, 0, 0); }, error, 'throws when first value is object');
+    st['throws'](function () { return is.within(0, {}, 0); }, error, 'throws when second value is object');
+    st['throws'](function () { return is.within(0, 0, {}); }, error, 'throws when third value is object');
+    st['throws'](function () { return is.within(null, 0, 0); }, error, 'throws when first value is null');
+    st['throws'](function () { return is.within(0, null, 0); }, error, 'throws when second value is null');
+    st['throws'](function () { return is.within(0, 0, null); }, error, 'throws when third value is null');
+    st['throws'](function () { return is.within(undefined, 0, 0); }, error, 'throws when first value is undefined');
+    st['throws'](function () { return is.within(0, undefined, 0); }, error, 'throws when second value is undefined');
+    st['throws'](function () { return is.within(0, 0, undefined); }, error, 'throws when third value is undefined');
+    st.end();
+  });
 
   t.ok(is.within(2, 1, 3), '2 is between 1 and 3');
   t.ok(is.within(0, -1, 1), '0 is between -1 and 1');
@@ -526,6 +575,31 @@ test('is.object', function (t) {
   t.notOk(is.object(NaN), 'NaN is not an object');
   t.notOk(is.object(Object), 'object constructor is not an object');
   t.notOk(is.object(function () {}), 'function is not an object');
+
+  t.test('Symbols', { skip: typeof Symbol !== 'function' }, function (st) {
+    st.notOk(is.object(Symbol('foo')), 'symbol is not an object');
+    st.end();
+  });
+
+  t.end();
+});
+
+test('is.primitive', function (t) {
+  t.notOk(is.primitive({}), 'object literal is not a primitive');
+  t.notOk(is.primitive([]), 'array is not a primitive');
+  t.ok(is.primitive(), 'undefined is a primitive');
+  t.ok(is.primitive(null), 'null is a primitive');
+  t.ok(is.primitive(true), 'true is a primitive');
+  t.ok(is.primitive(''), 'string is a primitive');
+  t.ok(is.primitive(NaN), 'NaN is a primitive');
+  t.notOk(is.primitive(Object), 'object constructor is not a primitive');
+  t.notOk(is.primitive(function () {}), 'function is not a primitive');
+
+  t.test('Symbols', { skip: typeof Symbol !== 'function' }, function (st) {
+    st.ok(is.primitive(Symbol('foo')), 'symbol is a primitive');
+    st.end();
+  });
+
   t.end();
 });
 
@@ -535,25 +609,33 @@ test('is.hash', function (t) {
   t.notOk(is.hash(), 'undefined is not a hash');
   t.notOk(is.hash(null), 'null is not a hash');
   t.notOk(is.hash(new Date()), 'date is not a hash');
-  t.notOk(is.hash(new String()), 'string object is not a hash');
+  t.notOk(is.hash(Object('')), 'string object is not a hash');
   t.notOk(is.hash(''), 'string literal is not a hash');
-  t.notOk(is.hash(new Number()), 'number object is not a hash');
+  t.notOk(is.hash(Object(0)), 'number object is not a hash');
   t.notOk(is.hash(1), 'number literal is not a hash');
   t.notOk(is.hash(true), 'true is not a hash');
   t.notOk(is.hash(false), 'false is not a hash');
-  t.notOk(is.hash(new Boolean()), 'boolean obj is not hash');
+  t.notOk(is.hash(Object(false)), 'boolean obj is not hash');
   t.notOk(is.hash(false), 'literal false is not hash');
   t.notOk(is.hash(true), 'literal true is not hash');
-  if (typeof module !== 'undefined') {
-    t.ok(is.hash(module.exports), 'module.exports is a hash');
-  }
-  if (typeof window !== 'undefined') {
-    t.notOk(is.hash(window), 'window is not a hash');
-    t.notOk(is.hash(document.createElement('div')), 'element is not a hash');
-  } else if (typeof process !== 'undefined') {
-    t.notOk(is.hash(global), 'global is not a hash');
-    t.notOk(is.hash(process), 'process is not a hash');
-  }
+
+  t.test('commonJS environment', { skip: typeof module === 'undefined' }, function (st) {
+    st.ok(is.hash(module.exports), 'module.exports is a hash');
+    st.end();
+  });
+
+  t.test('browser stuff', { skip: typeof window === 'undefined' }, function (st) {
+    st.notOk(is.hash(window), 'window is not a hash');
+    st.notOk(is.hash(document.createElement('div')), 'element is not a hash');
+    st.end();
+  });
+
+  t.test('node stuff', { skip: typeof process === 'undefined' }, function (st) {
+    st.notOk(is.hash(global), 'global is not a hash');
+    st.notOk(is.hash(process), 'process is not a hash');
+    st.end();
+  });
+
   t.end();
 });
 
@@ -568,11 +650,11 @@ test('is.regexp', function (t) {
 
 test('is.string', function (t) {
   t.ok(is.string('foo'), 'string literal is string');
-  t.ok(is.string(new String('foo')), 'string literal is string');
+  t.ok(is.string(Object('foo')), 'string object is string');
   t.notOk(is.string(), 'undefined is not string');
   t.notOk(is.string(String), 'string constructor is not string');
   var F = function () {};
-  F.prototype = new String();
+  F.prototype = Object('');
   t.notOk(is.string(F), 'string subtype is not string');
   t.end();
 });
@@ -595,27 +677,52 @@ test('is.hex', function (t) {
 });
 
 test('is.symbol', function (t) {
-  t.test('not symbols', function (t) {
+  t.test('not symbols', function (st) {
     var notSymbols = [true, false, null, undefined, {}, [], function () {}, 42, NaN, Infinity, /a/g, '', 0, -0, new Error('error')];
     forEach(notSymbols, function (notSymbol) {
-      t.notOk(is.symbol(notSymbol), notSymbol + ' is not symbol');
+      st.notOk(is.symbol(notSymbol), notSymbol + ' is not symbol');
     });
 
-    t.end();
+    st.end();
   });
 
-  t.test('symbols', { skip: typeof Symbol !== 'function' }, function (t) {
-    t.ok(is.symbol(Symbol('foo')), 'Symbol("foo") is symbol');
+  t.test('symbols', { skip: typeof Symbol !== 'function' }, function (st) {
+    st.ok(is.symbol(Symbol('foo')), 'Symbol("foo") is symbol');
 
-    var notKnownSymbolProperties = ['length', 'name', 'arguments', 'caller', 'prototype', 'for', 'keyFor'];
+    var notKnownSymbols = ['length', 'name', 'arguments', 'caller', 'prototype', 'for', 'keyFor'];
     var symbolKeys = Object.getOwnPropertyNames(Symbol).filter(function (name) {
-      return notKnownSymbolProperties.indexOf(name) < 0;
+      return notKnownSymbols.indexOf(name) < 0;
     });
     forEach(symbolKeys, function (symbolKey) {
-      t.ok(is.symbol(Symbol[symbolKey]), symbolKey + ' is symbol');
+      st.ok(is.symbol(Symbol[symbolKey]), symbolKey + ' is symbol');
+    });
+
+    st.end();
+  });
+
+  t.end();
+});
+
+test('is.bigint', function (t) {
+  t.test('not bigints', function (st) {
+    var notBigints = [true, false, null, undefined, {}, [], function () {}, 42, NaN, Infinity, /a/g, '', 0, -0, new Error('error')];
+    forEach(notBigints, function (notBigint) {
+      st.notOk(is.bigint(notBigint), notBigint + ' is not bigint');
+    });
+
+    st.end();
+  });
+
+  t.test('bigints', { skip: typeof BigInt !== 'function' }, function (st) {
+    var bigInts = [
+      Function('return 42n')(), // eslint-disable-line no-new-func
+      BigInt(42)
+    ];
+    forEach(bigInts, function (bigInt) {
+      st.ok(is.bigint(bigInt), bigInt + ' is bigint');
     });
 
-    t.end();
+    st.end();
   });
 
   t.end();