From fabf082949ebd7c479160feaea0c8ee4ddce42e9 Mon Sep 17 00:00:00 2001
From: Gleb Bahmutov <gleb.bahmutov@gmail.com>
Date: Wed, 21 Jun 2017 22:49:29 -0400
Subject: [PATCH] fix(git): latest pre-git version with simple commit message

---
 package.json                                  |    8 +-
 .../node_modules/check-types/.travis.yml      |    3 +-
 .../node_modules/check-types/COPYING          |    2 +-
 .../node_modules/check-types/Jakefile.js      |   59 -
 .../node_modules/check-types/README.md        |  712 +++++-
 .../node_modules/check-types/component.json   |   26 +-
 .../check-types/config/jshint.json            |   67 -
 .../check-types/src/check-types.js            |  952 +++++---
 .../check-types/src/check-types.min.js        |    2 +-
 .../check-types/test/check-types-browser.js   |  928 --------
 .../check-types/test/check-types.html         |    2 +-
 .../check-types/test/check-types.js           | 1935 ++++++++++++-----
 12 files changed, 2705 insertions(+), 1991 deletions(-)
 delete mode 100644 test/test-next-updater/node_modules/check-types/Jakefile.js
 delete mode 100644 test/test-next-updater/node_modules/check-types/config/jshint.json
 delete mode 100644 test/test-next-updater/node_modules/check-types/test/check-types-browser.js

diff --git a/package.json b/package.json
index 8c85262..aed4471 100644
--- a/package.json
+++ b/package.json
@@ -11,7 +11,7 @@
   },
   "config": {
     "pre-git": {
-      "commit-msg": "validate-commit-msg",
+      "commit-msg": "simple",
       "pre-commit": [
         "npm run build",
         "npm test"
@@ -66,9 +66,10 @@
     "matchdep": "1.0.1",
     "mocha": "3.0.2",
     "mockery": "1.7.0",
-    "pre-git": "1.4.0",
+    "pre-git": "3.15.0",
     "publish": "0.6.0",
     "semantic-release": "4.3.5",
+    "simple-commit-message": "3.0.2",
     "stop-build": "1.0.1",
     "time-grunt": "1.4.0"
   },
@@ -99,7 +100,8 @@
     "verifyConditions": {
       "path": "condition-node-version",
       "node": "4"
-    }
+    },
+    "analyzeCommits": "simple-commit-message"
   },
   "repository": {
     "type": "git",
diff --git a/test/test-next-updater/node_modules/check-types/.travis.yml b/test/test-next-updater/node_modules/check-types/.travis.yml
index d15ad89..5c8c10c 100644
--- a/test/test-next-updater/node_modules/check-types/.travis.yml
+++ b/test/test-next-updater/node_modules/check-types/.travis.yml
@@ -1,7 +1,8 @@
 language: node_js
 node_js:
+  - "iojs"
+  - "0.12"
   - "0.10"
-  - "0.8"
 branches:
   only:
     - master
diff --git a/test/test-next-updater/node_modules/check-types/COPYING b/test/test-next-updater/node_modules/check-types/COPYING
index 59934f8..405b4f3 100644
--- a/test/test-next-updater/node_modules/check-types/COPYING
+++ b/test/test-next-updater/node_modules/check-types/COPYING
@@ -1,4 +1,4 @@
-Copyright © 2012 Phil Booth
+Copyright © 2012, 2013, 2014, 2015 Phil Booth
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of
 this software and associated documentation files (the "Software"), to deal in
diff --git a/test/test-next-updater/node_modules/check-types/Jakefile.js b/test/test-next-updater/node_modules/check-types/Jakefile.js
deleted file mode 100644
index 6381d5d..0000000
--- a/test/test-next-updater/node_modules/check-types/Jakefile.js
+++ /dev/null
@@ -1,59 +0,0 @@
-/*jshint nomen:false */
-/*globals require, console, complete, __dirname, process */
-
-'use strict';
-
-var exec = require('child_process').exec,
-
-commands = {
-    minify: './node_modules/.bin/uglifyjs ./src/check-types.js --compress --mangle --output ./src/check-types.min.js',
-    test: './node_modules/.bin/mocha --ui tdd --reporter spec --colors ./test/check-types.js',
-    lint: './node_modules/.bin/jshint ./src/check-types.js --config config/jshint.json',
-    prepare: 'npm install'
-};
-
-desc('Minify the source code for deployment.');
-task('minify', function () {
-    runTask('minify', 'Minifying...');
-}, {
-    async: true
-});
-
-desc('Run the unit tests.');
-task('test', function () {
-    runTask('test', 'Testing...');
-}, {
-    async: true
-});
-
-desc('Lint the source code.');
-task('lint', function () {
-    runTask('lint', 'Linting...');
-}, {
-    async: true
-});
-
-desc('Install dependencies.');
-task('prepare', function () {
-    runTask('prepare', 'Preparing the build environment...');
-}, {
-    async: true
-});
-
-function runTask (command, message) {
-    console.log(message);
-    runCommand(command);
-}
-
-function runCommand (command) {
-    exec(commands[command], { cwd: __dirname }, function (error, stdout, stderr) {
-        console.log(stdout);
-        console.log(stderr);
-        if (typeof error === 'object' && error !== null) {
-            console.log(error.message);
-            process.exit(1);
-        }
-        complete();
-    });
-}
-
diff --git a/test/test-next-updater/node_modules/check-types/README.md b/test/test-next-updater/node_modules/check-types/README.md
index f917ba1..93933b8 100644
--- a/test/test-next-updater/node_modules/check-types/README.md
+++ b/test/test-next-updater/node_modules/check-types/README.md
@@ -2,16 +2,41 @@
 
 [![Build status][ci-image]][ci-status]
 
-A tiny JavaScript library
-for checking types
-and throwing exceptions.
-
-## Why would I want such a thing?
+A little JavaScript library
+for asserting types
+and values.
+
+* [Why would I want that?](#why-would-i-want-that)
+* [How little is it?](#how-little-is-it)
+* [How do I install it?](#how-do-i-install-it)
+* [How do I use it?](#how-do-i-use-it)
+    * [Loading the library](#loading-the-library)
+    * [Calling the exported functions](#calling-the-exported-functions)
+        * [String predicates](#string-predicates)
+        * [Number predicates](#number-predicates)
+        * [Boolean predicates](#boolean-predicates)
+        * [Array predicates](#array-predicates)
+        * [Object predicates](#object-predicates)
+        * [Date predicates](#date-predicates)
+        * [Error predicates](#error-predicates)
+        * [Function predicates](#function-predicates)
+        * [Other predicates](#other-predicates)
+        * [Modifiers](#modifiers)
+        * [Batch operations](#batch-operations)
+        * [Some examples](#some-examples)
+* [Where can I use it?](#where-can-i-use-it)
+* [What changed from 2.x to 3.x?](#what-changed-from-2x-to-3x)
+* [What changed from 1.x to 2.x?](#what-changed-from-1x-to-2x)
+* [What changed from 0.x to 1.x?](#what-changed-from-0x-to-1x)
+* [How do I set up the build environment?](#how-do-i-set-up-the-build-environment)
+* [What license is it released under?](#what-license-is-it-released-under)
+
+## Why would I want that?
 
 Writing explicit conditions
 in your functions
-for checking arguments
-and throwing exceptions
+to check arguments
+and throw exceptions
 is a task that
 swiftly becomes tiresome
 and adds complexity
@@ -20,37 +45,43 @@ to your codebase.
 The purpose of check-types.js
 is to remove this burden
 from JavaScript application developers
-in an efficient and robust manner.
+in an efficient and robust manner,
+abstracted by a simple API.
 
-## How tiny is it?
+## How little is it?
 
-14.3 kb unminified with comments, 2.2 kb minified, 0.8 kb minified + gzipped.
+22 kb unminified with comments, 5.8 kb minified, 2 kb minified + gzipped.
 
 ## How do I install it?
 
-Any of the following will do:
+If you're using npm:
 
 ```
-npm install check-types
-
-jam install check-types
-
-bower install check-types
+npm install check-types --save
+```
 
-component install philbooth/check-types.js
+Or if you just want the git repo:
 
+```
 git clone git@github.com:philbooth/check-types.js.git
 ```
 
+If you're into
+other package managers,
+it is also available
+from Bower, Component and Jam.
+
 ## How do I use it?
 
+### Loading the library
+
 If you are running in
-[Node.js][node],
-[Browserify]
+Node.js,
+Browserify
 or another CommonJS-style
 environment,
 you can `require`
-check-types.js like so:
+check-types like so:
 
 ```javascript
 var check = require('check-types');
@@ -58,157 +89,600 @@ var check = require('check-types');
 
 It also the supports
 the AMD-style format
-preferred by [Require.js][require]:
-
-```javascript
-require.config({
-    paths: {
-        check: 'check-types.js/src/check-types'
-    }
-});
-
-require([ 'check' ], function (check) {
-});
-```
+preferred by Require.js.
 
 If you are
 including check-types.js
 with an HTML `<script>` tag,
 or neither of the above environments
 are detected,
-check-types.js will just export its interface globally
-as `check`.
+it will export the interface globally as `check`.
+
+### Calling the exported functions
 
 Once you have loaded the library
 in your application,
 a whole bunch of functions are available
-to call:
+to call.
+
+Most of the functions
+are predicates,
+which can be executed
+in a number of different contexts:
+
+* `check.xxx(thing)`:
+  These functions are basic predicates,
+  returning true or false
+  depending on the type and value of `thing`.
+
+* `check.not.xxx(thing)`:
+  The `not` modifier
+  negates predicates,
+  returning `true` if the predicate returns `false`
+  and `false` if the predicate returns `true`.
+  It is also itself a function,
+  which simply returns
+  the negation of
+  its argument.
+
+* `check.maybe.xxx(thing)`:
+  The `maybe` modifier
+  tweaks predicates to
+  return `true` if `thing` is `null` or `undefined`,
+  otherwise their normal result
+  is returned.
+  It is also itself a function,
+  which returns `true`
+  when its argument is `null` or `undefined`,
+  otherwise it returns its argument.
+
+* `check.either.xxx(thing).or.yyy(thang)`:
+  The `either` modifier
+  returns `true` if either predicate is true,
+  it will only return `false`
+  when both predicates are false.
+
+* `check.assert.xxx(thing, message)`:
+  The `assert` modifier
+  changes predicates
+  to throw when their result
+  would otherwise be `false`.
+  It can be applied
+  to the `not`, `maybe` and `either` modifiers
+  using the forms
+  `check.assert.not.xxx(thing, message)`,
+  `check.assert.maybe.xxx(thing, message)`
+  and
+  `check.assert.either.xxx(thing, message).or.yyy(thang)`.
+  It is also itself a function,
+  which simply throws
+  when its argument is false.
+
+* `check.array.of.xxx(thing)`:
+  The `array.of` modifier
+  first checks that
+  it is operating on an array
+  and then applies
+  the modified predicate
+  to each item
+  of the array.
+  If the predicate fails
+  for any item,
+  it returns `false`,
+  otherwise it returns `true`.
+  It can also be prefixed
+  by other modifiers,
+  so `check.maybe.array.of`,
+  `check.not.array.of`,
+  `check.assert.array.of`,
+  `check.assert.maybe.array.of` and
+  `check.assert.not.array.of`
+  all work
+  as you would expect
+  them to.
+
+* `check.arrayLike.of.xxx(thing)`:
+  The `arrayLike.of` modifier
+  is synonymous with `array.of`,
+  except it operates on array-like objects.
+
+* `check.iterable.of.xxx(thing)`:
+  The `iterable.of` modifier
+  is synonymous with `array.of`,
+  except it operates on iterables.
+
+* `check.object.of.xxx(thing)`:
+  The `object.of` modifier
+  is synonymous with `array.of`,
+  except it operates on an object's properties.
+
+Additionally, there are some batch operations
+that allow you to apply different predicates
+to each value
+in an array or object.
+These are implemented by
+`check.apply`,
+`check.map`,
+`check.any` and
+`check.all`.
+
+#### String predicates
+
+* `check.string(thing)`:
+  Returns `true`
+  if `thing` is a string,
+  `false` otherwise.
+
+* `check.unemptyString(thing)`:
+  Returns `true`
+  if `thing` is a non-empty string,
+  `false` otherwise.
+
+* `check.contains(thing, substring)`:
+  Returns `true`
+  if `thing` is a string
+  that contains `substring`,
+  `false` otherwise.
 
-* `check.quacksLike(thing, duck)`:
-  Tests whether an object 'quacks like a duck'.
+* `check.match(thing, regex)`:
   Returns `true`
-  if the first argument has all of the properties
-  of the second, archetypal argument (the 'duck').
-  Returns `false` otherwise.
-  If either argument is not an object,
-  an exception is thrown.
+  if `thing` is a string
+  that matches `regex`,
+  `false` otherwise.
+
+* `check.hasLength(thing, value)`:
+  Returns `true`
+  if `thing` has a length property
+  that equals `value`,
+  `false` otherwise.
+
+#### Number predicates
+
+* `check.number(thing)`:
+  Returns `true`
+  if `thing` is a number,
+  `false` otherwise.
+  Note that
+  `NaN`,
+  `Number.POSITIVE_INFINITY` and
+  `Number.NEGATIVE_INFINITY`
+  are not considered numbers here.
+
+* `check.greater(thing, value)`:
+  Returns `true` if `thing` is a number
+  greater than `value`,
+  `false` otherwise.
+
+* `check.greaterOrEqual(thing, value)`:
+  Returns `true` if `thing` is a number
+  greater than or equal to `value`,
+  `false` otherwise.
+
+* `check.less(thing, value)`:
+  Returns `true` if `thing` is a number
+  less than `value`,
+  `false` otherwise.
+
+* `check.lessOrEqual(thing, value)`:
+  Returns `true` if `thing` is a number
+  less than or equal to `value`,
+  `false` otherwise.
 
-* `check.verifyQuack(thing, duck, message)`:
-  Throws an exception
-  if an object does not 'quack like a duck'.
+* `check.between(thing, a, b)`:
+  Returns `true` if `thing` is a number
+  between than `a` and `b`,
+  `false` otherwise.
+  The arguments `a` and `b`
+  may be in any order,
+  it doesn't matter
+  which is greater.
+
+* `check.inRange(thing, a, b)`:
+  Returns `true` if `thing` is a number
+  in the range `a` .. `b`,
+  `false` otherwise.
+  The arguments `a` and `b`
+  may be in any order,
+  it doesn't matter
+  which is greater.
 
-* `check.isInstance(thing, prototype)`:
-  Returns `true` if an object is an instance of a prototype,
+* `check.positive(thing)`:
+  Returns `true` if `thing` is a number
+  greater than zero,
   `false` otherwise.
 
-* `check.verifyInstance(thing, prototype, message)`:
-  Throws an exception if an object is not an instance of a prototype.
+* `check.negative(thing)`:
+  Returns `true`
+  if `thing` is a number
+  less than zero,
+  `false` otherwise.
 
-* `check.isEmptyObject(thing)`:
-  Returns `true` if something is an empty, non-null, non-array object,
+* `check.zero(thing)`:
+  Returns `true`
+  if `thing` is zero,
   `false` otherwise.
 
-* `check.verifyEmptyObject(thing, message)`:
-  Throws an exception unless something is an empty, non-null, non-array object.
+* `check.odd(thing)`:
+  Returns `true`
+  if `thing` is an odd number,
+  `false` otherwise.
 
-* `check.isObject(thing)`:
-  Returns `true` if something is a non-null, non-array, non-date object,
+* `check.even(thing)`:
+  Returns `true`
+  if `thing` is an even number,
   `false` otherwise.
 
-* `check.verifyObject(thing, message)`:
-  Throws an exception unless something is a non-null, non-array, non-date object.
+* `check.integer(thing)`:
+  Returns `true`
+  if `thing` is an integer,
+  `false` otherwise.
 
-* `check.isLength(thing, length)`:
-  Returns `true` if something has a length property
-  that matches the specified length,
+#### Boolean predicates
+
+* `check.boolean(thing)`:
+  Returns `true`
+  if `thing` is a boolean,
   `false` otherwise.
 
-* `check.verifyLength(thing, length, message)`:
-  Throws an exception unless something has a length property
-  matching the specified length.
+#### Array predicates
 
-* `check.isArray(thing)`:
-  Returns `true` something is an array,
+* `check.array(thing)`:
+  Returns `true`
+  if `thing` is an array,
   `false` otherwise.
 
-* `check.verifyArray(thing, message)`:
-  Throws an exception unless something is an array.
+* `check.emptyArray(thing)`:
+  Returns `true`
+  if `thing` is an empty array,
+  `false` otherwise.
 
-* `check.isDate(thing)`:
-  Returns `true` something is a date,
+* `check.hasLength(thing, value)`:
+  Returns `true`
+  if `thing` has a length property
+  that equals `value`,
   `false` otherwise.
 
-* `check.verifyDate(thing, message)`:
-  Throws an exception unless something is a date.
+* `check.arrayLike(thing)`:
+  Returns `true`
+  if `thing` has a numeric length property,
+  `false` otherwise.
 
-* `check.isFunction(thing)`:
-  Returns `true` if something is function,
+* `check.iterable(thing)`:
+  Returns `true`
+  if `thing` implements the iterable protocol,
   `false` otherwise.
+  In pre-ES6 environments,
+  this predicate falls back
+  to `arrayLike` behaviour.
 
-* `check.verifyFunction(thing, message)`:
-  Throws an exception unless something is function.
+#### Object predicates
 
-* `check.isUnemptyString(thing)`:
-  Returns `true` if something is a non-empty string,
+* `check.object(thing)`:
+  Returns `true`
+  if `thing` is a plain-old JavaScript object,
   `false` otherwise.
 
-* `check.verifyUnemptyString(thing, message)`:
-  Throws an exception unless something is a non-empty string.
+* `check.emptyObject(thing)`:
+  Returns `true`
+  if `thing` is an empty object,
+  `false` otherwise.
 
-* `check.isString(thing)`:
-  Returns `true` if something is a string,
+* `check.instance(thing, prototype)`:
+  Returns `true`
+  if `thing` is an instance of `prototype`,
   `false` otherwise.
 
-* `check.verifyString(thing, message)`:
-  Throws an exception unless something is a string.
+* `check.like(thing, duck)`:
+  Duck-typing checker.
+  Returns `true`
+  if `thing` has all of the properties of `duck`,
+  `false` otherwise.
 
-* `check.isPositiveNumber(thing)`:
-  Returns `true` if something is a number
-  greater than zero,
+#### Date predicates
+
+* `check.date(thing)`:
+  Returns `true`
+  if `thing` is a valid date,
   `false` otherwise.
 
-* `check.verifyPositiveNumber(thing, message)`:
-  Throws an exception unless something is a number
-  greater than zero.
+#### Error predicates
 
-* `check.isNegativeNumber(thing)`:
-  Returns `true` if something is a number
-  less than zero,
+* `check.error(thing)`:
+  Returns `true`
+  if `thing` is an error,
   `false` otherwise.
 
-* `check.verifyNegativeNumber(thing, message)`:
-  Throws an exception unless something is a number
-  less than zero.
+#### Function predicates
 
-* `check.isEvenNumber(thing)`:
-  Returns `true` if something is an even number,
+* `check.function(thing)`:
+  Returns `true`
+  if `thing` is a function,
   `false` otherwise.
 
-* `check.verifyEvenNumber(thing, message)`:
-  Throws an exception unless something is an even number.
+* `check.hasLength(thing, value)`:
+  Returns `true`
+  if `thing` has a length property
+  that equals `value`,
+  `false` otherwise.
 
-* `check.isOddNumber(thing)`:
-  Returns `true` if something is an even number,
+#### Other predicates
+
+* `check.null(thing)`:
+  Returns `true`
+  if `thing` is `null`,
   `false` otherwise.
 
-* `check.verifyOddNumberthing, message)`:
-  Throws an exception unless something is an even number.
+* `check.undefined(thing)`:
+  Returns `true`
+  if `thing` is `undefined`,
+  `false` otherwise.
 
-* `check.isNumber(thing)`:
-  Returns `true` if something is a number,
+* `check.assigned(thing)`:
+  Returns `true`
+  if `thing` is not
+  `null` or `undefined`,
   `false` otherwise.
-  In this case, `NaN` is not considered a number.
 
-* `check.verifyNumber(thing, message)`:
-  Throws an exception unless something is a number.
-  In this case, `NaN` is not considered a number.
+#### Modifiers
+
+* `check.not(value)`:
+  Returns the negation
+  of `value`.
+
+* `check.not.xxx(...)`:
+  Returns the negation
+  of the predicate.
+
+* `check.maybe(value)`:
+  Returns `true`
+  if `value` is `null` or `undefined`,
+  otherwise it returns `value`.
+
+* `check.maybe.xxx(...)`:
+  Returns `true`
+  if `thing` is `null` or `undefined`,
+  otherwise it propagates
+  the return value
+  from its predicate.
+
+* `check.either.xxx(...).or.yyy(...)`:
+  Returns `true`
+  if either predicate is true.
+  Returns `false`
+  if both predicates are false.
+
+* `check.array.of.xxx(value)`:
+  Returns `true`
+  if `value` is an array
+  and the predicate is true
+  for every item.
+  Also works with the `not` and `maybe` modifiers.
+
+* `check.arrayLike.of.xxx(thing)`:
+  The `arrayLike.of` modifier
+  is synonymous with `array.of`,
+  except it operates on array-like objects.
+
+* `check.iterable.of.xxx(thing)`:
+  The `iterable.of` modifier
+  is synonymous with `array.of`,
+  except it operates on iterables.
+
+* `check.object.of.xxx(thing)`:
+  The `object.of` modifier
+  is synonymous with `array.of`,
+  except it operates on an object's properties.
+
+* `check.assert(value, message)`:
+  Throws an `Error`
+  if `value` is `false`,
+  setting `message`
+  on the `Error` instance.
+
+* `check.assert.xxx(...)`:
+  Throws an `Error`
+  if the predicate returns false.
+  The last argument
+  is an optional message
+  to be set on the `Error` instance.
+  Also works with the `not`, `maybe`, `either` and `...of` modifiers.
+
+#### Batch operations
+
+* `check.apply(things, predicates)`:
+  Applies each value from the `things` array
+  to the corresponding predicate
+  and returns the array of results.
+  Passing a single predicate
+  instead of an array
+  applies all of the values
+  to the same predicate.
+
+* `check.map(things, predicates)`:
+  Maps each value from the `things` object
+  to the corresponding predicate
+  and returns an object
+  containing the results.
+  Supports nested objects.
+  Passing a single predicate
+  instead of an object
+  applies all of the values
+  to the same predicate,
+  ignore nested objects.
+
+* `check.all(results)`:
+  Returns `true`
+  if all the result values are true
+  in an array (returned from `apply`)
+  or object (returned from `map`).
+
+* `check.any(predicateResults)`:
+  Returns `true`
+  if any result value is true
+  in an array (returned from `apply`)
+  or object (returned from `map`).
+
+#### Some examples
+
+```javascript
+check.even(3);
+// Returns false
+```
+
+```javascript
+check.not.even(3);
+// Returns true
+```
+
+```javascript
+check.maybe.even(null);
+// Returns true
+```
+
+```javascript
+check.either.even(3).or.odd(3);
+// Returns true
+```
+
+```javascript
+check.assert.like({ foo: 'bar' }, { baz: 'qux' }, 'Invalid object');
+// Throws new Error('Invalid object')
+```
+
+```javascript
+check.assert.not.like({ foo: 'bar' }, { baz: 'qux' }, 'Invalid object');
+// Doesn't throw
+```
+
+```javascript
+check.assert.maybe.like(undefined, { foo: 'bar' }, 'Invalid object');
+// Doesn't throw
+```
+
+```javascript
+check.assert(myFunction(), 'Something went wrong');
+// Throws if myFunction returns `false`
+```
+
+```javascript
+check.apply([ 'foo', 'bar', '' ], check.unemptyString);
+// Returns [ true, true, false ]
+```
+
+```javascript
+check.map({
+    foo: 2,
+    bar: { baz: 'qux' }
+}, {
+    foo: check.odd,
+    bar: { baz: check.unemptyString }
+});
+// Returns { foo: false, bar: { baz: true } }
+```
+
+```javascript
+check.all(
+    check.map(
+        { foo: 0, bar: '' },
+        { foo: check.number, bar: check.string }
+    );
+);
+// Returns true
+```
+
+```javascript
+check.any(
+    check.apply(
+        [ 1, 2, 3, '' ],
+        check.string
+    )
+);
+// Returns true
+```
+
+## Where can I use it?
+
+As of version 2.0,
+this library no longer supports ES3.
+That means you can't use it
+in IE 7 or 8.
+
+Everywhere else should be fine.
+
+If those versions of IE
+are important to you,
+worry not!
+The 1.x versions
+all support old IE
+and any future 1.x versions
+will adhere to that too.
+
+See the [releases]
+for more information.
+
+## What changed from 2.x to 3.x?
+
+Breaking changes
+were made to the API
+in version 3.0.0.
+
+Specifically,
+the predicate `length`
+was renamed to `hasLength`
+and the predicate `webUrl`
+was removed.
+
+See the [history][history3]
+for more details.
+
+## What changed from 1.x to 2.x?
+
+Breaking changes
+were made to the API
+in version 2.0.0.
+
+Specifically:
+
+* Support for ES3 was dropped
+* The predicates `gitUrl`, `email` and `floatNumber` were removed.
+* `verify` was renamed to `assert`.
+* `nulled` was renamed to `null`.
+* `oddNumber` was renamed to `odd`.
+* `evenNumber` was renamed to `even`.
+* `positiveNumber` was renamed to `positive`.
+* `negativeNumber` was renamed to `negative`.
+* `intNumber` was renamed to `integer`.
+* `bool` was renamed to `boolean`.
+* `defined` was swapped to become `undefined`.
+* `webUrl` was tightened to reject more cases.
+
+See the [history][history2]
+for more details.
+
+## What changed from 0.x to 1.x?
+
+Breaking changes
+were made to the API
+in version 1.0.0.
+
+Specifically,
+all of the predicates
+were renamed
+from `check.isXxxx`
+to `check.xxx` and
+all of the verifiers
+were renamed
+from `check.verifyXxxx`
+to `check.verify.xxx`.
+
+See the [history][history1]
+for more details.
 
 ## How do I set up the build environment?
 
 The build environment relies on
-Node.js,
+[Node.js][node],
 [NPM],
-[Jake],
 [JSHint],
 [Mocha],
 [Chai] and
@@ -218,19 +692,25 @@ you just need to run `npm install` to
 install all of the dependencies as listed in `package.json`.
 
 The unit tests are in `test/check-types.js`.
-You can run them with the command `npm test` or `jake test`.
+You can run them with the command `npm test`.
 To run the tests in a web browser,
 open `test/check-types.html`.
 
+## What license is it released under?
+
+[MIT][license]
+
 [ci-image]: https://secure.travis-ci.org/philbooth/check-types.js.png?branch=master
 [ci-status]: http://travis-ci.org/#!/philbooth/check-types.js
+[releases]: https://github.com/philbooth/check-types.js/releases
+[history3]: HISTORY.md#30
+[history2]: HISTORY.md#20
+[history1]: HISTORY.md#10
 [node]: http://nodejs.org/
-[browserify]: http://browserify.org/
-[require]: http://requirejs.org/
 [npm]: https://npmjs.org/
-[jake]: https://github.com/mde/jake
 [jshint]: https://github.com/jshint/node-jshint
-[mocha]: http://visionmedia.github.com/mocha
+[mocha]: http://mochajs.org/
 [chai]: http://chaijs.com/
 [uglifyjs]: https://github.com/mishoo/UglifyJS
+[license]: https://github.com/philbooth/check-types.js/blob/master/COPYING
 
diff --git a/test/test-next-updater/node_modules/check-types/component.json b/test/test-next-updater/node_modules/check-types/component.json
index 12b0f60..856a0d7 100644
--- a/test/test-next-updater/node_modules/check-types/component.json
+++ b/test/test-next-updater/node_modules/check-types/component.json
@@ -1,22 +1,10 @@
 {
     "name": "check-types",
-    "version": "0.6.5",
-    "author": "Phil Booth <pmbooth@gmail.com>",
-    "description": "A tiny JavaScript library for checking types and throwing exceptions.",
-    "contributors": [
-        { "name": "Phil Booth", "email": "pmbooth@gmail.com" },
-        { "name": "Rowan Manning" },
-        { "name": "Forbes Lindesay" },
-        { "name": "Fabrizio Moscon" }
-    ],
-    "main": "src/check-types.min.js",
-    "scripts": [
-        "src/check-types.min.js"
-    ],
-    "repository": {
-        "type": "git",
-        "url": "https://github.com/philbooth/check-types.js"
-    },
+    "version": "3.3.1",
+    "description": "A tiny library for asserting types and values.",
+    "repo": "philbooth/check-types.js",
+    "license": "MIT",
+    "main": "src/check-types.js",
     "keywords": [
         "types",
         "type-checking",
@@ -24,6 +12,8 @@
         "arguments",
         "parameters"
     ],
-    "license": "MIT"
+    "scripts": [
+        "src/check-types.js"
+    ]
 }
 
diff --git a/test/test-next-updater/node_modules/check-types/config/jshint.json b/test/test-next-updater/node_modules/check-types/config/jshint.json
deleted file mode 100644
index 37b8e71..0000000
--- a/test/test-next-updater/node_modules/check-types/config/jshint.json
+++ /dev/null
@@ -1,67 +0,0 @@
-{
-    "bitwise": true,
-    "camelcase": true,
-    "curly": true,
-    "eqeqeq": true,
-    "es3": true,
-    "forin": true,
-    "immed": true,
-    "indent": 4,
-    "latedef": false,
-    "newcap": true,
-    "noarg": true,
-    "noempty": true,
-    "nonew": true,
-    "plusplus": true,
-    "quotmark": "single",
-    "strict": true,
-    "trailing": true,
-    "undef": true,
-    "unused": true,
-
-    "asi": false,
-    "boss": false,
-    "debug": false,
-    "eqnull": false,
-    "es5": false,
-    "esnext": false,
-    "evil": false,
-    "expr": false,
-    "funcscope": false,
-    "globalstrict": false,
-    "iterator": false,
-    "lastsemic": false,
-    "laxbreak": false,
-    "laxcomma": false,
-    "loopfunc": false,
-    "moz": false,
-    "multistr": false,
-    "proto": false,
-    "scripturl": false,
-    "shadow": false,
-    "smarttabs": false,
-    "sub": false,
-    "supernew": false,
-    "validthis": false,
-
-    "browser": false,
-    "couch": false,
-    "devel": false,
-    "dojo": false,
-    "jquery": false,
-    "mootools": false,
-    "node": false,
-    "nonstandard": false,
-    "phantom": false,
-    "prototypejs": false,
-    "rhino": false,
-    "worker": false,
-    "wsh": false,
-    "yui": false,
-
-    "nomen": true,
-    "onevar": true,
-    "passfail": false,
-    "white": false
-}
-
diff --git a/test/test-next-updater/node_modules/check-types/src/check-types.js b/test/test-next-updater/node_modules/check-types/src/check-types.js
index 0df1374..da1edb2 100644
--- a/test/test-next-updater/node_modules/check-types/src/check-types.js
+++ b/test/test-next-updater/node_modules/check-types/src/check-types.js
@@ -1,99 +1,137 @@
+/*globals define, module, Symbol */
+
 /**
  * This module exports functions for checking types
  * and throwing exceptions.
  */
 
-/*globals define, module */
-
 (function (globals) {
     'use strict';
 
-    var functions = {
-        verifyQuack: verifyQuack,
-        quacksLike: quacksLike,
-        verifyInstance: verifyInstance,
-        isInstance: isInstance,
-        verifyEmptyObject: verifyEmptyObject,
-        isEmptyObject: isEmptyObject,
-        verifyObject: verifyObject,
-        isObject: isObject,
-        verifyLength: verifyLength,
-        isLength: isLength,
-        verifyArray: verifyArray,
-        isArray: isArray,
-        verifyDate: verifyDate,
-        isDate: isDate,
-        verifyFunction: verifyFunction,
-        isFunction: isFunction,
-        verifyUnemptyString: verifyUnemptyString,
-        isUnemptyString:isUnemptyString,
-        verifyString: verifyString,
-        isString: isString,
-        verifyEvenNumber: verifyEvenNumber,
-        isEvenNumber: isEvenNumber,
-        verifyOddNumber: verifyOddNumber,
-        isOddNumber: isOddNumber,
-        verifyPositiveNumber: verifyPositiveNumber,
-        isPositiveNumber: isPositiveNumber,
-        verifyNegativeNumber: verifyNegativeNumber,
-        isNegativeNumber: isNegativeNumber,
-        verifyNumber: verifyNumber,
-        isNumber: isNumber
+    var messages, predicates, functions, assert, not, maybe, either, collections, slice;
+
+    messages = {
+        like: 'Invalid type',
+        instance: 'Invalid type',
+        emptyObject: 'Invalid object',
+        object: 'Invalid object',
+        assigned: 'Invalid value',
+        undefined: 'Invalid value',
+        null: 'Invalid value',
+        hasLength: 'Invalid length',
+        emptyArray: 'Invalid array',
+        array: 'Invalid array',
+        arrayLike: 'Invalid array-like object',
+        iterable: 'Invalid iterable',
+        date: 'Invalid date',
+        error: 'Invalid error',
+        function: 'Invalid function',
+        match: 'Invalid string',
+        contains: 'Invalid string',
+        unemptyString: 'Invalid string',
+        string: 'Invalid string',
+        odd: 'Invalid number',
+        even: 'Invalid number',
+        inRange: 'Invalid number',
+        greaterOrEqual: 'Invalid number',
+        lessOrEqual: 'Invalid number',
+        between: 'Invalid number',
+        greater: 'Invalid number',
+        less: 'Invalid number',
+        positive: 'Invalid number',
+        negative: 'Invalid number',
+        integer: 'Invalid number',
+        zero: 'Invalid number',
+        number: 'Invalid number',
+        boolean: 'Invalid boolean'
     };
 
-    exportFunctions();
+    predicates = {
+        like: like,
+        instance: instance,
+        emptyObject: emptyObject,
+        object: object,
+        assigned: assigned,
+        undefined: isUndefined,
+        null: isNull,
+        hasLength: hasLength,
+        emptyArray: emptyArray,
+        array: array,
+        arrayLike: arrayLike,
+        iterable: iterable,
+        date: date,
+        error: error,
+        function: isFunction,
+        match: match,
+        contains: contains,
+        unemptyString: unemptyString,
+        string: string,
+        odd: odd,
+        even: even,
+        inRange: inRange,
+        greaterOrEqual: greaterOrEqual,
+        lessOrEqual: lessOrEqual,
+        between: between,
+        greater: greater,
+        less: less,
+        positive: positive,
+        negative: negative,
+        integer : integer,
+        zero: zero,
+        number: number,
+        boolean: boolean
+    };
 
-    /**
-     * Public function `verifyQuack`.
-     *
-     * Throws an exception if an object does not share
-     * the properties of a second, archetypal object
-     * (i.e. doesn't 'quack like a duck').
-     *
-     * @param thing {object}     The object to test.
-     * @param duck {object}      The archetypal object,
-     *                           or 'duck', that the test
-     *                           is against.
-     * @param [message] {string} An optional error message
-     *                           to set on the thrown Error.
-     */
-    function verifyQuack (thing, duck, message) {
-        verify(quacksLike, [ thing, duck ], message, 'Invalid type');
-    }
+    functions = {
+        apply: apply,
+        map: map,
+        all: all,
+        any: any
+    };
 
-    function verify (fn, args, message, defaultMessage) {
-        if (fn.apply(null, args) === false) {
-            throw new Error(message || defaultMessage);
-        }
-    }
+    collections = [ 'array', 'arrayLike', 'iterable', 'object' ];
+    slice = Array.prototype.slice;
+
+    functions = mixin(functions, predicates);
+    assert = createModifiedPredicates(assertModifier, assertImpl);
+    not = createModifiedPredicates(notModifier, notImpl);
+    maybe = createModifiedPredicates(maybeModifier, maybeImpl);
+    either = createModifiedPredicates(eitherModifier);
+    assert.not = createModifiedModifier(assertModifier, not);
+    assert.maybe = createModifiedModifier(assertModifier, maybe);
+    assert.either = createModifiedModifier(assertEitherModifier, predicates);
+
+    collections.forEach(createOfPredicates);
+    createOfModifiers(assert, assertModifier);
+    createOfModifiers(not, notModifier);
+    collections.forEach(createMaybeOfModifiers);
+
+    exportFunctions(mixin(functions, {
+        assert: assert,
+        not: not,
+        maybe: maybe,
+        either: either
+    }));
 
     /**
-     * Public function `quacksLike`.
+     * Public function `like`.
      *
      * Tests whether an object 'quacks like a duck'.
      * Returns `true` if the first argument has all of
      * the properties of the second, archetypal argument
-     * (the 'duck'). Returns `false` otherwise. If either
-     * argument is not an object, an exception is thrown.
+     * (the 'duck'). Returns `false` otherwise.
      *
-     * @param thing {object} The object to test.
-     * @param duck {object}  The archetypal object, or
-     *                       'duck', that the test is
-     *                       against.
      */
-    function quacksLike (thing, duck) {
-        var property;
-
-        verifyObject(thing);
-        verifyObject(duck);
+    function like (data, duck) {
+        var name;
 
-        for (property in duck) {
-            if (duck.hasOwnProperty(property)) {
-                if (thing.hasOwnProperty(property) === false) {
+        for (name in duck) {
+            if (duck.hasOwnProperty(name)) {
+                if (data.hasOwnProperty(name) === false || typeof data[name] !== typeof duck[name]) {
                     return false;
                 }
 
-                if (typeof thing[property] !== typeof duck[property]) {
+                if (object(data[name]) && like(data[name], duck[name]) === false) {
                     return false;
                 }
             }
@@ -103,393 +141,759 @@
     }
 
     /**
-     * Public function `verifyInstance`.
+     * Public function `instance`.
      *
-     * Throws an exception if an object is not an instance
-     * of a prototype.
+     * Returns `true` if an object is an instance of a prototype,
+     * `false` otherwise.
      *
-     * @param thing {object}       The object to test.
-     * @param prototype {function} The prototype that the
-     *                             test is against.
-     * @param [message] {string}   An optional error message
-     *                             to set on the thrown Error.
      */
-    function verifyInstance (thing, prototype, message) {
-        verify(isInstance, [ thing, prototype ], message, 'Invalid type');
+    function instance (data, prototype) {
+        if (data && isFunction(prototype) && data instanceof prototype) {
+            return true;
+        }
+
+        return false;
     }
 
     /**
-     * Public function `isInstance`.
+     * Public function `emptyObject`.
      *
-     * Returns `true` if an object is an instance of a prototype,
+     * Returns `true` if something is an empty object,
      * `false` otherwise.
      *
-     * @param thing {object}       The object to test.
-     * @param prototype {function} The prototype that the
-     *                             test is against.
      */
-    function isInstance (thing, prototype) {
-        if (typeof thing === 'undefined' || thing === null) {
-            return false;
-        }
+    function emptyObject (data) {
+        return object(data) && Object.keys(data).length === 0;
+    }
 
-        if (isFunction(prototype) && thing instanceof prototype) {
-            return true;
-        }
+    /**
+     * Public function `object`.
+     *
+     * Returns `true` if something is a plain-old JS object,
+     * `false` otherwise.
+     *
+     */
+    function object (data) {
+        return Object.prototype.toString.call(data) === '[object Object]';
+    }
 
-        return false;
+    /**
+     * Public function `assigned`.
+     *
+     * Returns `true` if something is not null or undefined,
+     * `false` otherwise.
+     *
+     */
+    function assigned (data) {
+        return !isUndefined(data) && !isNull(data);
     }
 
     /**
-     * Public function `verifyEmptyObject`.
+     * Public function `undefined`.
      *
-     * Throws an exception unless something is an empty, non-null,
-     * non-array object.
+     * Returns `true` if something is undefined,
+     * `false` otherwise.
      *
-     * @param thing              The thing to test.
-     * @param [message] {string} An optional error message
-     *                           to set on the thrown Error.
      */
-    function verifyEmptyObject (thing, message) {
-        verify(isEmptyObject, [ thing ], message, 'Invalid object');
+    function isUndefined (data) {
+        return data === undefined;
     }
 
     /**
-     * Public function `isEmptyObject`.
+     * Public function `null`.
      *
-     * Returns `true` if something is an empty, non-null, non-array object, `false` otherwise.
+     * Returns `true` if something is null,
+     * `false` otherwise.
      *
-     * @param thing          The thing to test.
      */
-    function isEmptyObject (thing) {
-        var property;
+    function isNull (data) {
+        return data === null;
+    }
 
-        if (isObject(thing)) {
-            for (property in thing) {
-                if (thing.hasOwnProperty(property)) {
-                    return false;
-                }
-            }
+    /**
+     * Public function `hasLength`.
+     *
+     * Returns `true` if something is has a length property
+     * that equals `value`, `false` otherwise.
+     *
+     */
+    function hasLength (data, value) {
+        return assigned(data) && data.length === value;
+    }
 
-            return true;
+    /**
+     * Public function `emptyArray`.
+     *
+     * Returns `true` if something is an empty array,
+     * `false` otherwise.
+     *
+     */
+    function emptyArray (data) {
+        return array(data) && data.length === 0;
+    }
+
+    /**
+     * Public function `array`.
+     *
+     * Returns `true` something is an array,
+     * `false` otherwise.
+     *
+     */
+    function array (data) {
+        return Array.isArray(data);
+    }
+
+    /**
+     * Public function `arrayLike`.
+     *
+     * Returns `true` something is an array-like object,
+     * `false` otherwise.
+     *
+     */
+    function arrayLike (data) {
+        return assigned(data) && number(data.length);
+    }
+
+    /**
+     * Public function `iterable`.
+     *
+     * Returns `true` something is an iterable,
+     * `false` otherwise.
+     *
+     */
+    function iterable (data) {
+        if (typeof Symbol === 'undefined') {
+            // Fall back to arrayLike predicate in pre-ES6 environments.
+            return arrayLike(data);
         }
 
-        return false;
+        return assigned(data) && isFunction(data[Symbol.iterator]);
     }
 
     /**
-     * Public function `verifyObject`.
+     * Public function `date`.
      *
-     * Throws an exception unless something is a non-null,
-     * non-array, non-date object.
+     * Returns `true` something is a valid date,
+     * `false` otherwise.
      *
-     * @param thing              The thing to test.
-     * @param [message] {string} An optional error message
-     *                           to set on the thrown Error.
      */
-    function verifyObject (thing, message) {
-        verify(isObject, [ thing ], message, 'Invalid object');
+    function date (data) {
+        return Object.prototype.toString.call(data) === '[object Date]' &&
+            !isNaN(data.getTime());
     }
 
     /**
-     * Public function `isObject`.
+     * Public function `error`.
      *
-     * Returns `true` if something is a non-null, non-array,
-     * non-date object, `false` otherwise.
+     * Returns `true` if something is a plain-old JS object,
+     * `false` otherwise.
      *
-     * @param thing          The thing to test.
      */
-    function isObject (thing) {
-        return typeof thing === 'object' && thing !== null && isArray(thing) === false && isDate(thing) === false;
+    function error (data) {
+        return Object.prototype.toString.call(data) === '[object Error]';
     }
 
     /**
-     * Public function `verifyLength`.
+     * Public function `function`.
      *
-     * Throws an exception unless something is a non-null,
-     * non-array object.
+     * Returns `true` if something is function,
+     * `false` otherwise.
      *
-     * @param thing              The thing to test.
-     * @param [message] {string} An optional error message
-     *                           to set on the thrown Error.
      */
-    function verifyLength (thing, length, message) {
-        verify(isLength, [ thing, length ], message, 'Invalid length');
+    function isFunction (data) {
+        return typeof data === 'function';
     }
 
     /**
-     * Public function `isLength`.
+     * Public function `match`.
      *
-     * Returns `true` if something is has a length property
-     * matching the specified value, `false` otherwise.
+     * Returns `true` if something is a string
+     * that matches `regex`, `false` otherwise.
      *
-     * @param thing  The thing to test.
-     * @param length The required length to test against.
      */
-    function isLength (thing, length) {
-        return thing && thing.length === length;
+    function match (data, regex) {
+        return string(data) && !!data.match(regex);
     }
 
     /**
-     * Public function `verifyArray`.
+     * Public function `contains`.
      *
-     * Throws an exception unless something is an array.
+     * Returns `true` if something is a string
+     * that contains `substring`, `false` otherwise.
      *
-     * @param thing              The thing to test.
-     * @param [message] {string} An optional error message
-     *                           to set on the thrown Error.
      */
-    function verifyArray (thing, message) {
-        verify(isArray, [ thing ], message, 'Invalid array');
+    function contains (data, substring) {
+        return string(data) && data.indexOf(substring) !== -1;
     }
 
     /**
-     * Public function `isArray`.
+     * Public function `unemptyString`.
      *
-     * Returns `true` something is an array, `false` otherwise.
+     * Returns `true` if something is a non-empty string,
+     * `false` otherwise.
      *
-     * @param thing          The thing to test.
      */
-    function isArray (thing) {
-        if (Array.isArray) {
-            return Array.isArray(thing);
-        }
+    function unemptyString (data) {
+        return string(data) && data !== '';
+    }
 
-        return Object.prototype.toString.call(thing) === '[object Array]';
+    /**
+     * Public function `string`.
+     *
+     * Returns `true` if something is a string, `false` otherwise.
+     *
+     */
+    function string (data) {
+        return typeof data === 'string';
     }
 
     /**
-     * Public function `verifyDate`.
+     * Public function `odd`.
      *
-     * Throws an exception unless something is a date.
+     * Returns `true` if something is an odd number,
+     * `false` otherwise.
      *
-     * @param thing              The thing to test.
-     * @param [message] {string} An optional error message
-     *                           to set on the thrown Error.
      */
-    function verifyDate (thing, message) {
-        verify(isDate, [ thing ], message, 'Invalid date');
+    function odd (data) {
+        return integer(data) && !even(data);
     }
 
     /**
-     * Public function `isDate`.
+     * Public function `even`.
      *
-     * Returns `true` something is a date, `false` otherwise.
+     * Returns `true` if something is an even number,
+     * `false` otherwise.
      *
-     * @param thing          The thing to test.
      */
-    function isDate (thing) {
-        return Object.prototype.toString.call(thing) === '[object Date]';
+    function even (data) {
+        return number(data) && data % 2 === 0;
     }
 
     /**
-     * Public function `verifyFunction`.
+     * Public function `integer`.
      *
-     * Throws an exception unless something is function.
+     * Returns `true` if something is an integer,
+     * `false` otherwise.
      *
-     * @param thing              The thing to test.
-     * @param [message] {string} An optional error message
-     *                           to set on the thrown Error.
      */
-    function verifyFunction (thing, message) {
-        verify(isFunction, [ thing ], message, 'Invalid function');
+    function integer (data) {
+        return number(data) && data % 1 === 0;
     }
 
     /**
-     * Public function `isFunction`.
+     * Public function `inRange`.
      *
-     * Returns `true` if something is function, `false` otherwise.
+     * Returns `true` if something is a number in
+     * the range `a` .. `b`, `false` otherwise.
      *
-     * @param thing          The thing to test.
      */
-    function isFunction (thing) {
-        return typeof thing === 'function';
+    function inRange (data, a, b) {
+        if (a < b) {
+            return greaterOrEqual(data, a) && lessOrEqual(data, b);
+        }
+
+        return lessOrEqual(data, a) && greaterOrEqual(data, b);
     }
 
     /**
-     * Public function `verifyUnemptyString`.
+     * Public function `greaterOrEqual`.
      *
-     * Throws an exception unless something is a non-empty string.
+     * Returns `true` if something is a number greater
+     * than or equal to `value`, `false` otherwise.
      *
-     * @param thing              The thing to test.
-     * @param [message] {string} An optional error message
-     *                           to set on the thrown Error.
      */
-    function verifyUnemptyString (thing, message) {
-        verify(isUnemptyString, [ thing ], message, 'Invalid string');
+    function greaterOrEqual (data, value) {
+        return number(data) && data >= value;
     }
 
     /**
-     * Public function `isUnemptyString`.
+     * Public function `lessOrEqual`.
      *
-     * Returns `true` if something is a non-empty string, `false`
-     * otherwise.
+     * Returns `true` if something is a number less
+     * than or equal to `value`, `false` otherwise.
      *
-     * @param thing          The thing to test.
      */
-    function isUnemptyString (thing) {
-        return isString(thing) && thing !== '';
+    function lessOrEqual (data, value) {
+        return number(data) && data <= value;
     }
 
     /**
-     * Public function `verifyString`.
+     * Public function `between`.
      *
-     * Throws an exception unless something is a string.
+     * Returns `true` if something is a number
+     * between `a` and `b`, `false` otherwise.
      *
-     * @param thing              The thing to test.
-     * @param [message] {string} An optional error message
-     *                           to set on the thrown Error.
      */
-    function verifyString (thing, message) {
-        verify(isString, [ thing ], message, 'Invalid string');
+    function between (data, a, b) {
+        if (a < b) {
+            return greater(data, a) && less(data, b);
+        }
+
+        return less(data, a) && greater(data, b);
     }
 
     /**
-     * Public function `isString`.
+     * Public function `greater`.
      *
-     * Returns `true` if something is a string, `false` otherwise.
+     * Returns `true` if something is a number
+     * greater than `value`, `false` otherwise.
      *
-     * @param thing          The thing to test.
      */
-    function isString (thing) {
-        return typeof thing === 'string';
+    function greater (data, value) {
+        return number(data) && data > value;
     }
 
     /**
-     * Public function `verifyOddNumber`.
+     * Public function `less`.
      *
-     * Throws an exception unless something is an odd number.
+     * Returns `true` if something is a number
+     * less than `value`, `false` otherwise.
      *
-     * @param thing              The thing to test.
-     * @param [message] {string} An optional error message
-     *                           to set on the thrown Error.
      */
-    function verifyOddNumber (thing, message) {
-        verify(isOddNumber, [ thing ], message, 'Invalid number');
+    function less (data, value) {
+        return number(data) && data < value;
     }
 
     /**
-     * Public function `isOddNumber`.
+     * Public function `positive`.
      *
-     * Returns `true` if something is an odd number,
+     * Returns `true` if something is a positive number,
      * `false` otherwise.
      *
-     * @param thing          The thing to test.
      */
-    function isOddNumber (thing) {
-        return isNumber(thing) && (thing % 2 === 1 || thing % 2 === -1);
+    function positive (data) {
+        return greater(data, 0);
     }
 
     /**
-     * Public function `verifyEvenNumber`.
+     * Public function `negative`.
      *
-     * Throws an exception unless something is an even number.
+     * Returns `true` if something is a negative number,
+     * `false` otherwise.
      *
-     * @param thing              The thing to test.
-     * @param [message] {string} An optional error message
-     *                           to set on the thrown Error.
+     * @param data          The thing to test.
      */
-    function verifyEvenNumber (thing, message) {
-        verify(isEvenNumber, [ thing ], message, 'Invalid number');
+    function negative (data) {
+        return less(data, 0);
     }
 
     /**
-     * Public function `isEvenNumber`.
+     * Public function `number`.
      *
-     * Returns `true` if something is an even number,
+     * Returns `true` if data is a number,
      * `false` otherwise.
      *
-     * @param thing          The thing to test.
      */
-    function isEvenNumber (thing) {
-        return isNumber(thing) && thing % 2 === 0;
+    function number (data) {
+        return typeof data === 'number' && isNaN(data) === false &&
+               data !== Number.POSITIVE_INFINITY &&
+               data !== Number.NEGATIVE_INFINITY;
     }
 
     /**
-     * Public function `verifyPositiveNumber`.
+     * Public function `zero`.
      *
-     * Throws an exception unless something is a positive number.
+     * Returns `true` if something is zero,
+     * `false` otherwise.
      *
-     * @param thing              The thing to test.
-     * @param [message] {string} An optional error message
-     *                           to set on the thrown Error.
+     * @param data          The thing to test.
      */
-    function verifyPositiveNumber (thing, message) {
-        verify(isPositiveNumber, [ thing ], message, 'Invalid number');
+    function zero (data) {
+        return data === 0;
     }
 
     /**
-     * Public function `isPositiveNumber`.
+     * Public function `boolean`.
      *
-     * Returns `true` if something is a positive number,
+     * Returns `true` if data is a boolean value,
      * `false` otherwise.
      *
-     * @param thing          The thing to test.
      */
-    function isPositiveNumber (thing) {
-        return isNumber(thing) && thing > 0;
+    function boolean (data) {
+        return data === false || data === true;
     }
 
     /**
-     * Public function `verifyNegativeNumber`.
+     * Public function `apply`.
      *
-     * Throws an exception unless something is a positive number.
+     * Maps each value from the data to the corresponding predicate and returns
+     * the result array. If the same function is to be applied across all of the
+     * data, a single predicate function may be passed in.
      *
-     * @param thing              The thing to test.
-     * @param [message] {string} An optional error message
-     *                           to set on the thrown Error.
      */
-    function verifyNegativeNumber (thing, message) {
-        verify(isNegativeNumber, [ thing ], message, 'Invalid number');
+    function apply (data, predicates) {
+        assert.array(data);
+
+        if (isFunction(predicates)) {
+            return data.map(function (value) {
+                return predicates(value);
+            });
+        }
+
+        assert.array(predicates);
+        assert.hasLength(data, predicates.length);
+
+        return data.map(function (value, index) {
+            return predicates[index](value);
+        });
     }
 
     /**
-     * Public function `isNegativeNumber`.
+     * Public function `map`.
      *
-     * Returns `true` if something is a positive number,
-     * `false` otherwise.
+     * Maps each value from the data to the corresponding predicate and returns
+     * the result object. Supports nested objects. If the data is not nested and
+     * the same function is to be applied across all of it, a single predicate
+     * function may be passed in.
+     *
+     */
+    function map (data, predicates) {
+        assert.object(data);
+
+        if (isFunction(predicates)) {
+            return mapSimple(data, predicates);
+        }
+
+        assert.object(predicates);
+
+        return mapComplex(data, predicates);
+    }
+
+    function mapSimple (data, predicate) {
+        var result = {};
+
+        Object.keys(data).forEach(function (key) {
+            result[key] = predicate(data[key]);
+        });
+
+        return result;
+    }
+
+    function mapComplex (data, predicates) {
+        var result = {};
+
+        Object.keys(predicates).forEach(function (key) {
+            var predicate = predicates[key];
+
+            if (isFunction(predicate)) {
+                if (not.assigned(data)) {
+                    result[key] = !!predicate._isMaybefied;
+                } else {
+                    result[key] = predicate(data[key]);
+                }
+            } else if (object(predicate)) {
+                result[key] = mapComplex(data[key], predicate);
+            }
+        });
+
+        return result;
+    }
+
+    /**
+     * Public function `all`
+     *
+     * Check that all boolean values are true
+     * in an array (returned from `apply`)
+     * or object (returned from `map`).
      *
-     * @param thing          The thing to test.
      */
-    function isNegativeNumber (thing) {
-        return isNumber(thing) && thing < 0;
+    function all (data) {
+        if (array(data)) {
+            return testArray(data, false);
+        }
+
+        assert.object(data);
+
+        return testObject(data, false);
+    }
+
+    function testArray (data, result) {
+        var i;
+
+        for (i = 0; i < data.length; i += 1) {
+            if (data[i] === result) {
+                return result;
+            }
+        }
+
+        return !result;
+    }
+
+    function testObject (data, result) {
+        var key, value;
+
+        for (key in data) {
+            if (data.hasOwnProperty(key)) {
+                value = data[key];
+
+                if (object(value) && testObject(value, result) === result) {
+                    return result;
+                }
+
+                if (value === result) {
+                    return result;
+                }
+            }
+        }
+
+        return !result;
     }
 
     /**
-     * Public function `verifyNumber`.
+     * Public function `any`
      *
-     * Throws an exception unless something is a number, excluding NaN.
+     * Check that at least one boolean value is true
+     * in an array (returned from `apply`)
+     * or object (returned from `map`).
      *
-     * @param thing              The thing to test.
-     * @param [message] {string} An optional error message
-     *                           to set on the thrown Error.
      */
-    function verifyNumber (thing, message) {
-        verify(isNumber, [ thing ], message, 'Invalid number');
+    function any (data) {
+        if (array(data)) {
+            return testArray(data, true);
+        }
+
+        assert.object(data);
+
+        return testObject(data, true);
+    }
+
+    function mixin (target, source) {
+        Object.keys(source).forEach(function (key) {
+            target[key] = source[key];
+        });
+
+        return target;
     }
 
     /**
-     * Public function `isNumber`.
+     * Public modifier `assert`.
      *
-     * Returns `true` if something is a number other than NaN,
-     * `false` otherwise.
+     * Throws if `predicate` returns `false`.
+     */
+    function assertModifier (predicate, defaultMessage) {
+        return function () {
+            assertPredicate(predicate, arguments, defaultMessage);
+        };
+    }
+
+    function assertPredicate (predicate, args, defaultMessage) {
+        var message = args[args.length - 1];
+        assertImpl(predicate.apply(null, args), unemptyString(message) ? message : defaultMessage);
+    }
+
+    function assertImpl (value, message) {
+        if (value === false) {
+            throw new Error(message || 'Assertion failed');
+        }
+    }
+
+    function assertEitherModifier (predicate, defaultMessage) {
+        return function () {
+            var error;
+
+            try {
+                assertPredicate(predicate, arguments, defaultMessage);
+            } catch (e) {
+                error = e;
+            }
+
+            return {
+                or: Object.keys(predicates).reduce(delayedAssert, {})
+            };
+
+            function delayedAssert (result, key) {
+                result[key] = function () {
+                    if (error && !predicates[key].apply(null, arguments)) {
+                        throw error;
+                    }
+                };
+
+                return result;
+            }
+        };
+    }
+
+    /**
+     * Public modifier `not`.
      *
-     * @param thing The thing to test.
+     * Negates `predicate`.
      */
-    function isNumber (thing) {
-        return typeof thing === 'number' && isNaN(thing) === false;
+    function notModifier (predicate) {
+        return function () {
+            return notImpl(predicate.apply(null, arguments));
+        };
     }
 
-    function exportFunctions () {
+    function notImpl (value) {
+        return !value;
+    }
+
+    /**
+     * Public modifier `maybe`.
+     *
+     * Returns `true` if predicate argument is  `null` or `undefined`,
+     * otherwise propagates the return value from `predicate`.
+     */
+    function maybeModifier (predicate) {
+        var modifiedPredicate = function () {
+            if (!assigned(arguments[0])) {
+                return true;
+            }
+
+            return predicate.apply(null, arguments);
+        };
+
+        // Hackishly indicate that this is a maybe.xxx predicate.
+        // Without this flag, the alternative would be to iterate
+        // through the maybe predicates or use indexOf to check,
+        // which would be time-consuming.
+        modifiedPredicate._isMaybefied = true;
+
+        return modifiedPredicate;
+    }
+
+    function maybeImpl (value) {
+        if (assigned(value) === false) {
+            return true;
+        }
+
+        return value;
+    }
+
+    /**
+     * Public modifier `either`.
+     *
+     * Returns `true` if either predicate is true.
+     */
+    function eitherModifier (predicate) {
+        return function () {
+            var shortcut = predicate.apply(null, arguments);
+
+            return {
+                or: Object.keys(predicates).reduce(nopOrPredicate, {})
+            };
+
+            function nopOrPredicate (result, key) {
+                result[key] = shortcut ? nop : predicates[key];
+                return result;
+            }
+        };
+
+        function nop () {
+            return true;
+        }
+    }
+
+    /**
+     * Public modifier `of`.
+     *
+     * Applies the chained predicate to members of the collection.
+     */
+    function ofModifier (target, type, predicate) {
+        return function () {
+            var collection, args;
+
+            collection = arguments[0];
+
+            if (!type(collection)) {
+                return false;
+            }
+
+            collection = coerceCollection(type, collection);
+            args = slice.call(arguments, 1);
+
+            try {
+                collection.forEach(function (item) {
+                    if (
+                        (target !== 'maybe' || assigned(item)) &&
+                        !predicate.apply(null, [ item ].concat(args))
+                    ) {
+                        // HACK: Ideally we'd use a for...of loop and return here,
+                        //       but that syntax is not supported by ES5. We could
+                        //       use a transpiler and a build step but I'm happy
+                        //       enough with this until ES6 is the baseline.
+                        throw 0;
+                    }
+                });
+            } catch (ignore) {
+                return false;
+            }
+
+            return true;
+        };
+    }
+
+    function coerceCollection (type, collection) {
+        switch (type) {
+            case arrayLike:
+                return slice.call(collection);
+            case object:
+                return Object.keys(collection).map(function (key) {
+                    return collection[key];
+                });
+            default:
+                return collection;
+        }
+    }
+
+    function createModifiedPredicates (modifier, object) {
+        return createModifiedFunctions([ modifier, predicates, object ]);
+    }
+
+    function createModifiedFunctions (args) {
+        var modifier, object, functions, result;
+
+        modifier = args.shift();
+        object = args.pop();
+        functions = args.pop();
+
+        result = object || {};
+
+        Object.keys(functions).forEach(function (key) {
+            Object.defineProperty(result, key, {
+                configurable: false,
+                enumerable: true,
+                writable: false,
+                value: modifier.apply(null, args.concat(functions[key], messages[key]))
+            });
+        });
+
+        return result;
+    }
+
+    function createModifiedModifier (modifier, modified) {
+        return createModifiedFunctions([ modifier, modified, null ]);
+    }
+
+    function createOfPredicates (key) {
+        predicates[key].of = createModifiedFunctions(
+            [ ofModifier.bind(null, null), predicates[key], predicates, null ]
+        );
+    }
+
+    function createOfModifiers (base, modifier) {
+        collections.forEach(function (key) {
+            base[key].of = createModifiedModifier(modifier, predicates[key].of);
+        });
+    }
+
+    function createMaybeOfModifiers (key) {
+        maybe[key].of = createModifiedFunctions(
+            [ ofModifier.bind(null, 'maybe'), predicates[key], predicates, null ]
+        );
+        assert.maybe[key].of = createModifiedModifier(assertModifier, maybe[key].of);
+        assert.not[key].of = createModifiedModifier(assertModifier, not[key].of);
+    }
+
+    function exportFunctions (functions) {
         if (typeof define === 'function' && define.amd) {
             define(function () {
                 return functions;
             });
-        } else if (typeof module !== 'undefined' && module !== null) {
+        } else if (typeof module !== 'undefined' && module !== null && module.exports) {
             module.exports = functions;
         } else {
             globals.check = functions;
         }
     }
 }(this));
-
diff --git a/test/test-next-updater/node_modules/check-types/src/check-types.min.js b/test/test-next-updater/node_modules/check-types/src/check-types.min.js
index 4e5a2cb..05c64fb 100644
--- a/test/test-next-updater/node_modules/check-types/src/check-types.min.js
+++ b/test/test-next-updater/node_modules/check-types/src/check-types.min.js
@@ -1 +1 @@
-!function(n){"use strict";function t(n,t,r){i(e,[n,t],r,"Invalid type")}function i(n,t,i,e){if(n.apply(null,t)===!1)throw new Error(i||e)}function e(n,t){var i;c(n),c(t);for(i in t)if(t.hasOwnProperty(i)){if(n.hasOwnProperty(i)===!1)return!1;if(typeof n[i]!=typeof t[i])return!1}return!0}function r(n,t,e){i(u,[n,t],e,"Invalid type")}function u(n,t){return"undefined"==typeof n||null===n?!1:m(t)&&n instanceof t?!0:!1}function f(n,t){i(o,[n],t,"Invalid object")}function o(n){var t;if(a(n)){for(t in n)if(n.hasOwnProperty(t))return!1;return!0}return!1}function c(n,t){i(a,[n],t,"Invalid object")}function a(n){return"object"==typeof n&&null!==n&&s(n)===!1&&b(n)===!1}function y(n,t,e){i(v,[n,t],e,"Invalid length")}function v(n,t){return n&&n.length===t}function l(n,t){i(s,[n],t,"Invalid array")}function s(n){return Array.isArray?Array.isArray(n):"[object Array]"===Object.prototype.toString.call(n)}function d(n,t){i(b,[n],t,"Invalid date")}function b(n){return"[object Date]"===Object.prototype.toString.call(n)}function p(n,t){i(m,[n],t,"Invalid function")}function m(n){return"function"==typeof n}function I(n,t){i(g,[n],t,"Invalid string")}function g(n){return j(n)&&""!==n}function N(n,t){i(j,[n],t,"Invalid string")}function j(n){return"string"==typeof n}function O(n,t){i(h,[n],t,"Invalid number")}function h(n){return L(n)&&(1===n%2||-1===n%2)}function A(n,t){i(S,[n],t,"Invalid number")}function S(n){return L(n)&&0===n%2}function w(n,t){i(E,[n],t,"Invalid number")}function E(n){return L(n)&&n>0}function P(n,t){i(k,[n],t,"Invalid number")}function k(n){return L(n)&&0>n}function D(n,t){i(L,[n],t,"Invalid number")}function L(n){return"number"==typeof n&&isNaN(n)===!1}function F(){"function"==typeof define&&define.amd?define(function(){return U}):"undefined"!=typeof module&&null!==module?module.exports=U:n.check=U}var U={verifyQuack:t,quacksLike:e,verifyInstance:r,isInstance:u,verifyEmptyObject:f,isEmptyObject:o,verifyObject:c,isObject:a,verifyLength:y,isLength:v,verifyArray:l,isArray:s,verifyDate:d,isDate:b,verifyFunction:p,isFunction:m,verifyUnemptyString:I,isUnemptyString:g,verifyString:N,isString:j,verifyEvenNumber:A,isEvenNumber:S,verifyOddNumber:O,isOddNumber:h,verifyPositiveNumber:w,isPositiveNumber:E,verifyNegativeNumber:P,isNegativeNumber:k,verifyNumber:D,isNumber:L};F()}(this);
\ No newline at end of file
+!function(n){"use strict";function r(n,t){var e;for(e in t)if(t.hasOwnProperty(e)){if(n.hasOwnProperty(e)===!1||typeof n[e]!=typeof t[e])return!1;if(u(n[e])&&r(n[e],t[e])===!1)return!1}return!0}function t(n,r){return n&&v(r)&&n instanceof r?!0:!1}function e(n){return u(n)&&0===Object.keys(n).length}function u(n){return"[object Object]"===Object.prototype.toString.call(n)}function i(n){return!o(n)&&!a(n)}function o(n){return void 0===n}function a(n){return null===n}function c(n,r){return i(n)&&n.length===r}function f(n){return l(n)&&0===n.length}function l(n){return Array.isArray(n)}function d(n){return i(n)&&T(n.length)}function s(n){return"undefined"==typeof Symbol?d(n):i(n)&&v(n[Symbol.iterator])}function b(n){return"[object Date]"===Object.prototype.toString.call(n)&&!isNaN(n.getTime())}function y(n){return"[object Error]"===Object.prototype.toString.call(n)}function v(n){return"function"==typeof n}function p(n,r){return I(n)&&!!n.match(r)}function m(n,r){return I(n)&&-1!==n.indexOf(r)}function g(n){return I(n)&&""!==n}function I(n){return"string"==typeof n}function h(n){return O(n)&&!j(n)}function j(n){return T(n)&&n%2===0}function O(n){return T(n)&&n%1===0}function E(n,r,t){return t>r?k(n,r)&&w(n,t):w(n,r)&&k(n,t)}function k(n,r){return T(n)&&n>=r}function w(n,r){return T(n)&&r>=n}function N(n,r,t){return t>r?S(n,r)&&A(n,t):A(n,r)&&S(n,t)}function S(n,r){return T(n)&&n>r}function A(n,r){return T(n)&&r>n}function L(n){return S(n,0)}function P(n){return A(n,0)}function T(n){return"number"==typeof n&&isNaN(n)===!1&&n!==Number.POSITIVE_INFINITY&&n!==Number.NEGATIVE_INFINITY}function q(n){return 0===n}function _(n){return n===!1||n===!0}function x(n,r){return dn.array(n),v(r)?n.map(function(n){return r(n)}):(dn.array(r),dn.hasLength(n,r.length),n.map(function(n,t){return r[t](n)}))}function z(n,r){return dn.object(n),v(r)?F(n,r):(dn.object(r),M(n,r))}function F(n,r){var t={};return Object.keys(n).forEach(function(e){t[e]=r(n[e])}),t}function M(n,r){var t={};return Object.keys(r).forEach(function(e){var i=r[e];v(i)?sn.assigned(n)?t[e]=!!i._isMaybefied:t[e]=i(n[e]):u(i)&&(t[e]=M(n[e],i))}),t}function R(n){return l(n)?V(n,!1):(dn.object(n),Y(n,!1))}function V(n,r){var t;for(t=0;t<n.length;t+=1)if(n[t]===r)return r;return!r}function Y(n,r){var t,e;for(t in n)if(n.hasOwnProperty(t)){if(e=n[t],u(e)&&Y(e,r)===r)return r;if(e===r)return r}return!r}function D(n){return l(n)?V(n,!0):(dn.object(n),Y(n,!0))}function G(n,r){return Object.keys(r).forEach(function(t){n[t]=r[t]}),n}function B(n,r){return function(){C(n,arguments,r)}}function C(n,r,t){var e=r[r.length-1];H(n.apply(null,r),g(e)?e:t)}function H(n,r){if(n===!1)throw new Error(r||"Assertion failed")}function J(n,r){return function(){function t(n,r){return n[r]=function(){if(e&&!fn[r].apply(null,arguments))throw e},n}var e;try{C(n,arguments,r)}catch(u){e=u}return{or:Object.keys(fn).reduce(t,{})}}}function K(n){return function(){return Q(n.apply(null,arguments))}}function Q(n){return!n}function U(n){var r=function(){return i(arguments[0])?n.apply(null,arguments):!0};return r._isMaybefied=!0,r}function W(n){return i(n)===!1?!0:n}function X(n){function r(){return!0}return function(){function t(n,t){return n[t]=e?r:fn[t],n}var e=n.apply(null,arguments);return{or:Object.keys(fn).reduce(t,{})}}}function Z(n,r,t){return function(){var e,u;if(e=arguments[0],!r(e))return!1;e=$(r,e),u=pn.call(arguments,1);try{e.forEach(function(r){if(("maybe"!==n||i(r))&&!t.apply(null,[r].concat(u)))throw 0})}catch(o){return!1}return!0}}function $(n,r){switch(n){case d:return pn.call(r);case u:return Object.keys(r).map(function(n){return r[n]});default:return r}}function nn(n,r){return rn([n,fn,r])}function rn(n){var r,t,e,u;return r=n.shift(),t=n.pop(),e=n.pop(),u=t||{},Object.keys(e).forEach(function(t){Object.defineProperty(u,t,{configurable:!1,enumerable:!0,writable:!1,value:r.apply(null,n.concat(e[t],cn[t]))})}),u}function tn(n,r){return rn([n,r,null])}function en(n){fn[n].of=rn([Z.bind(null,null),fn[n],fn,null])}function un(n,r){vn.forEach(function(t){n[t].of=tn(r,fn[t].of)})}function on(n){bn[n].of=rn([Z.bind(null,"maybe"),fn[n],fn,null]),dn.maybe[n].of=tn(B,bn[n].of),dn.not[n].of=tn(B,sn[n].of)}function an(r){"function"==typeof define&&define.amd?define(function(){return r}):"undefined"!=typeof module&&null!==module&&module.exports?module.exports=r:n.check=r}var cn,fn,ln,dn,sn,bn,yn,vn,pn;cn={like:"Invalid type",instance:"Invalid type",emptyObject:"Invalid object",object:"Invalid object",assigned:"Invalid value",undefined:"Invalid value","null":"Invalid value",hasLength:"Invalid length",emptyArray:"Invalid array",array:"Invalid array",arrayLike:"Invalid array-like object",iterable:"Invalid iterable",date:"Invalid date",error:"Invalid error",fn:"Invalid function",match:"Invalid string",contains:"Invalid string",unemptyString:"Invalid string",string:"Invalid string",odd:"Invalid number",even:"Invalid number",inRange:"Invalid number",greaterOrEqual:"Invalid number",lessOrEqual:"Invalid number",between:"Invalid number",greater:"Invalid number",less:"Invalid number",positive:"Invalid number",negative:"Invalid number",integer:"Invalid number",zero:"Invalid number",number:"Invalid number","boolean":"Invalid boolean"},fn={like:r,instance:t,emptyObject:e,object:u,assigned:i,undefined:o,"null":a,hasLength:c,emptyArray:f,array:l,arrayLike:d,iterable:s,date:b,error:y,"function":v,match:p,contains:m,unemptyString:g,string:I,odd:h,even:j,inRange:E,greaterOrEqual:k,lessOrEqual:w,between:N,greater:S,less:A,positive:L,negative:P,integer:O,zero:q,number:T,"boolean":_},ln={apply:x,map:z,all:R,any:D},vn=["array","arrayLike","iterable","object"],pn=Array.prototype.slice,ln=G(ln,fn),dn=nn(B,H),sn=nn(K,Q),bn=nn(U,W),yn=nn(X),dn.not=tn(B,sn),dn.maybe=tn(B,bn),dn.either=tn(J,fn),vn.forEach(en),un(dn,B),un(sn,K),vn.forEach(on),an(G(ln,{assert:dn,not:sn,maybe:bn,either:yn}))}(this);
\ No newline at end of file
diff --git a/test/test-next-updater/node_modules/check-types/test/check-types-browser.js b/test/test-next-updater/node_modules/check-types/test/check-types-browser.js
deleted file mode 100644
index eeac2ec..0000000
--- a/test/test-next-updater/node_modules/check-types/test/check-types-browser.js
+++ /dev/null
@@ -1,928 +0,0 @@
-(function () {
-    'use strict';
-
-    var assert = chai.assert;
-
-    suite('check-types.js:', function () {
-        test('verifyQuack function is defined', function () {
-            assert.isFunction(check.verifyQuack);
-        });
-
-        test('verifyQuack with two empty object arguments does not throw', function () {
-            assert.doesNotThrow(function () {
-                check.verifyQuack({}, {});
-            });
-        });
-
-        test('verifyQuack with foo bar properties throws', function () {
-            assert.throws(function () {
-                check.verifyQuack({ foo: {} }, { bar: {} });
-            });
-        });
-
-        test('verifyQuack with foo foo properties does not throw', function () {
-            assert.doesNotThrow(function () {
-                check.verifyQuack({ foo: {} }, { foo: {} });
-            });
-        });
-
-        test('verifyQuack with bar baz second properties throws', function () {
-            assert.throws(function () {
-                check.verifyQuack({ foo: {}, bar: {} }, { foo: {}, baz: {} });
-            });
-        });
-
-        test('verifyQuack with bar bar second properties does not throw', function () {
-            assert.doesNotThrow(function () {
-                check.verifyQuack({ foo: (function () {}), bar: {} }, { foo: (function () {}), bar: {} });
-            });
-        });
-
-        test('verifyQuack with differently typed bar bar second properties throws', function () {
-            assert.throws(function () {
-                check.verifyQuack({ foo: (function () {}), bar: {} }, { foo: (function () {}), bar: (function () {}) });
-            });
-        });
-
-        test('quacksLike function is defined', function () {
-            assert.isFunction(check.quacksLike);
-        });
-
-        test('quacksLike without arguments throws', function () {
-            assert.throws(function () {
-                check.quacksLike();
-            });
-        });
-
-        test('quacksLike with two object arguments does not throw', function () {
-            assert.doesNotThrow(function () {
-                check.quacksLike({}, {});
-            });
-        });
-
-        test('quacksLike with function first argument throws', function () {
-            assert.throws(function () {
-                check.quacksLike(function () {}, {});
-            });
-        });
-
-        test('quacksLike with null first argument throws', function () {
-            assert.throws(function () {
-                check.quacksLike(null, {});
-            });
-        });
-
-        test('quacksLike with function second argument throws', function () {
-            assert.throws(function () {
-                check.quacksLike({}, function () {});
-            });
-        });
-
-        test('quacksLike with null second argument throws', function () {
-            assert.throws(function () {
-                check.quacksLike({}, null);
-            });
-        });
-
-        test('quacksLike with two empty object arguments returns true', function () {
-            assert.isTrue(check.quacksLike({}, {}));
-        });
-
-        test('quacksLike with foo bar properties returns false', function () {
-            assert.isFalse(check.quacksLike({ foo: {} }, { bar: {} }));
-        });
-
-        test('quacksLike with foo foo properties returns true', function () {
-            assert.isTrue(check.quacksLike({ foo: {} }, { foo: {} }));
-        });
-
-        test('quacksLike with bar baz second properties returns false', function () {
-            assert.isFalse(check.quacksLike({ foo: {}, bar: {} }, { foo: {}, baz: {} }));
-        });
-
-        test('quacksLike with bar bar second properties returns true', function () {
-            assert.isTrue(check.quacksLike({ foo: (function () {}), bar: {} }, { foo: (function () {}), bar: {} }));
-        });
-
-        test('quacksLike with differently typed bar bar second properties returns false', function () {
-            assert.isFalse(check.quacksLike({ foo: (function () {}), bar: {} }, { foo: (function () {}), bar: (function () {}) }));
-        });
-
-        test('verifyInstance with new Error and Error does not throw', function () {
-            assert.doesNotThrow(function () {
-                check.verifyInstance(new Error(), Error);
-            });
-        });
-
-        test('verifyInstance with object and Error throws', function () {
-            assert.throws(function () {
-                check.verifyInstance({}, Error);
-            });
-        });
-
-        test('verifyInstance with null and null throws', function () {
-            assert.throws(function () {
-                check.verifyInstance(null, null);
-            });
-        });
-
-        test('verifyInstance with object and Object does not throw', function () {
-            assert.doesNotThrow(function () {
-                check.verifyInstance({}, Object);
-            });
-        });
-
-        test('verifyInstance with null and Object throws', function () {
-            assert.throws(function () {
-                check.verifyInstance(null, Object);
-            });
-        });
-
-        test('verifyInstance with array and Array does not throw', function () {
-            assert.doesNotThrow(function () {
-                check.verifyInstance([], Array);
-            });
-        });
-
-        test('verifyInstance with Object and object throws', function () {
-            assert.throws(function () {
-                check.verifyInstance(Object, {});
-            });
-        });
-
-        test('isInstance function is defined', function () {
-            assert.isFunction(check.isInstance);
-        });
-
-        test('isInstance with new Error and Error returns true', function () {
-            assert.isTrue(check.isInstance(new Error(), Error));
-        });
-
-        test('isInstance with object and Error returns false', function () {
-            assert.isFalse(check.isInstance({}, Error));
-        });
-
-        test('isInstance with null and null returns false', function () {
-            assert.isFalse(check.isInstance(null, null));
-        });
-
-        test('isInstance with object and Object returns true', function () {
-            assert.isTrue(check.isInstance({}, Object));
-        });
-
-        test('isInstance with null and Object returns false', function () {
-            assert.isFalse(check.isInstance(null, Object));
-        });
-
-        test('isInstance with array and Array returns true', function () {
-            assert.isTrue(check.isInstance([], Array));
-        });
-
-        test('isInstance with Object and object returns false', function () {
-            assert.isFalse(check.isInstance(Object, {}));
-        });
-
-        test('verifyEmptyObject function is defined', function () {
-            assert.isFunction(check.verifyEmptyObject);
-        });
-
-        test('verifyEmptyObject with empty object does not throw', function () {
-            assert.doesNotThrow(function () {
-                check.verifyEmptyObject({});
-            });
-        });
-
-        test('verifyEmptyObject with non-empty object throws', function () {
-            assert.throws(function () {
-                check.verifyEmptyObject({ foo: 'bar' });
-            });
-        });
-
-        test('verifyEmptyObject with null throws', function () {
-            assert.throws(function () {
-                check.verifyEmptyObject(null);
-            });
-        });
-
-        test('verifyEmptyObject with string throws', function () {
-            assert.throws(function () {
-                check.verifyEmptyObject('{}');
-            });
-        });
-
-        test('verifyEmptyObject with array throws', function () {
-            assert.throws(function () {
-                check.verifyEmptyObject([]);
-            });
-        });
-
-        test('isEmptyObject function is defined', function () {
-            assert.isFunction(check.isEmptyObject);
-        });
-
-        test('isEmptyObject with empty object returns true', function () {
-            assert.isTrue(check.isEmptyObject({}));
-        });
-
-        test('isEmptyObject with empty array returns false', function () {
-            assert.isFalse(check.isEmptyObject([]));
-        });
-
-        test('isEmptyObject with null returns false', function () {
-            assert.isFalse(check.isEmptyObject(null));
-        });
-
-        test('isEmptyObject with non-empty object returns false', function () {
-            assert.isFalse(check.isEmptyObject({ foo: 'bar' }));
-        });
-
-        test('verifyObject function is defined', function () {
-            assert.isFunction(check.verifyObject);
-        });
-
-        test('verifyObject with object does not throw', function () {
-            assert.doesNotThrow(function () {
-                check.verifyObject({});
-            });
-        });
-
-        test('verifyObject with null throws', function () {
-            assert.throws(function () {
-                check.verifyObject(null);
-            });
-        });
-
-        test('verifyObject with string throws', function () {
-            assert.throws(function () {
-                check.verifyObject('[]');
-            });
-        });
-
-        test('verifyObject with array throws', function () {
-            assert.throws(function () {
-                check.verifyObject([]);
-            });
-        });
-
-        test('isObject function is defined', function () {
-            assert.isFunction(check.isObject);
-        });
-
-        test('isObject with object returns true', function () {
-            assert.isTrue(check.isObject({}));
-        });
-
-        test('isObject with null returns false', function () {
-            assert.isFalse(check.isObject(null));
-        });
-
-        test('isObject with string returns false', function () {
-            assert.isFalse(check.isObject('{}'));
-        });
-
-        test('isObject with array returns false', function () {
-            assert.isFalse(check.isObject([]));
-        });
-
-        test('verifyLength function is defined', function () {
-            assert.isFunction(check.verifyLength);
-        });
-
-        test('verifyLength with matching undefined length does not throw', function () {
-            assert.doesNotThrow(function () {
-                check.verifyLength({});
-            });
-        });
-
-        test('verifyLength with contrasting undefined length throws', function () {
-            assert.throws(function () {
-                check.verifyLength({}, 42);
-            });
-        });
-
-        test('verifyLength with matching length on array does not throw', function () {
-            assert.doesNotThrow(function () {
-                check.verifyLength([ 1, 2, 3], 3);
-            });
-        });
-
-        test('verifyLength with contrasting length on array throws', function () {
-            assert.throws(function () {
-                check.verifyLength([ 2, 3], 3);
-            });
-        });
-
-        test('verifyLength with matching length on object does not throw', function () {
-            assert.doesNotThrow(function () {
-                check.verifyLength({ length: 4 }, 4);
-            });
-        });
-
-        test('verifyLength with contrasting length on object throws', function () {
-            assert.throws(function () {
-                check.verifyLength({ length: 5 }, 4);
-            });
-        });
-
-        test('isLength function is defined', function () {
-            assert.isFunction(check.isLength);
-        });
-
-        test('isLength with matching undefined length returns true', function () {
-            assert.isTrue(check.isLength({}));
-        });
-
-        test('isLength with contrasting undefined length returns false', function () {
-            assert.isFalse(check.isLength({}, 7));
-        });
-
-        test('isLength with matching length on array returns true', function () {
-            assert.isTrue(check.isLength([ 'foo', 'bar' ], 2));
-        });
-
-        test('isLength with contrasting length on array returns false', function () {
-            assert.isFalse(check.isLength([ 'foo', 'bar', 'baz' ], 2));
-        });
-
-        test('isLength with matching length on object returns true', function () {
-            assert.isTrue(check.isLength({ length: 1 }, 1));
-        });
-
-        test('isLength with contrasting length on object returns false', function () {
-            assert.isFalse(check.isLength({ length: 1 }, 2));
-        });
-
-        test('verifyArray function is defined', function () {
-            assert.isFunction(check.verifyArray);
-        });
-
-        test('verifyArray with array does not throw', function () {
-            assert.doesNotThrow(function () {
-                check.verifyArray([]);
-            });
-        });
-
-        test('verifyArray with null throws', function () {
-            assert.throws(function () {
-                check.verifyArray(null);
-            });
-        });
-
-        test('verifyArray with string throws', function () {
-            assert.throws(function () {
-                check.verifyArray('[]');
-            });
-        });
-
-        test('verifyArray with object throws', function () {
-            assert.throws(function () {
-                check.verifyArray({});
-            });
-        });
-
-        test('isArray function is defined', function () {
-            assert.isFunction(check.isArray);
-        });
-
-        test('isArray with array returns true', function () {
-            assert.isTrue(check.isArray([]));
-        });
-
-        test('isArray with null returns false', function () {
-            assert.isFalse(check.isArray(null));
-        });
-
-        test('isArray with string returns false', function () {
-            assert.isFalse(check.isArray('[]'));
-        });
-
-        test('isArray with object returns false', function () {
-            assert.isFalse(check.isArray({}));
-        });
-
-        test('verifyFunction function is defined', function () {
-            assert.isFunction(check.verifyFunction);
-        });
-
-        test('verifyFunction with function does not throw', function () {
-            assert.doesNotThrow(function () {
-                check.verifyFunction(function () {});
-            });
-        });
-
-        test('verifyFunction with null throws', function () {
-            assert.throws(function () {
-                check.verifyFunction(null);
-            });
-        });
-
-        test('verifyFunction with string throws', function () {
-            assert.throws(function () {
-                check.verifyFunction('[]');
-            });
-        });
-
-        test('verifyFunction with object throws', function () {
-            assert.throws(function () {
-                check.verifyFunction({});
-            });
-        });
-
-        test('verifyFunction with array throws', function () {
-            assert.throws(function () {
-                check.verifyFunction([]);
-            });
-        });
-
-        test('isFunction function is defined', function () {
-            assert.isFunction(check.isFunction);
-        });
-
-        test('isFunction with function returns true', function () {
-            assert.isTrue(check.isFunction(function () {}));
-        });
-
-        test('isFunction with null returns false', function () {
-            assert.isFalse(check.isFunction(null));
-        });
-
-        test('isFunction with string returns false', function () {
-            assert.isFalse(check.isFunction('function () {}'));
-        });
-
-        test('isFunction with object returns false', function () {
-            assert.isFalse(check.isFunction({}));
-        });
-
-        test('isFunction with array returns false', function () {
-            assert.isFalse(check.isFunction([]));
-        });
-
-        test('verifyUnemptyString function is defined', function () {
-            assert.isFunction(check.verifyUnemptyString);
-        });
-
-        test('verifyUnemptyString with string baz does not throw', function () {
-            assert.doesNotThrow(function () {
-                check.verifyUnemptyString('baz');
-            });
-        });
-
-        test('verifyUnemptyString with null throws', function () {
-            assert.throws(function () {
-                check.verifyUnemptyString(null);
-            });
-        });
-
-        test('verifyUnemptyString with empty string throws', function () {
-            assert.throws(function () {
-                check.verifyUnemptyString('');
-            });
-        });
-
-        test('verifyUnemptyString with object throws', function () {
-            assert.throws(function () {
-                check.verifyUnemptyString({});
-            });
-        });
-
-        test('verifyUnemptyString with string qux does not throw', function () {
-            assert.doesNotThrow(function () {
-                check.verifyUnemptyString('qux');
-            });
-        });
-
-        test('isUnemptyString function is defined', function () {
-            assert.isFunction(check.isUnemptyString);
-        });
-
-        test('isUnemptyString with string foo returns true', function () {
-            assert.isTrue(check.isUnemptyString('foo'));
-        });
-
-        test('isUnemptyString with null returns false', function () {
-            assert.isFalse(check.isUnemptyString(null));
-        });
-
-        test('isUnemptyString with empty string returns false', function () {
-            assert.isFalse(check.isUnemptyString(''));
-        });
-
-        test('isUnemptyString with object returns false', function () {
-            assert.isFalse(check.isUnemptyString({}));
-        });
-
-        test('isUnemptyString with string bar returns true', function () {
-            assert.isTrue(check.isUnemptyString('bar'));
-        });
-
-        test('verifyString function is defined', function () {
-            assert.isFunction(check.verifyString);
-        });
-
-        test('verifyString with string baz does not throw', function () {
-            assert.doesNotThrow(function () {
-                check.verifyString('baz');
-            });
-        });
-
-        test('verifyString with null throws', function () {
-            assert.throws(function () {
-                check.verifyString(null);
-            });
-        });
-
-        test('verifyString with empty string does not throw', function () {
-            assert.doesNotThrow(function () {
-                check.verifyString('');
-            });
-        });
-
-        test('verifyString with object throws', function () {
-            assert.throws(function () {
-                check.verifyString({});
-            });
-        });
-
-        test('isString function is defined', function () {
-            assert.isFunction(check.isString);
-        });
-
-        test('isString with string foo returns true', function () {
-            assert.isTrue(check.isString('foo'));
-        });
-
-        test('isString with null returns false', function () {
-            assert.isFalse(check.isString(null));
-        });
-
-        test('isString with empty string returns true', function () {
-            assert.isTrue(check.isString(''));
-        });
-
-        test('isString with object returns false', function () {
-            assert.isFalse(check.isString({}));
-        });
-
-        test('verifyPositiveNumber function is defined', function () {
-            assert.isFunction(check.verifyPositiveNumber);
-        });
-
-        test('verifyPositiveNumber with positive integer does not throw', function () {
-            assert.doesNotThrow(function () {
-                check.verifyPositiveNumber(1);
-            });
-        });
-
-        test('verifyPositiveNumber with negative integer throws', function () {
-            assert.throws(function () {
-                check.verifyPositiveNumber(-1);
-            });
-        });
-
-        test('verifyPositiveNumber with positive fraction does not throw', function () {
-            assert.doesNotThrow(function () {
-                check.verifyPositiveNumber(1/2);
-            });
-        });
-
-        test('verifyPositiveNumber with negative fraction throws', function () {
-            assert.throws(function () {
-                check.verifyPositiveNumber(-1/2);
-            });
-        });
-
-        test('verifyPositiveNumber with positive infinity does not throw', function () {
-            assert.doesNotThrow(function () {
-                check.verifyPositiveNumber(Infinity);
-            });
-        });
-
-        test('verifyPositiveNumber with negative infinity throws', function () {
-            assert.throws(function () {
-                check.verifyPositiveNumber(-Infinity);
-            });
-        });
-
-        test('verifyPositiveNumber with NaN throws', function () {
-            assert.throws(function () {
-                check.verifyPositiveNumber(NaN);
-            });
-        });
-
-        test('verifyPositiveNumber with object throws', function () {
-            assert.throws(function () {
-                check.verifyPositiveNumber({});
-            });
-        });
-
-        test('verifyPositiveNumber with string throws', function () {
-            assert.throws(function () {
-                check.verifyPositiveNumber('1');
-            });
-        });
-
-        test('isPositiveNumber function is defined', function () {
-            assert.isFunction(check.isPositiveNumber);
-        });
-
-        test('isPositiveNumber with positive integer returns true', function () {
-            assert.isTrue(check.isPositiveNumber(1));
-        });
-
-        test('isPositiveNumber with negative integer returns false', function () {
-            assert.isFalse(check.isPositiveNumber(-1));
-        });
-
-        test('isPositiveNumber with positive fraction returns true', function () {
-            assert.isTrue(check.isPositiveNumber(1/2));
-        });
-
-        test('isPositiveNumber with negative fraction returns false', function () {
-            assert.isFalse(check.isPositiveNumber(-1/2));
-        });
-
-        test('isPositiveNumber with positive infinity returns true', function () {
-            assert.isTrue(check.isPositiveNumber(Infinity));
-        });
-
-        test('isPositiveNumber with negative infinity returns false', function () {
-            assert.isFalse(check.isPositiveNumber(-Infinity));
-        });
-
-        test('isPositiveNumber with NaN returns false', function () {
-            assert.isFalse(check.isPositiveNumber(NaN));
-        });
-
-        test('isPositiveNumber with object returns false', function () {
-            assert.isFalse(check.isPositiveNumber({}));
-        });
-
-        test('isPositiveNumber with string returns false', function () {
-            assert.isFalse(check.isPositiveNumber('1'));
-        });
-
-        test('verifyNegativeNumber function is defined', function () {
-            assert.isFunction(check.verifyNegativeNumber);
-        });
-
-        test('verifyNegativeNumber with positive integer throws', function () {
-            assert.throws(function () {
-                check.verifyNegativeNumber(1);
-            });
-        });
-
-        test('verifyNegativeNumber with negative integer does not throw', function () {
-            assert.doesNotThrow(function () {
-                check.verifyNegativeNumber(-1);
-            });
-        });
-
-        test('verifyNegativeNumber with positive fraction throws', function () {
-            assert.throws(function () {
-                check.verifyNegativeNumber(1/2);
-            });
-        });
-
-        test('verifyNegativeNumber with negative fraction does not throw', function () {
-            assert.doesNotThrow(function () {
-                check.verifyNegativeNumber(-1/2);
-            });
-        });
-
-        test('verifyNegativeNumber with positive infinity throws', function () {
-            assert.throws(function () {
-                check.verifyNegativeNumber(Infinity);
-            });
-        });
-
-        test('verifyNegativeNumber with negative infinity does not throw', function () {
-            assert.doesNotThrow(function () {
-                check.verifyNegativeNumber(-Infinity);
-            });
-        });
-
-        test('verifyNegativeNumber with NaN throws', function () {
-            assert.throws(function () {
-                check.verifyNegativeNumber(NaN);
-            });
-        });
-
-        test('verifyNegativeNumber with object throws', function () {
-            assert.throws(function () {
-                check.verifyNegativeNumber({});
-            });
-        });
-
-        test('verifyNegativeNumber with string throws', function () {
-            assert.throws(function () {
-                check.verifyNegativeNumber('-1');
-            });
-        });
-
-        test('isNegativeNumber function is defined', function () {
-            assert.isFunction(check.isNegativeNumber);
-        });
-
-        test('isNegativeNumber with positive integer returns false', function () {
-            assert.isFalse(check.isNegativeNumber(1));
-        });
-
-        test('isNegativeNumber with negative integer returns true', function () {
-            assert.isTrue(check.isNegativeNumber(-1));
-        });
-
-        test('isNegativeNumber with positive fraction returns false', function () {
-            assert.isFalse(check.isNegativeNumber(1/2));
-        });
-
-        test('isNegativeNumber with negative fraction returns true', function () {
-            assert.isTrue(check.isNegativeNumber(-1/2));
-        });
-
-        test('isNegativeNumber with positive infinity returns false', function () {
-            assert.isFalse(check.isNegativeNumber(Infinity));
-        });
-
-        test('isNegativeNumber with negative infinity returns true', function () {
-            assert.isTrue(check.isNegativeNumber(-Infinity));
-        });
-
-        test('isNegativeNumber with NaN returns false', function () {
-            assert.isFalse(check.isNegativeNumber(NaN));
-        });
-
-        test('isNegativeNumber with object returns false', function () {
-            assert.isFalse(check.isNegativeNumber({}));
-        });
-
-        test('isNegativeNumber with string returns false', function () {
-            assert.isFalse(check.isNegativeNumber('1'));
-        });
-
-        test('verifyNumber function is defined', function () {
-            assert.isFunction(check.verifyNumber);
-        });
-
-        test('verifyNumber with positive integer does not throw', function () {
-            assert.doesNotThrow(function () {
-                check.verifyNumber(1);
-            });
-        });
-
-        test('verifyNumber with negative integer does not throw', function () {
-            assert.doesNotThrow(function () {
-                check.verifyNumber(-1);
-            });
-        });
-
-        test('verifyNumber with fraction does not throw', function () {
-            assert.doesNotThrow(function () {
-                check.verifyNumber(1/2);
-            });
-        });
-
-        test('verifyNumber with positive infinity does not throw', function () {
-            assert.doesNotThrow(function () {
-                check.verifyNumber(Infinity);
-            });
-        });
-
-        test('verifyNumber with negative infinity does not throw', function () {
-            assert.doesNotThrow(function () {
-                check.verifyNumber(-Infinity);
-            });
-        });
-
-        test('verifyNumber with NaN throws', function () {
-            assert.throws(function () {
-                check.verifyNumber(NaN);
-            });
-        });
-
-        test('verifyNumber with object throws', function () {
-            assert.throws(function () {
-                check.verifyNumber({});
-            });
-        });
-
-        test('verifyNumber with string throws', function () {
-            assert.throws(function () {
-                check.verifyNumber('1');
-            });
-        });
-
-        test('isNumber function is defined', function () {
-            assert.isFunction(check.isNumber);
-        });
-
-        test('isNumber with positive integer returns true', function () {
-            assert.isTrue(check.isNumber(1));
-        });
-
-        test('isNumber with negative integer returns true', function () {
-            assert.isTrue(check.isNumber(-1));
-        });
-
-        test('isNumber with fraction returns true', function () {
-            assert.isTrue(check.isNumber(1/2));
-        });
-
-        test('isNumber with Infinity returns true', function () {
-            assert.isTrue(check.isNumber(Infinity));
-        });
-
-        test('isNumber with NaN returns false', function () {
-            assert.isFalse(check.isNumber(NaN));
-        });
-
-        test('isNumber with object returns false', function () {
-            assert.isFalse(check.isNumber({}));
-        });
-
-        test('isNumber with string returns false', function () {
-            assert.isFalse(check.isNumber('1'));
-        });
-
-        test('isOddNumber with string returns false', function () {
-            assert.isFalse(check.isOddNumber('1'));
-        });
-
-        test('isOddNumber with odd number returns true', function () {
-            assert.isTrue(check.isOddNumber(1));
-        });
-
-        test('isOddNumber with even number returns false', function () {
-            assert.isFalse(check.isOddNumber(2));
-        });
-
-        test('isOddNumber with alternative odd number returns true', function () {
-            assert.isTrue(check.isOddNumber(3));
-        });
-
-        test('isOddNumber with negative odd number returns true', function () {
-            assert.isTrue(check.isOddNumber(-5));
-        });
-
-        test('isOddNumber with negative even number returns false', function () {
-            assert.isFalse(check.isOddNumber(-4));
-        });
-
-        test('isOddNumber with floating point number returns false', function () {
-            assert.isFalse(check.isEvenNumber(3.5));
-        });
-
-        test('verifyOddNumber with odd number does not throw', function () {
-            assert.doesNotThrow(function () {
-                check.verifyOddNumber(-7);
-            });
-        });
-
-        test('verifyOddNumber with even number throws', function () {
-            assert.throws(function () {
-                check.verifyOddNumber(8);
-            });
-        });
-
-        test('isEvenNumber with string returns false', function () {
-            assert.isFalse(check.isEvenNumber('2'));
-        });
-
-        test('isEvenNumber with odd number returns false', function () {
-            assert.isFalse(check.isEvenNumber(1));
-        });
-
-        test('isEvenNumber with even number returns true', function () {
-            assert.isTrue(check.isEvenNumber(2));
-        });
-
-        test('isEvenNumber with alternative even number returns true', function () {
-            assert.isTrue(check.isEvenNumber(4));
-        });
-
-        test('isEvenNumber with negative odd number returns false', function () {
-            assert.isFalse(check.isEvenNumber(-5));
-        });
-
-        test('isEvenNumber with negative even number returns true', function () {
-            assert.isTrue(check.isEvenNumber(-6));
-        });
-
-        test('isEvenNumber with floating point number returns false', function () {
-            assert.isFalse(check.isEvenNumber(2.4));
-        });
-
-        test('verifyEvenNumber with odd number throws', function () {
-            assert.throws(function () {
-                check.verifyEvenNumber(7);
-            });
-        });
-
-        test('verifyEvenNumber with even number does not throw', function () {
-            assert.doesNotThrow(function () {
-                check.verifyEvenNumber(-8);
-            });
-        });
-    });
-}());
-
diff --git a/test/test-next-updater/node_modules/check-types/test/check-types.html b/test/test-next-updater/node_modules/check-types/test/check-types.html
index 39765c8..03cf047 100644
--- a/test/test-next-updater/node_modules/check-types/test/check-types.html
+++ b/test/test-next-updater/node_modules/check-types/test/check-types.html
@@ -13,7 +13,7 @@
       mocha.setup('tdd');
     </script>
     <script src="../src/check-types.min.js"></script>
-    <script src="check-types-browser.js"></script>
+    <script src="check-types.js"></script>
     <script>
       mocha.checkLeaks();
       mocha.run();
diff --git a/test/test-next-updater/node_modules/check-types/test/check-types.js b/test/test-next-updater/node_modules/check-types/test/check-types.js
index 0b43027..072446d 100644
--- a/test/test-next-updater/node_modules/check-types/test/check-types.js
+++ b/test/test-next-updater/node_modules/check-types/test/check-types.js
@@ -1,1001 +1,1892 @@
-/*globals require */
+/*globals require, chai */
 
-(function () {
+(function (require) {
     'use strict';
 
-    var assert = require('chai').assert,
-        module = '../src/check-types';
+    var assert, modulePath;
+
+    if (typeof require === 'undefined') {
+        assert = chai.assert;
+        require = function () { return check; };
+    } else {
+        assert = require('chai').assert;
+        modulePath = '../src/check-types';
+    }
 
     suite('no setup:', function () {
         test('require does not throw', function () {
             assert.doesNotThrow(function () {
-                require(module);
+                require(modulePath);
             });
         });
 
         test('require returns object', function () {
-            assert.isObject(require(module));
+            assert.isObject(require(modulePath));
         });
     });
 
     suite('require:', function () {
-        var types;
+        var check;
 
         setup(function () {
-            types = require(module);
+            check = require(modulePath);
         });
 
         teardown(function () {
-            types = undefined;
+            check = undefined;
         });
 
-        test('verifyQuack function is defined', function () {
-            assert.isFunction(types.verifyQuack);
+        test('like function is defined', function () {
+            assert.isFunction(check.like);
         });
 
-        test('verifyQuack with two empty object arguments does not throw', function () {
-            assert.doesNotThrow(function () {
-                types.verifyQuack({}, {});
-            });
+        test('like with two empty object arguments returns true', function () {
+            assert.isTrue(check.like({}, {}));
         });
 
-        test('verifyQuack with foo bar properties throws', function () {
-            assert.throws(function () {
-                types.verifyQuack({ foo: {} }, { bar: {} });
-            });
+        test('like with different named properties returns false', function () {
+            assert.isFalse(check.like({ foo: {} }, { bar: {} }));
         });
 
-        test('verifyQuack with foo foo properties does not throw', function () {
-            assert.doesNotThrow(function () {
-                types.verifyQuack({ foo: {} }, { foo: {} });
-            });
+        test('like with same named properties returns true', function () {
+            assert.isTrue(check.like({ foo: {} }, { foo: {} }));
         });
 
-        test('verifyQuack with bar baz second properties throws', function () {
-            assert.throws(function () {
-                types.verifyQuack({ foo: {}, bar: {} }, { foo: {}, baz: {} });
-            });
+        test('like with different named second properties returns false', function () {
+            assert.isFalse(check.like({ foo: {}, bar: {} }, { foo: {}, baz: {} }));
         });
 
-        test('verifyQuack with bar bar second properties does not throw', function () {
-            assert.doesNotThrow(function () {
-                types.verifyQuack({ foo: (function () {}), bar: {} }, { foo: (function () {}), bar: {} });
-            });
+        test('like with same named second properties returns true', function () {
+            assert.isTrue(check.like({ foo: function () {}, bar: {} }, { foo: function () {}, bar: {} }));
         });
 
-        test('verifyQuack with differently typed bar bar second properties throws', function () {
-            assert.throws(function () {
-                types.verifyQuack({ foo: (function () {}), bar: {} }, { foo: (function () {}), bar: (function () {}) });
-            });
+        test('like with differently typed second properties returns false', function () {
+            assert.isFalse(check.like({ foo: function () {}, bar: {} }, { foo: function () {}, bar: function () {} }));
         });
 
-        test('quacksLike function is defined', function () {
-            assert.isFunction(types.quacksLike);
+        test('like with different nested objects returns false', function () {
+            assert.isFalse(check.like({ foo: { bar: { qux: 'string' }, baz: 23 }},
+                                      { foo: { bar: { qux: 123      }, baz: 66 }}));
         });
 
-        test('quacksLike without arguments throws', function () {
-            assert.throws(function () {
-                types.quacksLike();
-            });
+        test('like with similar nested objects returns true', function () {
+            assert.isTrue(check.like({ foo: { bar: { qux: 'string' }, baz: 23 }},
+                                     { foo: { bar: { qux: 'other'  }, baz: 66 }}));
         });
 
-        test('quacksLike with two object arguments does not throw', function () {
-            assert.doesNotThrow(function () {
-                types.quacksLike({}, {});
-            });
+        test('instance function is defined', function () {
+            assert.isFunction(check.instance);
         });
 
-        test('quacksLike with function first argument throws', function () {
-            assert.throws(function () {
-                types.quacksLike(function () {}, {});
-            });
+        test('instance with new Error and Error returns true', function () {
+            assert.isTrue(check.instance(new Error(), Error));
         });
 
-        test('quacksLike with null first argument throws', function () {
-            assert.throws(function () {
-                types.quacksLike(null, {});
-            });
+        test('instance with object and Error returns false', function () {
+            assert.isFalse(check.instance({}, Error));
         });
 
-        test('quacksLike with function second argument throws', function () {
-            assert.throws(function () {
-                types.quacksLike({}, function () {});
-            });
+        test('instance with null and null returns false', function () {
+            assert.isFalse(check.instance(null, null));
         });
 
-        test('quacksLike with null second argument throws', function () {
-            assert.throws(function () {
-                types.quacksLike({}, null);
-            });
+        test('instance with object and Object returns true', function () {
+            assert.isTrue(check.instance({}, Object));
         });
 
-        test('quacksLike with two empty object arguments returns true', function () {
-            assert.isTrue(types.quacksLike({}, {}));
+        test('instance with null and Object returns false', function () {
+            assert.isFalse(check.instance(null, Object));
         });
 
-        test('quacksLike with foo bar properties returns false', function () {
-            assert.isFalse(types.quacksLike({ foo: {} }, { bar: {} }));
+        test('instance with array and Array returns true', function () {
+            assert.isTrue(check.instance([], Array));
         });
 
-        test('quacksLike with foo foo properties returns true', function () {
-            assert.isTrue(types.quacksLike({ foo: {} }, { foo: {} }));
+        test('instance with swapped arguments returns false', function () {
+            assert.isFalse(check.instance(Object, {}));
         });
 
-        test('quacksLike with bar baz second properties returns false', function () {
-            assert.isFalse(types.quacksLike({ foo: {}, bar: {} }, { foo: {}, baz: {} }));
+        test('emptyObject function is defined', function () {
+            assert.isFunction(check.emptyObject);
         });
 
-        test('quacksLike with bar bar second properties returns true', function () {
-            assert.isTrue(types.quacksLike({ foo: (function () {}), bar: {} }, { foo: (function () {}), bar: {} }));
+        test('emptyObject with empty object returns true', function () {
+            assert.isTrue(check.emptyObject({}));
         });
 
-        test('quacksLike with differently typed bar bar second properties returns false', function () {
-            assert.isFalse(types.quacksLike({ foo: (function () {}), bar: {} }, { foo: (function () {}), bar: (function () {}) }));
+        test('emptyObject with empty array returns false', function () {
+            assert.isFalse(check.emptyObject([]));
         });
 
-        test('verifyInstance with new Error and Error does not throw', function () {
-            assert.doesNotThrow(function () {
-                types.verifyInstance(new Error(), Error);
-            });
+        test('emptyObject with null returns false', function () {
+            assert.isFalse(check.emptyObject(null));
         });
 
-        test('verifyInstance with object and Error throws', function () {
-            assert.throws(function () {
-                types.verifyInstance({}, Error);
-            });
+        test('emptyObject with non-empty object returns false', function () {
+            assert.isFalse(check.emptyObject({ foo: 'bar' }));
         });
 
-        test('verifyInstance with null and null throws', function () {
-            assert.throws(function () {
-                types.verifyInstance(null, null);
-            });
+        test('null function is defined', function () {
+            assert.isFunction(check.null);
         });
 
-        test('verifyInstance with object and Object does not throw', function () {
-            assert.doesNotThrow(function () {
-                types.verifyInstance({}, Object);
-            });
+        test('null with null returns true', function () {
+            assert.isTrue(check.null(null));
         });
 
-        test('verifyInstance with null and Object throws', function () {
-            assert.throws(function () {
-                types.verifyInstance(null, Object);
-            });
+        test('null with empty object returns false', function () {
+            assert.isFalse(check.null({}));
         });
 
-        test('verifyInstance with array and Array does not throw', function () {
-            assert.doesNotThrow(function () {
-                types.verifyInstance([], Array);
-            });
+        test('null with undefined returns false', function () {
+            assert.isFalse(check.null(undefined));
         });
 
-        test('verifyInstance with Object and object throws', function () {
-            assert.throws(function () {
-                types.verifyInstance(Object, {});
-            });
+        test('undefined function is defined', function () {
+            assert.isFunction(check.undefined);
         });
 
-        test('isInstance function is defined', function () {
-            assert.isFunction(types.isInstance);
+        test('undefined with undefined returns true', function () {
+            assert.isTrue(check.undefined(undefined));
         });
 
-        test('isInstance with new Error and Error returns true', function () {
-            assert.isTrue(types.isInstance(new Error(), Error));
+        test('undefined with null returns false', function () {
+            assert.isFalse(check.undefined(null));
         });
 
-        test('isInstance with object and Error returns false', function () {
-            assert.isFalse(types.isInstance({}, Error));
+        test('undefined with empty object returns false', function () {
+            assert.isFalse(check.undefined({}));
         });
 
-        test('isInstance with null and null returns false', function () {
-            assert.isFalse(types.isInstance(null, null));
+        test('undefined with false returns false', function () {
+            assert.isFalse(check.undefined(false));
         });
 
-        test('isInstance with object and Object returns true', function () {
-            assert.isTrue(types.isInstance({}, Object));
+        test('assigned function is defined', function () {
+            assert.isFunction(check.assigned);
         });
 
-        test('isInstance with null and Object returns false', function () {
-            assert.isFalse(types.isInstance(null, Object));
+        test('assigned with null returns false', function () {
+            assert.isFalse(check.assigned(null));
         });
 
-        test('isInstance with array and Array returns true', function () {
-            assert.isTrue(types.isInstance([], Array));
+        test('assigned with undefined returns false', function () {
+            assert.isFalse(check.assigned(undefined));
         });
 
-        test('isInstance with Object and object returns false', function () {
-            assert.isFalse(types.isInstance(Object, {}));
+        test('assigned with empty object returns true', function () {
+            assert.isTrue(check.assigned({}));
         });
 
-        test('verifyEmptyObject function is defined', function () {
-            assert.isFunction(types.verifyEmptyObject);
+        test('assigned with empty string returns true', function () {
+            assert.isTrue(check.assigned(''));
         });
 
-        test('verifyEmptyObject with empty object does not throw', function () {
-            assert.doesNotThrow(function () {
-                types.verifyEmptyObject({});
-            });
+        test('assigned with false returns true', function () {
+            assert.isTrue(check.assigned(false));
         });
 
-        test('verifyEmptyObject with non-empty object throws', function () {
-            assert.throws(function () {
-                types.verifyEmptyObject({ foo: 'bar' });
-            });
+        test('object function is defined', function () {
+            assert.isFunction(check.object);
         });
 
-        test('verifyEmptyObject with null throws', function () {
-            assert.throws(function () {
-                types.verifyEmptyObject(null);
-            });
+        test('object with object returns true', function () {
+            assert.isTrue(check.object({}));
         });
 
-        test('verifyEmptyObject with string throws', function () {
-            assert.throws(function () {
-                types.verifyEmptyObject('{}');
-            });
+        test('object with null returns false', function () {
+            assert.isFalse(check.object(null));
         });
 
-        test('verifyEmptyObject with array throws', function () {
-            assert.throws(function () {
-                types.verifyEmptyObject([]);
-            });
+        test('object with array returns false', function () {
+            assert.isFalse(check.object([]));
         });
 
-        test('isEmptyObject function is defined', function () {
-            assert.isFunction(types.isEmptyObject);
+        test('object with string returns false', function () {
+            assert.isFalse(check.object(''));
         });
 
-        test('isEmptyObject with empty object returns true', function () {
-            assert.isTrue(types.isEmptyObject({}));
+        test('object with date returns false', function () {
+            assert.isFalse(check.object(new Date()));
         });
 
-        test('isEmptyObject with empty array returns false', function () {
-            assert.isFalse(types.isEmptyObject([]));
+        test('object with error returns false', function () {
+            assert.isFalse(check.object(new Error()));
         });
 
-        test('isEmptyObject with null returns false', function () {
-            assert.isFalse(types.isEmptyObject(null));
+        test('hasLength function is defined', function () {
+            assert.isFunction(check.hasLength);
         });
 
-        test('isEmptyObject with non-empty object returns false', function () {
-            assert.isFalse(types.isEmptyObject({ foo: 'bar' }));
+        test('hasLength with zero on empty array returns true', function () {
+            assert.isTrue(check.hasLength([], 0));
         });
 
-        test('verifyObject function is defined', function () {
-            assert.isFunction(types.verifyObject);
+        test('hasLength with zero on empty string returns true', function () {
+            assert.isTrue(check.hasLength('', 0));
         });
 
-        test('verifyObject with object does not throw', function () {
-            assert.doesNotThrow(function () {
-                types.verifyObject({});
-            });
+        test('hasLength with zero on empty object returns false', function () {
+            assert.isFalse(check.hasLength({}, 0));
         });
 
-        test('verifyObject with null throws', function () {
-            assert.throws(function () {
-                types.verifyObject(null);
-            });
+        test('hasLength with matching length on array returns true', function () {
+            assert.isTrue(check.hasLength([ 'foo', 'bar' ], 2));
         });
 
-        test('verifyObject with string throws', function () {
-            assert.throws(function () {
-                types.verifyObject('[]');
-            });
+        test('hasLength with contrasting length on array returns false', function () {
+            assert.isFalse(check.hasLength([ 'foo', 'bar', 'baz' ], 2));
         });
 
-        test('verifyObject with array throws', function () {
-            assert.throws(function () {
-                types.verifyObject([]);
-            });
+        test('hasLength with matching length on string returns true', function () {
+            assert.isTrue(check.hasLength('foo', 3));
         });
 
-        test('verifyObject with date throws', function () {
-            assert.throws(function () {
-                types.verifyObject(new Date());
-            });
+        test('hasLength with contrasting length on string returns false', function () {
+            assert.isFalse(check.hasLength('foobar', 3));
         });
 
-        test('isObject function is defined', function () {
-            assert.isFunction(types.isObject);
+        test('hasLength with matching length on object returns true', function () {
+            assert.isTrue(check.hasLength({ length: 1 }, 1));
         });
 
-        test('isObject with object returns true', function () {
-            assert.isTrue(types.isObject({}));
+        test('hasLength with contrasting length on object returns false', function () {
+            assert.isFalse(check.hasLength({ length: 2 }, 1));
         });
 
-        test('isObject with null returns false', function () {
-            assert.isFalse(types.isObject(null));
+        test('array function is defined', function () {
+            assert.isFunction(check.array);
         });
 
-        test('isObject with string returns false', function () {
-            assert.isFalse(types.isObject('{}'));
+        test('array with array returns true', function () {
+            assert.isTrue(check.array([]));
         });
 
-        test('isObject with array returns false', function () {
-            assert.isFalse(types.isObject([]));
+        test('array with string returns false', function () {
+            assert.isFalse(check.array(''));
         });
 
-        test('isObject with date returns false', function () {
-            assert.isFalse(types.isObject(new Date()));
+        test('array with object returns false', function () {
+            assert.isFalse(check.array({}));
         });
 
-        test('verifyLength function is defined', function () {
-            assert.isFunction(types.verifyLength);
+        test('array with arguments object returns false', function () {
+            assert.isFalse(check.array(arguments));
         });
 
-        test('verifyLength with matching undefined length does not throw', function () {
-            assert.doesNotThrow(function () {
-                types.verifyLength({});
-            });
+        test('emptyArray function is defined', function () {
+            assert.isFunction(check.emptyArray);
         });
 
-        test('verifyLength with contrasting undefined length throws', function () {
-            assert.throws(function () {
-                types.verifyLength({}, 42);
-            });
+        test('emptyArray with empty array returns true', function () {
+            assert.isTrue(check.emptyArray([]));
         });
 
-        test('verifyLength with matching length on array does not throw', function () {
-            assert.doesNotThrow(function () {
-                types.verifyLength([ 1, 2, 3], 3);
-            });
+        test('emptyArray with empty object returns false', function () {
+            assert.isFalse(check.emptyArray({}));
         });
 
-        test('verifyLength with contrasting length on array throws', function () {
-            assert.throws(function () {
-                types.verifyLength([ 2, 3], 3);
-            });
+        test('emptyArray with null returns false', function () {
+            assert.isFalse(check.emptyArray(null));
         });
 
-        test('verifyLength with matching length on object does not throw', function () {
-            assert.doesNotThrow(function () {
-                types.verifyLength({ length: 4 }, 4);
-            });
+        test('emptyArray with non-empty array returns false', function () {
+            assert.isFalse(check.emptyArray([ 'foo' ]));
         });
 
-        test('verifyLength with contrasting length on object throws', function () {
-            assert.throws(function () {
-                types.verifyLength({ length: 5 }, 4);
-            });
+        test('arrayLike function is defined', function () {
+            assert.isFunction(check.arrayLike);
         });
 
-        test('isLength function is defined', function () {
-            assert.isFunction(types.isLength);
+        test('arrayLike with array returns true', function () {
+            assert.isTrue(check.arrayLike([]));
         });
 
-        test('isLength with matching undefined length returns true', function () {
-            assert.isTrue(types.isLength({}));
+        test('arrayLike with string returns true', function () {
+            assert.isTrue(check.arrayLike(''));
         });
 
-        test('isLength with contrasting undefined length returns false', function () {
-            assert.isFalse(types.isLength({}, 7));
+        test('arrayLike with object returns false', function () {
+            assert.isFalse(check.arrayLike({}));
         });
 
-        test('isLength with matching length on array returns true', function () {
-            assert.isTrue(types.isLength([ 'foo', 'bar' ], 2));
+        test('arrayLike with arguments object returns true', function () {
+            assert.isTrue(check.arrayLike(arguments));
         });
 
-        test('isLength with contrasting length on array returns false', function () {
-            assert.isFalse(types.isLength([ 'foo', 'bar', 'baz' ], 2));
+        test('arrayLike with map returns false', function () {
+            if (typeof Map !== 'undefined') {
+                assert.isFalse(check.arrayLike(new Map()));
+            }
         });
 
-        test('isLength with matching length on object returns true', function () {
-            assert.isTrue(types.isLength({ length: 1 }, 1));
+        test('iterable function is defined', function () {
+            assert.isFunction(check.iterable);
         });
 
-        test('isLength with contrasting length on object returns false', function () {
-            assert.isFalse(types.isLength({ length: 1 }, 2));
+        test('iterable with array returns true', function () {
+            assert.isTrue(check.iterable([]));
         });
 
-        test('verifyArray function is defined', function () {
-            assert.isFunction(types.verifyArray);
+        test('iterable with string returns true', function () {
+            assert.isTrue(check.iterable(''));
         });
 
-        test('verifyArray with array does not throw', function () {
-            assert.doesNotThrow(function () {
-                types.verifyArray([]);
-            });
+        test('iterable with object returns false', function () {
+            assert.isFalse(check.iterable({}));
         });
 
-        test('verifyArray with null throws', function () {
-            assert.throws(function () {
-                types.verifyArray(null);
-            });
+        test('iterable with set returns true in ES6 environments', function () {
+            if (typeof Symbol !== 'undefined') {
+                assert.isTrue(check.iterable(new Set()));
+            }
         });
 
-        test('verifyArray with string throws', function () {
-            assert.throws(function () {
-                types.verifyArray('[]');
-            });
+        test('date function is defined', function () {
+            assert.isFunction(check.date);
         });
 
-        test('verifyArray with object throws', function () {
-            assert.throws(function () {
-                types.verifyArray({});
-            });
+        test('date with date returns true', function () {
+            assert.isTrue(check.date(new Date()));
         });
 
-        test('isArray function is defined', function () {
-            assert.isFunction(types.isArray);
+        test('date with invalid date returns false', function () {
+            assert.isFalse(check.date(new Date('foo')));
         });
 
-        test('isArray with array returns true', function () {
-            assert.isTrue(types.isArray([]));
+        test('date with object returns false', function () {
+            assert.isFalse(check.date({}));
         });
 
-        test('isArray with null returns false', function () {
-            assert.isFalse(types.isArray(null));
+        test('error function is defined', function () {
+            assert.isFunction(check.error);
         });
 
-        test('isArray with string returns false', function () {
-            assert.isFalse(types.isArray('[]'));
+        test('error with error returns true', function () {
+            assert.isTrue(check.error(new Error()));
         });
 
-        test('isArray with object returns false', function () {
-            assert.isFalse(types.isArray({}));
+        test('error with object returns false', function () {
+            assert.isFalse(check.error({}));
         });
 
-        test('verifyDate function is defined', function () {
-            assert.isFunction(types.verifyDate);
+        test('function function is defined', function () {
+            assert.isFunction(check.function);
         });
 
-        test('verifyDate with date does not throw', function () {
-            assert.doesNotThrow(function () {
-                types.verifyDate(new Date());
-            });
+        test('function with function returns true', function () {
+            assert.isTrue(check.function(function () {}));
         });
 
-        test('verifyDate with object throws', function () {
-            assert.throws(function () {
-                types.verifyDate({});
-            });
+        test('function with object returns false', function () {
+            assert.isFalse(check.function({}));
         });
 
-        test('verifyDate with string throws', function () {
-            assert.throws(function () {
-                types.verifyDate('new Date()');
-            });
+        test('match function is defined', function () {
+            assert.isFunction(check.match);
         });
 
-        test('isDate function is defined', function () {
-            assert.isFunction(types.isDate);
+        test('match with match returns true', function () {
+            assert.isTrue(check.match('foo', /^FOO$/i));
         });
 
-        test('isDate with date returns true', function () {
-            assert.isTrue(types.isDate(new Date()));
+        test('match with no match returns false', function () {
+            assert.isFalse(check.match('foo', /^foO$/));
         });
 
-        test('isDate with object returns false', function () {
-            assert.isFalse(types.isDate({}));
+        test('match with object returns false', function () {
+            assert.isFalse(
+                check.match({
+                    toString: function () {
+                        return 'foo';
+                    }
+                }, /^foo$/)
+            );
         });
 
-        test('isDate with string returns false', function () {
-            assert.isFalse(types.isDate('new Date()'));
+        test('contains function is defined', function () {
+            assert.isFunction(check.contains);
         });
 
-        test('verifyFunction function is defined', function () {
-            assert.isFunction(types.verifyFunction);
+        test('contains with match returns true', function () {
+            assert.isTrue(check.contains('foo', 'oo'));
         });
 
-        test('verifyFunction with function does not throw', function () {
-            assert.doesNotThrow(function () {
-                types.verifyFunction(function () {});
-            });
+        test('contains with no match returns false', function () {
+            assert.isFalse(check.contains('foo', 'bar'));
         });
 
-        test('verifyFunction with null throws', function () {
-            assert.throws(function () {
-                types.verifyFunction(null);
-            });
+        test('contains with object returns false', function () {
+            assert.isFalse(
+                check.contains({
+                    toString: function () {
+                        return 'foo';
+                    }
+                }, 'oo')
+            );
         });
 
-        test('verifyFunction with string throws', function () {
-            assert.throws(function () {
-                types.verifyFunction('[]');
-            });
+        test('unemptyString function is defined', function () {
+            assert.isFunction(check.unemptyString);
         });
 
-        test('verifyFunction with object throws', function () {
-            assert.throws(function () {
-                types.verifyFunction({});
-            });
+        test('unemptyString with unempty string returns true', function () {
+            assert.isTrue(check.unemptyString('foo'));
         });
 
-        test('verifyFunction with array throws', function () {
-            assert.throws(function () {
-                types.verifyFunction([]);
-            });
+        test('unemptyString with empty string returns false', function () {
+            assert.isFalse(check.unemptyString(''));
         });
 
-        test('isFunction function is defined', function () {
-            assert.isFunction(types.isFunction);
+        test('unemptyString with alternative unempty string returns true', function () {
+            assert.isTrue(check.unemptyString('bar'));
         });
 
-        test('isFunction with function returns true', function () {
-            assert.isTrue(types.isFunction(function () {}));
+        test('unemptyString with object returns false', function () {
+            assert.isFalse(
+                check.unemptyString({
+                    toString: function () {
+                        return 'foo';
+                    }
+                })
+            );
         });
 
-        test('isFunction with null returns false', function () {
-            assert.isFalse(types.isFunction(null));
+        test('string function is defined', function () {
+            assert.isFunction(check.string);
         });
 
-        test('isFunction with string returns false', function () {
-            assert.isFalse(types.isFunction('function () {}'));
+        test('string with empty string returns true', function () {
+            assert.isTrue(check.string(''));
         });
 
-        test('isFunction with object returns false', function () {
-            assert.isFalse(types.isFunction({}));
+        test('string with object returns false', function () {
+            assert.isFalse(
+                check.string({
+                    toString: function () {
+                        return '';
+                    }
+                })
+            );
         });
 
-        test('isFunction with array returns false', function () {
-            assert.isFalse(types.isFunction([]));
+        test('odd function is defined', function () {
+            assert.isFunction(check.odd);
         });
 
-        test('verifyUnemptyString function is defined', function () {
-            assert.isFunction(types.verifyUnemptyString);
+        test('odd with odd number returns true', function () {
+            assert.isTrue(check.odd(1));
         });
 
-        test('verifyUnemptyString with string baz does not throw', function () {
-            assert.doesNotThrow(function () {
-                types.verifyUnemptyString('baz');
-            });
+        test('odd with even number returns false', function () {
+            assert.isFalse(check.odd(2));
+        });
+
+        test('odd with negative odd number returns true', function () {
+            assert.isTrue(check.odd(-3));
+        });
+
+        test('odd with negative even number returns false', function () {
+            assert.isFalse(check.odd(-4));
+        });
+
+        test('odd with floating point number returns false', function () {
+            assert.isFalse(check.odd(5.5));
+        });
+
+        test('odd with string returns false', function () {
+            assert.isFalse(check.odd('1'));
+        });
+
+        test('even function is defined', function () {
+            assert.isFunction(check.even);
+        });
+
+        test('even with even number returns true', function () {
+            assert.isTrue(check.even(2));
+        });
+
+        test('even with odd number returns false', function () {
+            assert.isFalse(check.even(3));
+        });
+
+        test('even with negative even number returns true', function () {
+            assert.isTrue(check.even(-4));
+        });
+
+        test('even with negative odd number returns false', function () {
+            assert.isFalse(check.even(-5));
+        });
+
+        test('even with floating point number returns false', function () {
+            assert.isFalse(check.even(2.4));
+        });
+
+        test('even with string returns false', function () {
+            assert.isFalse(check.even('2'));
+        });
+
+        test('inRange function is defined', function () {
+            assert.isFunction(check.inRange);
+        });
+
+        test('inRange with 2, 0, 1 returns false', function () {
+            assert.isFalse(check.inRange(2, 0, 1));
+        });
+
+        test('inRange with 1, 0, 1 returns true', function () {
+            assert.isTrue(check.inRange(1, 0, 1));
+        });
+
+        test('inRange with 1, 1, 0 returns true', function () {
+            assert.isTrue(check.inRange(1, 1, 0));
+        });
+
+        test('inRange works with fractions', function () {
+            assert.isTrue(check.inRange(1/2, 1/4, 1/2));
+        });
+
+        test('inRange works with negative numbers', function () {
+            assert.isTrue(check.inRange(-2, -2, -1));
+        });
+
+        test('inRange with positive infinity returns false', function () {
+            assert.isFalse(check.inRange(Number.POSITIVE_INFINITY, 0, Number.POSITIVE_INFINITY));
+        });
+
+        test('inRange with negative infinity returns false', function () {
+            assert.isFalse(check.inRange(Number.NEGATIVE_INFINITY, 0, Number.NEGATIVE_INFINITY));
+        });
+
+        test('inRange with NaN returns false', function () {
+            assert.isFalse(check.inRange(NaN, Number.NEGATIVE_INFINITY, Number.POSITIVE_INFINITY));
+        });
+
+        test('inRange with string returns false', function () {
+            assert.isFalse(check.inRange('-1', 0, -2));
+        });
+
+        test('greaterOrEqual function is defined', function () {
+            assert.isFunction(check.greaterOrEqual);
+        });
+
+        test('greaterOrEqual with 0, 1 returns false', function () {
+            assert.isFalse(check.greaterOrEqual(0, 1));
+        });
+
+        test('greaterOrEqual with 1, 1 returns true', function () {
+            assert.isTrue(check.greaterOrEqual(1, 1));
+        });
+
+        test('greaterOrEqual works with fractions', function () {
+            assert.isTrue(check.greaterOrEqual(1/2, 1/2));
+        });
+
+        test('greaterOrEqual works with negative numbers', function () {
+            assert.isFalse(check.greaterOrEqual(-1, 0));
+        });
+
+        test('greaterOrEqual with positive infinity returns false', function () {
+            assert.isFalse(check.greaterOrEqual(Number.POSITIVE_INFINITY, 0));
+        });
+
+        test('greaterOrEqual with NaN returns false', function () {
+            assert.isFalse(check.greaterOrEqual(NaN, -1));
+        });
+
+        test('greaterOrEqual with string returns false', function () {
+            assert.isFalse(check.greaterOrEqual('1', 1));
+        });
+
+        test('lessOrEqual function is defined', function () {
+            assert.isFunction(check.lessOrEqual);
+        });
+
+        test('lessOrEqual with 1, 0 returns false', function () {
+            assert.isFalse(check.lessOrEqual(1, 0));
+        });
+
+        test('lessOrEqual with 1, 1 returns true', function () {
+            assert.isTrue(check.lessOrEqual(1, 1));
+        });
+
+        test('lessOrEqual works with fractions', function () {
+            assert.isFalse(check.lessOrEqual(1/2, 1/4));
+        });
+
+        test('lessOrEqual works with negative numbers', function () {
+            assert.isTrue(check.lessOrEqual(-2, -2));
+        });
+
+        test('lessOrEqual with negative infinity returns false', function () {
+            assert.isFalse(check.lessOrEqual(Number.NEGATIVE_INFINITY, 0));
+        });
+
+        test('lessOrEqual with NaN returns false', function () {
+            assert.isFalse(check.lessOrEqual(NaN, 1));
+        });
+
+        test('lessOrEqual with string returns false', function () {
+            assert.isFalse(check.lessOrEqual('-1', -1));
+        });
+
+        test('between function is defined', function () {
+            assert.isFunction(check.between);
+        });
+
+        test('between with 1, 0, 1 returns false', function () {
+            assert.isFalse(check.between(1, 0, 1));
+        });
+
+        test('between with 1, 0, 2 returns true', function () {
+            assert.isTrue(check.between(1, 0, 2));
+        });
+
+        test('between with 1, 2, 0 returns true', function () {
+            assert.isTrue(check.between(1, 2, 0));
+        });
+
+        test('between works with fractions', function () {
+            assert.isTrue(check.between(1/2, 1/4, 1));
+        });
+
+        test('between works with negative numbers', function () {
+            assert.isTrue(check.between(-2, -3, -1));
+        });
+
+        test('between with positive infinity returns false', function () {
+            assert.isFalse(check.between(Number.POSITIVE_INFINITY, 0, Number.POSITIVE_INFINITY));
+        });
+
+        test('between with negative infinity returns false', function () {
+            assert.isFalse(check.between(Number.NEGATIVE_INFINITY, 0, Number.NEGATIVE_INFINITY));
+        });
+
+        test('between with NaN returns false', function () {
+            assert.isFalse(check.between(NaN, Number.NEGATIVE_INFINITY, Number.POSITIVE_INFINITY));
+        });
+
+        test('between with string returns false', function () {
+            assert.isFalse(check.between('-1', 0, -2));
+        });
+
+        test('greater function is defined', function () {
+            assert.isFunction(check.greater);
+        });
+
+        test('greater with 0, 1 returns false', function () {
+            assert.isFalse(check.greater(0, 1));
+        });
+
+        test('greater with 2, 1 returns true', function () {
+            assert.isTrue(check.greater(2, 1));
+        });
+
+        test('greater works with fractions', function () {
+            assert.isTrue(check.greater(1/2, 1/4));
+        });
+
+        test('greater works with negative numbers', function () {
+            assert.isFalse(check.greater(-2, -1));
+        });
+
+        test('greater with positive infinity returns false', function () {
+            assert.isFalse(check.greater(Number.POSITIVE_INFINITY, 0));
+        });
+
+        test('greater with NaN returns false', function () {
+            assert.isFalse(check.greater(NaN, -1));
+        });
+
+        test('greater with string returns false', function () {
+            assert.isFalse(check.greater('1', 0));
+        });
+
+        test('less function is defined', function () {
+            assert.isFunction(check.less);
+        });
+
+        test('less with 1, 0 returns false', function () {
+            assert.isFalse(check.less(1, 0));
+        });
+
+        test('less with 1, 2 returns true', function () {
+            assert.isTrue(check.less(1, 2));
+        });
+
+        test('less works with fractions', function () {
+            assert.isFalse(check.less(1/2, 1/4));
+        });
+
+        test('less works with negative numbers', function () {
+            assert.isTrue(check.less(-2, -1));
+        });
+
+        test('less with negative infinity returns false', function () {
+            assert.isFalse(check.less(Number.NEGATIVE_INFINITY, 0));
+        });
+
+        test('less with NaN returns false', function () {
+            assert.isFalse(check.less(NaN, 1));
+        });
+
+        test('less with string returns false', function () {
+            assert.isFalse(check.less('-1', 0));
+        });
+
+        test('positive function is defined', function () {
+            assert.isFunction(check.positive);
+        });
+
+        test('positive with positive integer returns true', function () {
+            assert.isTrue(check.positive(1));
+        });
+
+        test('positive with negative integer returns false', function () {
+            assert.isFalse(check.positive(-1));
+        });
+
+        test('positive with positive fraction returns true', function () {
+            assert.isTrue(check.positive(1/2));
+        });
+
+        test('positive with negative fraction returns false', function () {
+            assert.isFalse(check.positive(-1/2));
+        });
+
+        test('positive with positive infinity returns false', function () {
+            assert.isFalse(check.positive(Number.POSITIVE_INFINITY));
+        });
+
+        test('positive with NaN returns false', function () {
+            assert.isFalse(check.positive(NaN));
+        });
+
+        test('positive with string returns false', function () {
+            assert.isFalse(check.positive('1'));
+        });
+
+        test('negative function is defined', function () {
+            assert.isFunction(check.negative);
+        });
+
+        test('negative with positive integer returns false', function () {
+            assert.isFalse(check.negative(1));
+        });
+
+        test('negative with negative integer returns true', function () {
+            assert.isTrue(check.negative(-1));
+        });
+
+        test('negative with positive fraction returns false', function () {
+            assert.isFalse(check.negative(1/2));
+        });
+
+        test('negative with negative fraction returns true', function () {
+            assert.isTrue(check.negative(-1/2));
+        });
+
+        test('negative with negative infinity returns false', function () {
+            assert.isFalse(check.negative(Number.NEGATIVE_INFINITY));
+        });
+
+        test('negative with NaN returns false', function () {
+            assert.isFalse(check.negative(NaN));
+        });
+
+        test('negative with string returns false', function () {
+            assert.isFalse(check.negative('-1'));
         });
 
-        test('verifyUnemptyString with null throws', function () {
+        test('integer function is defined', function () {
+            assert.isFunction(check.integer);
+        });
+
+        test('integer with positive integer returns true', function () {
+            assert.isTrue(check.integer(1));
+        });
+
+        test('integer with positive floating point number returns false', function () {
+            assert.isFalse(check.integer(0.1));
+        });
+
+        test('integer with negative integer returns true', function () {
+            assert.isTrue(check.integer(-2));
+        });
+
+        test('integer with negative floating point number returns false', function () {
+            assert.isFalse(check.integer(-0.2));
+        });
+
+        test('integer with infinity returns false', function () {
+            assert.isFalse(check.integer(Infinity));
+        });
+
+        test('integer with NaN returns false', function () {
+            assert.isFalse(check.integer(NaN));
+        });
+
+        test('integer with string returns false', function () {
+            assert.isFalse(check.integer('1'));
+        });
+
+        test('number function is defined', function () {
+            assert.isFunction(check.number);
+        });
+
+        test('number with positive integer returns true', function () {
+            assert.isTrue(check.number(1));
+        });
+
+        test('number with negative integer returns true', function () {
+            assert.isTrue(check.number(-1));
+        });
+
+        test('number with fraction returns true', function () {
+            assert.isTrue(check.number(1/2));
+        });
+
+        test('number with positive infinity returns false', function () {
+            assert.isFalse(check.number(Number.POSITIVE_INFINITY));
+        });
+
+        test('number with negative infinity returns false', function () {
+            assert.isFalse(check.number(Number.NEGATIVE_INFINITY));
+        });
+
+        test('number with infinity returns false', function () {
+            assert.isFalse(check.number(Number.Infinity));
+        });
+
+        test('number with NaN returns false', function () {
+            assert.isFalse(check.number(NaN));
+        });
+
+        test('number with string returns false', function () {
+            assert.isFalse(check.number('1'));
+        });
+
+        test('zero function is defined', function () {
+            assert.isFunction(check.zero);
+        });
+
+        test('zero with zero returns true', function () {
+            assert.isTrue(check.zero(0));
+        });
+
+        test('zero with positive integer returns false', function () {
+            assert.isFalse(check.zero(1));
+        });
+
+        test('zero with negative integer returns false', function () {
+            assert.isFalse(check.zero(-1));
+        });
+
+        test('zero with positive fraction returns false', function () {
+            assert.isFalse(check.zero(0.00000001));
+        });
+
+        test('zero with string returns false', function () {
+            assert.isFalse(check.zero('0'));
+        });
+
+        test('boolean function is defined', function () {
+            assert.isFunction(check.boolean);
+        });
+
+        test('boolean with true returns true', function () {
+            assert.isTrue(check.boolean(true));
+        });
+
+        test('boolean with false returns true', function () {
+            assert.isTrue(check.boolean(false));
+        });
+
+        test('boolean with one returns false', function () {
+            assert.isFalse(check.boolean(1));
+        });
+
+        test('boolean with unempty string returns false', function () {
+            assert.isFalse(check.boolean('1'));
+        });
+
+        test('apply function is defined', function () {
+            assert.isFunction(check.apply);
+        });
+
+        test('apply with non-array data throws', function () {
             assert.throws(function () {
-                types.verifyUnemptyString(null);
+                check.apply({}, []);
             });
         });
 
-        test('verifyUnemptyString with empty string throws', function () {
+        test('apply with non-array predicates throws', function () {
             assert.throws(function () {
-                types.verifyUnemptyString('');
+                check.apply([], {});
             });
         });
 
-        test('verifyUnemptyString with object throws', function () {
-            assert.throws(function () {
-                types.verifyUnemptyString({});
+        test('apply with array data and predicates does not throw', function () {
+            assert.doesNotThrow(function () {
+                check.apply([], []);
             });
         });
 
-        test('verifyUnemptyString with string qux does not throw', function () {
+        test('apply with one predicate does not throw', function () {
             assert.doesNotThrow(function () {
-                types.verifyUnemptyString('qux');
+                check.apply([ '', '', ''], check.string);
             });
         });
 
-        test('isUnemptyString function is defined', function () {
-            assert.isFunction(types.isUnemptyString);
+        test('apply with insufficient data throws', function () {
+            assert.throws(function () {
+                check.apply([ '' ], [ check.string, check.string ]);
+            });
         });
 
-        test('isUnemptyString with string foo returns true', function () {
-            assert.isTrue(types.isUnemptyString('foo'));
+        test('apply with insufficient predicates throws', function () {
+            assert.throws(function () {
+                check.apply([ '', '', '' ], [ check.string, check.string ]);
+            });
         });
 
-        test('isUnemptyString with null returns false', function () {
-            assert.isFalse(types.isUnemptyString(null));
+        test('apply returns the correct results', function () {
+            var result =
+                check.apply(
+                    [ '', 0, '', 0 ],
+                    [ check.string, check.string, check.number, check.number ]
+                );
+            assert.lengthOf(result, 4);
+            assert.isTrue(result[0]);
+            assert.isFalse(result[1]);
+            assert.isFalse(result[2]);
+            assert.isTrue(result[3]);
         });
 
-        test('isUnemptyString with empty string returns false', function () {
-            assert.isFalse(types.isUnemptyString(''));
+        test('apply with assertion does not throw with valid data', function () {
+            assert.doesNotThrow(function () {
+                check.apply([ 'foo' ], check.assert.string);
+            });
         });
 
-        test('isUnemptyString with object returns false', function () {
-            assert.isFalse(types.isUnemptyString({}));
+        test('apply with assertion throws with invalid data', function () {
+            assert.throws(function () {
+                check.apply([ 'foo', 0 ], check.assert.string);
+            });
         });
 
-        test('isUnemptyString with string bar returns true', function () {
-            assert.isTrue(types.isUnemptyString('bar'));
+        test('map function is defined', function () {
+            assert.isFunction(check.map);
         });
 
-        test('verifyString function is defined', function () {
-            assert.isFunction(types.verifyString);
+        test('map with non-object data throws', function () {
+            assert.throws(function () {
+                check.map([], {});
+            });
         });
 
-        test('verifyString with string baz does not throw', function () {
+        test('map with object data does not throw', function () {
             assert.doesNotThrow(function () {
-                types.verifyString('baz');
+                check.map({}, {});
             });
         });
 
-        test('verifyString with null throws', function () {
-            assert.throws(function () {
-                types.verifyString(null);
-            });
+        test('map returns the correct results', function () {
+            var result =
+                check.map(
+                    { foo: '', bar: 0, baz: { qux: 0 } },
+                    { foo: check.string, bar: check.string, baz: { qux: check.number } }
+                );
+            assert.lengthOf(Object.keys(result), 3);
+            assert.isTrue(result.foo);
+            assert.isFalse(result.bar);
+            assert.isObject(result.baz);
+            assert.lengthOf(Object.keys(result.baz), 1);
+            assert.isTrue(result.baz.qux);
         });
 
-        test('verifyString with empty string does not throw', function () {
+        test('map with assertion does not throw with valid data', function () {
             assert.doesNotThrow(function () {
-                types.verifyString('');
+                check.map({ foo: 'bar' }, { foo: check.assert.string });
             });
         });
 
-        test('verifyString with object throws', function () {
+        test('map with assertion throws with invalid data', function () {
             assert.throws(function () {
-                types.verifyString({});
+                check.map({ foo: 'foo', bar: 0 }, check.assert.string);
             });
         });
 
-        test('isString function is defined', function () {
-            assert.isFunction(types.isString);
+        test('map returns the correct results with maybe modifier', function () {
+            var result =
+                check.map(
+                    { foo: null, baz: { qux: '' } },
+                    { foo: check.maybe.string, bar: check.maybe.string, baz: { qux: check.maybe.string } }
+                );
+
+            assert.lengthOf(Object.keys(result), 3);
+            assert.isTrue(result.foo);
+            assert.isTrue(result.bar);
+            assert.isObject(result.baz);
+            assert.lengthOf(Object.keys(result.baz), 1);
+            assert.isTrue(result.baz.qux);
         });
 
-        test('isString with string foo returns true', function () {
-            assert.isTrue(types.isString('foo'));
+        test('map works with a single predicate', function () {
+            var result = check.map({ foo: {}, bar: { baz: 'qux' } }, check.object);
+
+            assert.lengthOf(Object.keys(result), 2);
+            assert.isTrue(result.foo);
+            assert.isTrue(result.bar);
         });
 
-        test('isString with null returns false', function () {
-            assert.isFalse(types.isString(null));
+        test('map works with undefined data and maybe', function () {
+            var result = check.map({}, { foo: { bar: check.maybe.string } });
+
+            assert.lengthOf(Object.keys(result), 1);
+            assert.isObject(result.foo);
+            assert.lengthOf(Object.keys(result.foo), 1);
+            assert.isTrue(result.foo.bar);
         });
 
-        test('isString with empty string returns true', function () {
-            assert.isTrue(types.isString(''));
+        test('map works with undefined data and undefined', function () {
+            var result = check.map({}, { foo: { bar: check.undefined } });
+
+            assert.lengthOf(Object.keys(result), 1);
+            assert.isObject(result.foo);
+            assert.lengthOf(Object.keys(result.foo), 1);
+            assert.isFalse(result.foo.bar);
         });
 
-        test('isString with object returns false', function () {
-            assert.isFalse(types.isString({}));
+        test('map works with undefined data and not.assigned', function () {
+            var result = check.map({}, { foo: { bar: check.not.assigned } });
+
+            assert.lengthOf(Object.keys(result), 1);
+            assert.isObject(result.foo);
+            assert.lengthOf(Object.keys(result.foo), 1);
+            assert.isFalse(result.foo.bar);
         });
 
-        test('verifyPositiveNumber function is defined', function () {
-            assert.isFunction(types.verifyPositiveNumber);
+        test('all function is defined', function () {
+            assert.isFunction(check.all);
         });
 
-        test('verifyPositiveNumber with positive integer does not throw', function () {
-            assert.doesNotThrow(function () {
-                types.verifyPositiveNumber(1);
+        test('all with invalid data throws', function () {
+            assert.throws(function () {
+                check.all('foo');
             });
         });
 
-        test('verifyPositiveNumber with negative integer throws', function () {
-            assert.throws(function () {
-                types.verifyPositiveNumber(-1);
+        test('all with object data does not throw', function () {
+            assert.doesNotThrow(function () {
+                check.all({ foo: true });
             });
         });
 
-        test('verifyPositiveNumber with positive fraction does not throw', function () {
+        test('all with array data does not throw', function () {
             assert.doesNotThrow(function () {
-                types.verifyPositiveNumber(1/2);
+                check.all([ true ]);
             });
         });
 
-        test('verifyPositiveNumber with negative fraction throws', function () {
+        test('all returns true when data is all true', function () {
+            assert.isTrue(check.all({ foo: true, bar: true, baz: true, qux: true }));
+            assert.isTrue(check.all([ true, true, true, true ]));
+            assert.isTrue(check.all({ foo: { bar: { baz: { qux: true }}}}));
+        });
+
+        test('all returns false when some data is not true', function () {
+            assert.isFalse(check.all({ foo: true, bar: true, baz: true, qux: false }));
+            assert.isFalse(check.all([ true, true, false, true ]));
+            assert.isFalse(check.all({ foo: { bar: { baz: false }, qux: true } }));
+        });
+
+        test('any function is defined', function () {
+            assert.isFunction(check.any);
+        });
+
+        test('any with invalid data throws', function () {
             assert.throws(function () {
-                types.verifyPositiveNumber(-1/2);
+                check.any('foo');
             });
         });
 
-        test('verifyPositiveNumber with positive infinity does not throw', function () {
+        test('any with object data does not throw', function () {
             assert.doesNotThrow(function () {
-                types.verifyPositiveNumber(Infinity);
+                check.any({ foo: true });
             });
         });
 
-        test('verifyPositiveNumber with negative infinity throws', function () {
-            assert.throws(function () {
-                types.verifyPositiveNumber(-Infinity);
+        test('any with array data does not throw', function () {
+            assert.doesNotThrow(function () {
+                check.any([ true ]);
             });
         });
 
-        test('verifyPositiveNumber with NaN throws', function () {
+        test('any returns true when some data is true', function () {
+            assert.isTrue(check.any({ foo: false, bar: true }));
+            assert.isTrue(check.any([ false, true ]));
+            assert.isTrue(check.any({ foo: { bar: true }}));
+        });
+
+        test('any returns false when all data is not true', function () {
+            assert.isFalse(check.any({ foo: false, bar: false }));
+            assert.isFalse(check.any([ false, false ]));
+            assert.isFalse(check.any({ foo: { bar: false }}));
+        });
+
+        test('assert modifier is defined', function () {
+            assert.isFunction(check.assert);
+        });
+
+        test('assert modifier is applied to predicates', function () {
+            assert.isFunction(check.assert.like);
+            assert.isFunction(check.assert.instance);
+            assert.isFunction(check.assert.emptyObject);
+            assert.isFunction(check.assert.object);
+            assert.isFunction(check.assert.null);
+            assert.isFunction(check.assert.undefined);
+            assert.isFunction(check.assert.assigned);
+            assert.isFunction(check.assert.hasLength);
+            assert.isFunction(check.assert.emptyArray);
+            assert.isFunction(check.assert.array);
+            assert.isFunction(check.assert.arrayLike);
+            assert.isFunction(check.assert.iterable);
+            assert.isFunction(check.assert.date);
+            assert.isFunction(check.assert.error);
+            assert.isFunction(check.assert.function);
+            assert.isFunction(check.assert.match);
+            assert.isFunction(check.assert.contains);
+            assert.isFunction(check.assert.unemptyString);
+            assert.isFunction(check.assert.string);
+            assert.isFunction(check.assert.odd);
+            assert.isFunction(check.assert.even);
+            assert.isFunction(check.assert.between);
+            assert.isFunction(check.assert.greater);
+            assert.isFunction(check.assert.less);
+            assert.isFunction(check.assert.positive);
+            assert.isFunction(check.assert.negative);
+            assert.isFunction(check.assert.zero);
+            assert.isFunction(check.assert.integer);
+            assert.isFunction(check.assert.number);
+            assert.isFunction(check.assert.boolean);
+        });
+
+        test('assert modifier is not applied to batch operations', function () {
+            assert.isUndefined(check.assert.map);
+            assert.strictEqual(check.assert.apply, Function.apply);
+            assert.isUndefined(check.assert.all);
+            assert.isUndefined(check.assert.any);
+        });
+
+        test('assert modifier is not applied to itself', function () {
+            assert.isUndefined(check.assert.assert);
+        });
+
+        test('assert modifier is applied to not', function () {
+            assert.isObject(check.assert.not);
+            assert.lengthOf(Object.keys(check.assert.not), 33);
+        });
+
+        test('assert modifier is applied to maybe', function () {
+            assert.isObject(check.assert.maybe);
+            assert.lengthOf(Object.keys(check.assert.maybe), 33);
+        });
+
+        test('assert modifier is applied to either', function () {
+            assert.isObject(check.assert.either);
+            assert.lengthOf(Object.keys(check.assert.either), 33);
+        });
+
+        test('assert modifier has correct number of keys', function () {
+            assert.lengthOf(Object.keys(check.assert), 36);
+        });
+
+        test('assert modifier throws when value is wrong', function () {
             assert.throws(function () {
-                types.verifyPositiveNumber(NaN);
+                check.assert.unemptyString('');
             });
         });
 
-        test('verifyPositiveNumber with object throws', function () {
+        test('assert modifier does not throw when value is correct', function () {
+            assert.doesNotThrow(function () {
+                check.assert.unemptyString(' ');
+            });
+        });
+
+        test('assert modifier throws Error instance', function () {
+            try {
+                check.assert.unemptyString('');
+            } catch (error) {
+                assert.instanceOf(error, Error);
+            }
+        });
+
+        test('assert modifier sets default message on Error instance', function () {
+            try {
+                check.assert.unemptyString('');
+            } catch (error) {
+                assert.strictEqual(error.message, 'Invalid string');
+            }
+        });
+
+        test('assert modifer sets message on Error instance', function () {
+            try {
+                check.assert.unemptyString('', 'foo bar');
+            } catch (error) {
+                assert.strictEqual(error.message, 'foo bar');
+            }
+        });
+
+        test('assert modifier prohibits empty error messages', function () {
+            try {
+                check.assert.unemptyString('', '');
+            } catch (error) {
+                assert.strictEqual(error.message, 'Invalid string');
+            }
+        });
+
+        test('assert throws errors with the correct messages', function () {
+            assert.throws(function () { check.assert.like({a: 5}, {b: 2}) }, 'Invalid type');
+            assert.throws(function () { check.assert.instance() }, 'Invalid type');
+            assert.throws(function () { check.assert.emptyObject() }, 'Invalid object');
+            assert.throws(function () { check.assert.object() }, 'Invalid object');
+            assert.throws(function () { check.assert.assigned() }, 'Invalid value');
+            assert.throws(function () { check.assert.undefined(5) }, 'Invalid value');
+            assert.throws(function () { check.assert.null() }, 'Invalid value');
+            assert.throws(function () { check.assert.hasLength() }, 'Invalid length');
+            assert.throws(function () { check.assert.emptyArray() }, 'Invalid array');
+            assert.throws(function () { check.assert.array() }, 'Invalid array');
+            assert.throws(function () { check.assert.arrayLike() }, 'Invalid array-like object');
+            assert.throws(function () { check.assert.iterable() }, 'Invalid iterable');
+            assert.throws(function () { check.assert.date() }, 'Invalid date');
+            assert.throws(function () { check.assert.error() }, 'Invalid error');
+            assert.throws(function () { check.assert.function() }, 'Invalid function');
+            assert.throws(function () { check.assert.match() }, 'Invalid string');
+            assert.throws(function () { check.assert.contains() }, 'Invalid string');
+            assert.throws(function () { check.assert.unemptyString() }, 'Invalid string');
+            assert.throws(function () { check.assert.string() }, 'Invalid string');
+            assert.throws(function () { check.assert.odd() }, 'Invalid number');
+            assert.throws(function () { check.assert.even() }, 'Invalid number');
+            assert.throws(function () { check.assert.inRange() }, 'Invalid number');
+            assert.throws(function () { check.assert.greaterOrEqual() }, 'Invalid number');
+            assert.throws(function () { check.assert.lessOrEqual() }, 'Invalid number');
+            assert.throws(function () { check.assert.between() }, 'Invalid number');
+            assert.throws(function () { check.assert.greater() }, 'Invalid number');
+            assert.throws(function () { check.assert.less() }, 'Invalid number');
+            assert.throws(function () { check.assert.positive() }, 'Invalid number');
+            assert.throws(function () { check.assert.negative() }, 'Invalid number');
+            assert.throws(function () { check.assert.integer() }, 'Invalid number');
+            assert.throws(function () { check.assert.zero() }, 'Invalid number');
+            assert.throws(function () { check.assert.number() }, 'Invalid number');
+            assert.throws(function () { check.assert.boolean() }, 'Invalid boolean');
+        });
+
+
+        test('assert modifier runs standalone', function () {
+            assert.doesNotThrow(function () {
+                check.assert(true);
+            });
+
             assert.throws(function () {
-                types.verifyPositiveNumber({});
+                check.assert(false);
             });
         });
 
-        test('verifyPositiveNumber with string throws', function () {
+        test('assert modifier throws for multi-argument predicates', function () {
             assert.throws(function () {
-                types.verifyPositiveNumber('1');
+                check.assert.between(1, 2, 1);
+            });
+        });
+
+        test('assert modifier does not throw for multi-argument predicates', function () {
+            assert.doesNotThrow(function () {
+                check.assert.between(1, 2, 0);
             });
         });
 
-        test('isPositiveNumber function is defined', function () {
-            assert.isFunction(types.isPositiveNumber);
+        test('not modifier is defined', function () {
+            assert.isFunction(check.not);
+        });
+
+        test('not modifier is not applied to itself', function () {
+            assert.isUndefined(check.not.not);
+        });
+
+        test('not modifier is not applied to maybe', function () {
+            assert.isUndefined(check.not.maybe);
+        });
+
+        test('not modifier is not applied to either', function () {
+            assert.isUndefined(check.not.either);
+        });
+
+        test('not modifier is not applied to assert', function () {
+            assert.isUndefined(check.not.assert);
+        });
+
+        test('not modifier has correct number of keys', function () {
+            assert.lengthOf(Object.keys(check.not), 33);
         });
 
-        test('isPositiveNumber with positive integer returns true', function () {
-            assert.isTrue(types.isPositiveNumber(1));
+        test('not modifier returns true when predicate returns false', function () {
+            assert.isTrue(check.not.object(undefined));
         });
 
-        test('isPositiveNumber with negative integer returns false', function () {
-            assert.isFalse(types.isPositiveNumber(-1));
+        test('not modifier returns false when predicate returns true', function () {
+            assert.isFalse(check.not.unemptyString('1'));
         });
 
-        test('isPositiveNumber with positive fraction returns true', function () {
-            assert.isTrue(types.isPositiveNumber(1/2));
+        test('not modifier runs standalone', function () {
+            assert.isFalse(check.not(true));
+            assert.isTrue(check.not(false));
         });
 
-        test('isPositiveNumber with negative fraction returns false', function () {
-            assert.isFalse(types.isPositiveNumber(-1/2));
+        test('not modifier returns true for multi-argument predicates', function () {
+            assert.isTrue(check.not.between(1, 2, 1));
         });
 
-        test('isPositiveNumber with positive infinity returns true', function () {
-            assert.isTrue(types.isPositiveNumber(Infinity));
+        test('not modifier returns false for multi-argument predicates', function () {
+            assert.isFalse(check.not.between(1, 2, 0));
         });
 
-        test('isPositiveNumber with negative infinity returns false', function () {
-            assert.isFalse(types.isPositiveNumber(-Infinity));
+        test('maybe modifier is defined', function () {
+            assert.isFunction(check.maybe);
         });
 
-        test('isPositiveNumber with NaN returns false', function () {
-            assert.isFalse(types.isPositiveNumber(NaN));
+        test('maybe modifier is not applied to itself', function () {
+            assert.isUndefined(check.maybe.maybe);
         });
 
-        test('isPositiveNumber with object returns false', function () {
-            assert.isFalse(types.isPositiveNumber({}));
+        test('maybe modifier is not applied to not', function () {
+            assert.isUndefined(check.maybe.not);
         });
 
-        test('isPositiveNumber with string returns false', function () {
-            assert.isFalse(types.isPositiveNumber('1'));
+        test('maybe modifier is not applied to either', function () {
+            assert.isUndefined(check.maybe.either);
         });
 
-        test('verifyNegativeNumber function is defined', function () {
-            assert.isFunction(types.verifyNegativeNumber);
+        test('maybe modifier is not applied to assert', function () {
+            assert.isUndefined(check.maybe.assert);
         });
 
-        test('verifyNegativeNumber with positive integer throws', function () {
+        test('maybe modifier has correct number of keys', function () {
+            assert.lengthOf(Object.keys(check.maybe), 33);
+        });
+
+        test('maybe modifier returns true when value is undefined', function () {
+            assert.isTrue(check.maybe.object(undefined));
+        });
+
+        test('maybe modifier returns true when value is null', function () {
+            assert.isTrue(check.maybe.object(null));
+        });
+
+        test('maybe modifier returns predicate result on value', function () {
+            assert.isFalse(check.maybe.odd(2));
+            assert.isTrue(check.maybe.odd(1));
+        });
+
+        test('maybe modifier with falsey values evaluates predicate', function () {
+            assert.isFalse(check.maybe.positive(0));
+        });
+
+        test('maybe modifier runs standalone', function () {
+            assert.isTrue(check.maybe(null));
+            assert.isTrue(check.maybe(undefined));
+            assert.isFalse(check.maybe(false));
+        });
+
+        test('maybe modifier shortcuts for multi-argument predicates', function () {
+            assert.isTrue(check.maybe.instance(null, Error));
+        });
+
+        test('either modifier is defined', function () {
+            assert.isObject(check.either);
+        });
+
+        test('either modifier is not applied to itself', function () {
+            assert.isUndefined(check.either.either);
+        });
+
+        test('either modifier is not applied to not', function () {
+            assert.isUndefined(check.either.not);
+        });
+
+        test('either modifier is not applied to maybe', function () {
+            assert.isUndefined(check.either.maybe);
+        });
+
+        test('either modifier is not applied to assert', function () {
+            assert.isUndefined(check.either.assert);
+        });
+
+        test('either modifier has correct number of keys', function () {
+            assert.lengthOf(Object.keys(check.either), 33);
+        });
+
+        test('either modifier returns or object', function () {
+            assert.isObject(check.either.string(''));
+            assert.isObject(check.either.string('').or);
+            assert.lengthOf(Object.keys(check.either.string('').or), 33);
+        });
+
+        test('either returns true when first predicate is true', function () {
+            assert.isTrue(check.either.odd(1).or.even(2));
+            assert.isTrue(check.either.odd(1).or.even(3));
+        });
+
+        test('either returns second predicate result when first predicate is false', function () {
+            assert.isTrue(check.either.odd(2).or.even(4));
+            assert.isFalse(check.either.odd(2).or.even(5));
+        });
+
+        test('either works for multi-argument predicates', function () {
+            assert.isTrue(check.either.between(1, 2, 0).or.between(1, 2, 1));
+            assert.isTrue(check.either.between(1, 2, 1).or.between(1, 2, 0));
+            assert.isFalse(check.either.between(1, 2, 1).or.between(1, 2, 1));
+        });
+
+        test('assert modifier with not throws when value is correct', function () {
             assert.throws(function () {
-                types.verifyNegativeNumber(1);
+                check.assert.not.between(1, 2, 0);
             });
         });
 
-        test('verifyNegativeNumber with negative integer does not throw', function () {
+        test('assert modifier with not does not throw when value is wrong', function () {
             assert.doesNotThrow(function () {
-                types.verifyNegativeNumber(-1);
+                check.assert.not.between(1, 2, 1);
             });
         });
 
-        test('verifyNegativeNumber with positive fraction throws', function () {
-            assert.throws(function () {
-                types.verifyNegativeNumber(1/2);
+        test('assert modifier with maybe does not throw when value is correct', function () {
+            assert.doesNotThrow(function () {
+                check.assert.maybe.between(1, 2, 0);
             });
         });
 
-        test('verifyNegativeNumber with negative fraction does not throw', function () {
+        test('assert modifier with maybe does not throw when value is null', function () {
             assert.doesNotThrow(function () {
-                types.verifyNegativeNumber(-1/2);
+                check.assert.maybe.between(null, 2, 1);
             });
         });
 
-        test('verifyNegativeNumber with positive infinity throws', function () {
+        test('assert modifier with maybe throws when value is wrong', function () {
             assert.throws(function () {
-                types.verifyNegativeNumber(Infinity);
+                check.assert.maybe.between(1, 2, 1);
             });
         });
 
-        test('verifyNegativeNumber with negative infinity does not throw', function () {
+        test('assert modifier with either does not throw when second value is correct', function () {
             assert.doesNotThrow(function () {
-                types.verifyNegativeNumber(-Infinity);
+                check.assert.either.between(1, 2, 1).or.between(1, 2, 0);
             });
         });
 
-        test('verifyNegativeNumber with NaN throws', function () {
-            assert.throws(function () {
-                types.verifyNegativeNumber(NaN);
+        test('assert modifier with either does not throw when first value is correct', function () {
+            assert.doesNotThrow(function () {
+                check.assert.either.between(1, 2, 0).or.between(1, 2, 1);
             });
         });
 
-        test('verifyNegativeNumber with object throws', function () {
+        test('assert modifier with either throws when both values are wrong', function () {
             assert.throws(function () {
-                types.verifyNegativeNumber({});
+                check.assert.either.between(1, 2, 1).or.between(1, 2, 1);
             });
         });
 
-        test('verifyNegativeNumber with string throws', function () {
-            assert.throws(function () {
-                types.verifyNegativeNumber('-1');
-            });
+        test('array.of modifier is defined', function () {
+            assert.isObject(check.array.of);
         });
 
-        test('isNegativeNumber function is defined', function () {
-            assert.isFunction(types.isNegativeNumber);
+        test('array.of has predicates defined', function () {
+            assert.lengthOf(Object.keys(check.array.of), 33);
+            assert.isFunction(check.array.of.like);
+            assert.isFunction(check.array.of.instance);
+            assert.isFunction(check.array.of.emptyObject);
+            assert.isFunction(check.array.of.object);
+            assert.isFunction(check.array.of.null);
+            assert.isFunction(check.array.of.undefined);
+            assert.isFunction(check.array.of.assigned);
+            assert.isFunction(check.array.of.hasLength);
+            assert.isFunction(check.array.of.emptyArray);
+            assert.isFunction(check.array.of.array);
+            assert.isFunction(check.array.of.arrayLike);
+            assert.isFunction(check.array.of.iterable);
+            assert.isFunction(check.array.of.date);
+            assert.isFunction(check.array.of.error);
+            assert.isFunction(check.array.of.function);
+            assert.isFunction(check.array.of.match);
+            assert.isFunction(check.array.of.contains);
+            assert.isFunction(check.array.of.unemptyString);
+            assert.isFunction(check.array.of.string);
+            assert.isFunction(check.array.of.odd);
+            assert.isFunction(check.array.of.even);
+            assert.isFunction(check.array.of.inRange);
+            assert.isFunction(check.array.of.greaterOrEqual);
+            assert.isFunction(check.array.of.lessOrEqual);
+            assert.isFunction(check.array.of.between);
+            assert.isFunction(check.array.of.greater);
+            assert.isFunction(check.array.of.less);
+            assert.isFunction(check.array.of.positive);
+            assert.isFunction(check.array.of.negative);
+            assert.isFunction(check.array.of.zero);
+            assert.isFunction(check.array.of.integer);
+            assert.isFunction(check.array.of.number);
+            assert.isFunction(check.array.of.boolean);
         });
 
-        test('isNegativeNumber with positive integer returns false', function () {
-            assert.isFalse(types.isNegativeNumber(1));
+        test('array.of returns true when predicate is true for all items', function () {
+            assert.isTrue(check.array.of.unemptyString([ 'foo', 'bar', 'baz' ]));
         });
 
-        test('isNegativeNumber with negative integer returns true', function () {
-            assert.isTrue(types.isNegativeNumber(-1));
+        test('array.of returns false when predicate is false for one item', function () {
+            assert.isFalse(check.array.of.positive([ 1, 0, 2 ]));
         });
 
-        test('isNegativeNumber with positive fraction returns false', function () {
-            assert.isFalse(types.isNegativeNumber(1/2));
+        test('array.of returns true for multi-argument predicates', function () {
+            assert.isTrue(check.array.of.between([ 1, 0, -1 ], 2, -2));
         });
 
-        test('isNegativeNumber with negative fraction returns true', function () {
-            assert.isTrue(types.isNegativeNumber(-1/2));
+        test('array.of returns false for multi-argument predicates', function () {
+            assert.isFalse(check.array.of.greater([ 1, 2, 3 ], 4));
         });
 
-        test('isNegativeNumber with positive infinity returns false', function () {
-            assert.isFalse(types.isNegativeNumber(Infinity));
+        test('assert.array.of does not throw', function () {
+            assert.doesNotThrow(function () {
+                check.assert.array.of.instance([ new Error(), new Error() ], Error);
+            });
         });
 
-        test('isNegativeNumber with negative infinity returns true', function () {
-            assert.isTrue(types.isNegativeNumber(-Infinity));
+        test('assert.array.of throws', function () {
+            assert.throws(function () {
+                check.assert.array.of.instance([ new Error(), {} ], Error);
+            });
         });
 
-        test('isNegativeNumber with NaN returns false', function () {
-            assert.isFalse(types.isNegativeNumber(NaN));
+        test('maybe.array.of returns true', function () {
+            assert.isTrue(check.maybe.array.of.instance([ new Error(), null ], Error));
         });
 
-        test('isNegativeNumber with object returns false', function () {
-            assert.isFalse(types.isNegativeNumber({}));
+        test('maybe.array.of returns false', function () {
+            assert.isFalse(check.maybe.array.of.instance([ new Error(), {} ], Error));
         });
 
-        test('isNegativeNumber with string returns false', function () {
-            assert.isFalse(types.isNegativeNumber('1'));
+        test('not.array.of returns true', function () {
+            assert.isTrue(check.not.array.of.instance([ new Error(), null ], Error));
         });
 
-        test('verifyNumber function is defined', function () {
-            assert.isFunction(types.verifyNumber);
+        test('not.array.of returns false', function () {
+            assert.isFalse(check.not.array.of.instance([ new Error() ], Error));
         });
 
-        test('verifyNumber with positive integer does not throw', function () {
+        test('assert.maybe.array.of does not throw', function () {
             assert.doesNotThrow(function () {
-                types.verifyNumber(1);
+                check.assert.maybe.array.of.instance([ new Error(), null ], Error);
             });
         });
 
-        test('verifyNumber with negative integer does not throw', function () {
-            assert.doesNotThrow(function () {
-                types.verifyNumber(-1);
+        test('assert.maybe.array.of throws', function () {
+            assert.throws(function () {
+                check.assert.maybe.array.of.instance([ new Error(), {} ], Error);
             });
         });
 
-        test('verifyNumber with fraction does not throw', function () {
+        test('assert.not.array.of does not throw', function () {
             assert.doesNotThrow(function () {
-                types.verifyNumber(1/2);
+                check.assert.not.array.of.instance([ {} ], Error);
             });
         });
 
-        test('verifyNumber with positive infinity does not throw', function () {
-            assert.doesNotThrow(function () {
-                types.verifyNumber(Infinity);
+        test('assert.not.array.of throws', function () {
+            assert.throws(function () {
+                check.assert.not.array.of.instance([ new Error(), new Error() ], Error);
             });
         });
 
-        test('verifyNumber with negative infinity does not throw', function () {
-            assert.doesNotThrow(function () {
-                types.verifyNumber(-Infinity);
-            });
+        test('array.of returns false for array-like objects', function () {
+            assert.isFalse(check.array.of.unemptyString({ 1: 'foo', 2: 'bar', length: 2 }));
         });
 
-        test('verifyNumber with NaN throws', function () {
-            assert.throws(function () {
-                types.verifyNumber(NaN);
+        if (typeof Symbol !== 'undefined') {
+            test('array.of returns false for iterables', function () {
+                assert.isFalse(check.array.of.unemptyString(new Set([ 'foo', 'bar' ])));
             });
+        }
+
+        test('array.of returns false for objects', function () {
+            assert.isFalse(check.array.of.unemptyString({ 'foo': 'bar', 'baz': 'qux' }));
         });
 
-        test('verifyNumber with object throws', function () {
-            assert.throws(function () {
-                types.verifyNumber({});
+        test('arrayLike.of modifier is defined', function () {
+            assert.isObject(check.arrayLike.of);
+        });
+
+        test('arrayLike.of has predicates defined', function () {
+            assert.lengthOf(Object.keys(check.arrayLike.of), 33);
+        });
+
+        test('arrayLike.of returns true when predicate is true for all items', function () {
+            assert.isTrue(check.arrayLike.of.unemptyString({ 0: 'foo', 1: 'bar', length: 2 }));
+        });
+
+        test('arrayLike.of returns false when predicate is false for one item', function () {
+            assert.isFalse(check.arrayLike.of.unemptyString({ 0: 'foo', 1: '', length: 2 }));
+        });
+
+        test('arrayLike.of returns true for multi-argument predicates', function () {
+            assert.isTrue(check.arrayLike.of.between({ 0: 1, 1: 0, length: 2 }, 2, -1));
+        });
+
+        test('arrayLike.of returns false for multi-argument predicates', function () {
+            assert.isFalse(check.arrayLike.of.greater({ 0: 1, 1: 2, length: 2 }, 2));
+        });
+
+        test('assert.arrayLike.of does not throw', function () {
+            assert.doesNotThrow(function () {
+                check.assert.arrayLike.of.instance({ 0: new Error(), 1: new Error(), length: 2 }, Error);
             });
         });
 
-        test('verifyNumber with string throws', function () {
+        test('assert.arrayLike.of throws', function () {
             assert.throws(function () {
-                types.verifyNumber('1');
+                check.assert.arrayLike.of.instance({ 0: new Error(), 1: {}, length: 2 }, Error);
             });
         });
 
-        test('isNumber function is defined', function () {
-            assert.isFunction(types.isNumber);
+        test('maybe.arrayLike.of returns true', function () {
+            assert.isTrue(check.maybe.arrayLike.of.instance({ 0: new Error(), 1: null, length: 2 }, Error));
         });
 
-        test('isNumber with positive integer returns true', function () {
-            assert.isTrue(types.isNumber(1));
+        test('maybe.arrayLike.of returns false', function () {
+            assert.isFalse(check.maybe.arrayLike.of.instance({ 0: new Error(), 1: {}, length: 2 }, Error));
         });
 
-        test('isNumber with negative integer returns true', function () {
-            assert.isTrue(types.isNumber(-1));
+        test('not.arrayLike.of returns true', function () {
+            assert.isTrue(check.not.arrayLike.of.instance({ 0: new Error(), 1: null, length: 2 }, Error));
         });
 
-        test('isNumber with fraction returns true', function () {
-            assert.isTrue(types.isNumber(1/2));
+        test('not.arrayLike.of returns false', function () {
+            assert.isFalse(check.not.arrayLike.of.instance({ 0: new Error(), length: 1 }, Error));
         });
 
-        test('isNumber with Infinity returns true', function () {
-            assert.isTrue(types.isNumber(Infinity));
+        test('assert.maybe.arrayLike.of does not throw', function () {
+            assert.doesNotThrow(function () {
+                check.assert.maybe.arrayLike.of.instance({ 0: new Error(), 1: null, length: 2 }, Error);
+            });
         });
 
-        test('isNumber with NaN returns false', function () {
-            assert.isFalse(types.isNumber(NaN));
+        test('assert.maybe.arrayLike.of throws', function () {
+            assert.throws(function () {
+                check.assert.maybe.arrayLike.of.instance({ 0: new Error(), 1: {}, length: 2 }, Error);
+            });
         });
 
-        test('isNumber with object returns false', function () {
-            assert.isFalse(types.isNumber({}));
+        test('assert.not.arrayLike.of does not throw', function () {
+            assert.doesNotThrow(function () {
+                check.assert.not.arrayLike.of.instance({ 0: {}, length: 1 }, Error);
+            });
         });
 
-        test('isNumber with string returns false', function () {
-            assert.isFalse(types.isNumber('1'));
+        test('assert.not.arrayLike.of throws', function () {
+            assert.throws(function () {
+                check.assert.not.arrayLike.of.instance({ 0: new Error(), 1: new Error(), length: 2 }, Error);
+            });
         });
 
-        test('isOddNumber with string returns false', function () {
-            assert.isFalse(types.isOddNumber('1'));
+        test('arrayLike.of returns true for arrays', function () {
+            assert.isTrue(check.arrayLike.of.unemptyString([ 'foo', 'bar' ]));
         });
 
-        test('isOddNumber with odd number returns true', function () {
-            assert.isTrue(types.isOddNumber(1));
+        if (typeof Symbol !== 'undefined') {
+            test('arrayLike.of returns false for iterables', function () {
+                assert.isFalse(check.arrayLike.of.unemptyString(new Set([ 'foo', 'bar' ])));
+            });
+        }
+
+        test('arrayLike.of returns false for objects', function () {
+            assert.isFalse(check.arrayLike.of.unemptyString({ 'foo': 'bar', 'baz': 'qux' }));
         });
 
-        test('isOddNumber with even number returns false', function () {
-            assert.isFalse(types.isOddNumber(2));
+        test('iterable.of modifier is defined', function () {
+            assert.isObject(check.iterable.of);
         });
 
-        test('isOddNumber with alternative odd number returns true', function () {
-            assert.isTrue(types.isOddNumber(3));
+        test('iterable.of has predicates defined', function () {
+            assert.lengthOf(Object.keys(check.iterable.of), 33);
         });
 
-        test('isOddNumber with negative odd number returns true', function () {
-            assert.isTrue(types.isOddNumber(-5));
+        if (typeof Symbol !== 'undefined') {
+            test('iterable.of returns true when predicate is true for all items', function () {
+                assert.isTrue(check.iterable.of.unemptyString(new Set([ 'foo', 'bar' ])));
+            });
+
+            test('iterable.of returns false when predicate is false for one item', function () {
+                assert.isFalse(check.iterable.of.unemptyString(new Set([ 'foo', '' ])));
+            });
+
+            test('iterable.of returns true for multi-argument predicates', function () {
+                assert.isTrue(check.iterable.of.between(new Map([['foo', 1], ['bar', 0]]), 2, -1));
+            });
+
+            test('iterable.of returns false for multi-argument predicates', function () {
+                assert.isFalse(check.iterable.of.less(new Map([['foo', 1], ['bar', 2]]), 2));
+            });
+
+            test('assert.iterable.of does not throw', function () {
+                assert.doesNotThrow(function () {
+                    check.assert.iterable.of.instance(new Set([ new Error(), new Error() ]), Error);
+                });
+            });
+
+            test('assert.iterable.of throws', function () {
+                assert.throws(function () {
+                    check.assert.iterable.of.instance(new Set([ new Error(), {} ]), Error);
+                });
+            });
+
+            test('maybe.iterable.of returns true', function () {
+                assert.isTrue(check.maybe.iterable.of.instance(new Set([ new Error(), null ]), Error));
+            });
+
+            test('maybe.iterable.of returns false', function () {
+                assert.isFalse(check.maybe.iterable.of.instance(new Set([ new Error(), {} ]), Error));
+            });
+
+            test('not.iterable.of returns true', function () {
+                assert.isTrue(check.not.iterable.of.instance(new Set([ new Error(), null ]), Error));
+            });
+
+            test('not.iterable.of returns false', function () {
+                assert.isFalse(check.not.iterable.of.instance(new Set([ new Error() ]), Error));
+            });
+
+            test('assert.maybe.iterable.of does not throw', function () {
+                assert.doesNotThrow(function () {
+                    check.assert.maybe.iterable.of.instance(new Set([ new Error(), null ]), Error);
+                });
+            });
+
+            test('assert.maybe.iterable.of throws', function () {
+                assert.throws(function () {
+                    check.assert.maybe.iterable.of.instance(new Set([ new Error(), {} ]), Error);
+                });
+            });
+
+            test('assert.not.iterable.of does not throw', function () {
+                assert.doesNotThrow(function () {
+                    check.assert.not.iterable.of.instance(new Set([ new Error(), {} ]), Error);
+                });
+            });
+
+            test('assert.not.iterable.of throws', function () {
+                assert.throws(function () {
+                    check.assert.not.iterable.of.instance(new Set([ new Error(), new Error() ]), Error);
+                });
+            });
+
+            test('iterable.of returns true for arrays', function () {
+                assert.isTrue(check.iterable.of.unemptyString([ 'foo', 'bar' ]));
+            });
+
+            test('iterable.of returns false for array-like objects', function () {
+                assert.isFalse(check.iterable.of.unemptyString({ 0: 'foo', 1: 'bar', length: 2 }));
+            });
+
+            test('iterable.of returns false for objects', function () {
+                assert.isFalse(check.iterable.of.unemptyString({ 'foo': 'bar', 'baz': 'qux' }));
+            });
+        }
+
+        test('object.of modifier is defined', function () {
+            assert.isObject(check.object.of);
+        });
+
+        test('object.of has predicates defined', function () {
+            assert.lengthOf(Object.keys(check.object.of), 33);
         });
 
-        test('isOddNumber with negative even number returns false', function () {
-            assert.isFalse(types.isOddNumber(-4));
+        test('object.of returns true when predicate is true for all items', function () {
+            assert.isTrue(check.object.of.unemptyString({ 'foo': 'bar', 'baz': 'qux' }));
         });
 
-        test('isOddNumber with floating point number returns false', function () {
-            assert.isFalse(types.isEvenNumber(3.5));
+        test('object.of returns false when predicate is false for one item', function () {
+            assert.isFalse(check.object.of.unemptyString({ 'foo': 'bar', 'baz': '' }));
         });
 
-        test('verifyOddNumber with odd number does not throw', function () {
+        test('object.of returns true for multi-argument predicates', function () {
+            assert.isTrue(check.object.of.between({ 'foo': 1, 'bar': 0 }, 2, -1));
+        });
+
+        test('object.of returns false for multi-argument predicates', function () {
+            assert.isFalse(check.object.of.greater({ 'foo': 1, 'bar': 2 }, 2));
+        });
+
+        test('assert.object.of does not throw', function () {
             assert.doesNotThrow(function () {
-                types.verifyOddNumber(-7);
+                check.assert.object.of.instance({ 'foo': new Error(), 'bar': new Error() }, Error);
             });
         });
 
-        test('verifyOddNumber with even number throws', function () {
+        test('assert.object.of throws', function () {
             assert.throws(function () {
-                types.verifyOddNumber(8);
+                check.assert.object.of.instance({ 'foo': new Error(), 'bar': {} }, Error);
             });
         });
 
-        test('isEvenNumber with string returns false', function () {
-            assert.isFalse(types.isEvenNumber('2'));
+        test('maybe.object.of returns true', function () {
+            assert.isTrue(check.maybe.object.of.instance({ 'foo': new Error(), 'bar': null }, Error));
         });
 
-        test('isEvenNumber with odd number returns false', function () {
-            assert.isFalse(types.isEvenNumber(1));
+        test('maybe.object.of returns false', function () {
+            assert.isFalse(check.maybe.object.of.instance({ 'foo': new Error(), 'bar': {} }, Error));
         });
 
-        test('isEvenNumber with even number returns true', function () {
-            assert.isTrue(types.isEvenNumber(2));
+        test('not.object.of returns true', function () {
+            assert.isTrue(check.not.object.of.instance({ 'foo': new Error(), 'bar': null }, Error));
         });
 
-        test('isEvenNumber with alternative even number returns true', function () {
-            assert.isTrue(types.isEvenNumber(4));
+        test('not.object.of returns false', function () {
+            assert.isFalse(check.not.object.of.instance({ 'foo': new Error() }, Error));
         });
 
-        test('isEvenNumber with negative odd number returns false', function () {
-            assert.isFalse(types.isEvenNumber(-5));
+        test('assert.maybe.object.of does not throw', function () {
+            assert.doesNotThrow(function () {
+                check.assert.maybe.object.of.instance({ 'foo': new Error(), 'bar': null }, Error);
+            });
         });
 
-        test('isEvenNumber with negative even number returns true', function () {
-            assert.isTrue(types.isEvenNumber(-6));
+        test('assert.maybe.object.of throws', function () {
+            assert.throws(function () {
+                check.assert.maybe.object.of.instance({ 'foo': new Error(), 'bar': {} }, Error);
+            });
         });
 
-        test('isEvenNumber with floating point number returns false', function () {
-            assert.isFalse(types.isEvenNumber(2.4));
+        test('assert.not.object.of does not throw', function () {
+            assert.doesNotThrow(function () {
+                check.assert.not.object.of.instance({ 'foo': {} }, Error);
+            });
         });
 
-        test('verifyEvenNumber with odd number throws', function () {
+        test('assert.not.object.of throws', function () {
             assert.throws(function () {
-                types.verifyEvenNumber(7);
+                check.assert.not.object.of.instance({ 'foo': new Error(), 'bar': new Error() }, Error);
             });
         });
 
-        test('verifyEvenNumber with even number does not throw', function () {
-            assert.doesNotThrow(function () {
-                types.verifyEvenNumber(-8);
-            });
+        test('object.of returns false for arrays', function () {
+            assert.isFalse(check.object.of.unemptyString([ 'foo', 'bar' ]));
         });
+
+        test('object.of returns false for array-likes', function () {
+            assert.isFalse(check.object.of.unemptyString({ 0: 'foo', 1: 'bar', length: 2 }));
+        });
+
+        if (typeof Symbol !== 'undefined') {
+            test('object.of returns false for iterables', function () {
+                assert.isFalse(check.object.of.unemptyString(new Set([ 'foo', 'bar' ])));
+            });
+        }
     });
-}());
+}(typeof require === 'function' ? require : undefined));