text: /*globals define, module, Symbol */
  /*jshint -W056 */
  
  (function (globals) {
    'use strict';
  
    var strings, messages, predicates, functions, assert, not, maybe,
        collections, slice, neginf, posinf, isArray, haveSymbols;
  
    strings = {
      v: 'value',
      n: 'number',
      s: 'string',
      b: 'boolean',
      o: 'object',
      t: 'type',
      a: 'array',
      al: 'array-like',
      i: 'iterable',
      d: 'date',
      f: 'function',
      l: 'length'
    };
  
    messages = {};
    predicates = {};
  
    [
      { n: 'equal', f: equal, s: 'v' },
      { n: 'undefined', f: isUndefined, s: 'v' },
      { n: 'null', f: isNull, s: 'v' },
      { n: 'assigned', f: assigned, s: 'v' },
      { n: 'primitive', f: primitive, s: 'v' },
      { n: 'includes', f: includes, s: 'v' },
      { n: 'zero', f: zero },
      { n: 'infinity', f: infinity },
      { n: 'number', f: number },
      { n: 'integer', f: integer },
      { n: 'even', f: even },
      { n: 'odd', f: odd },
      { n: 'greater', f: greater },
      { n: 'less', f: less },
      { n: 'between', f: between },
      { n: 'greaterOrEqual', f: greaterOrEqual },
      { n: 'lessOrEqual', f: lessOrEqual },
      { n: 'inRange', f: inRange },
      { n: 'positive', f: positive },
      { n: 'negative', f: negative },
      { n: 'string', f: string, s: 's' },
      { n: 'emptyString', f: emptyString, s: 's' },
      { n: 'nonEmptyString', f: nonEmptyString, s: 's' },
      { n: 'contains', f: contains, s: 's' },
      { n: 'match', f: match, s: 's' },
      { n: 'boolean', f: boolean, s: 'b' },
      { n: 'object', f: object, s: 'o' },
      { n: 'emptyObject', f: emptyObject, s: 'o' },
      { n: 'nonEmptyObject', f: nonEmptyObject, s: 'o' },
      { n: 'instanceStrict', f: instanceStrict, s: 't' },
      { n: 'instance', f: instance, s: 't' },
      { n: 'like', f: like, s: 't' },
      { n: 'array', f: array, s: 'a' },
      { n: 'emptyArray', f: emptyArray, s: 'a' },
      { n: 'nonEmptyArray', f: nonEmptyArray, s: 'a' },
      { n: 'arrayLike', f: arrayLike, s: 'al' },
      { n: 'iterable', f: iterable, s: 'i' },
      { n: 'date', f: date, s: 'd' },
      { n: 'function', f: isFunction, s: 'f' },
      { n: 'hasLength', f: hasLength, s: 'l' },
    ].map(function (data) {
      var n = data.n;
      messages[n] = 'Invalid ' + strings[data.s || 'n'];
      predicates[n] = data.f;
    });
  
    functions = {
      apply: apply,
      map: map,
      all: all,
      any: any
    };
  
    collections = [ 'array', 'arrayLike', 'iterable', 'object' ];
    slice = Array.prototype.slice;
    neginf = Number.NEGATIVE_INFINITY;
    posinf = Number.POSITIVE_INFINITY;
    isArray = Array.isArray;
    haveSymbols = typeof Symbol === 'function';
  
    functions = mixin(functions, predicates);
    assert = createModifiedPredicates(assertModifier, assertImpl);
    not = createModifiedPredicates(notModifier, notImpl);
    maybe = createModifiedPredicates(maybeModifier, maybeImpl);
    assert.not = createModifiedModifier(assertModifier, not);
    assert.maybe = createModifiedModifier(assertModifier, maybe);
  
    collections.forEach(createOfPredicates);
    createOfModifiers(assert, assertModifier);
    createOfModifiers(not, notModifier);
    collections.forEach(createMaybeOfModifiers);
  
    exportFunctions(mixin(functions, {
      assert: assert,
      not: not,
      maybe: maybe
    }));
  
    /**
     * Public function `equal`.
     *
     * Returns true if `lhs` and `rhs` are strictly equal, without coercion.
     * Returns false otherwise.
     */
    function equal (lhs, rhs) {
      return lhs === rhs;
    }
  
    /**
     * Public function `undefined`.
     *
     * Returns true if `data` is undefined, false otherwise.
     */
    function isUndefined (data) {
      return data === undefined;
    }
  
    /**
     * Public function `null`.
     *
     * Returns true if `data` is null, false otherwise.
     */
    function isNull (data) {
      return data === null;
    }
  
    /**
     * Public function `assigned`.
     *
     * Returns true if `data` is not null or undefined, false otherwise.
     */
    function assigned (data) {
      return data !== undefined && data !== null;
    }
  
    /**
     * Public function `primitive`.
     *
     * Returns true if `data` is a primitive type, false otherwise.
     */
    function primitive (data) {
      var type;
  
      switch (data) {
        case null:
        case undefined:
        case false:
        case true:
          return true;
      }
  
      type = typeof data;
      return type === 'string' || type === 'number' || (haveSymbols && type === 'symbol');
    }
  
    /**
     * Public function `zero`.
     *
     * Returns true if `data` is zero, false otherwise.
     */
    function zero (data) {
      return data === 0;
    }
  
    /**
     * Public function `infinity`.
     *
     * Returns true if `data` is positive or negative infinity, false otherwise.
     */
    function infinity (data) {
      return data === neginf || data === posinf;
    }
  
    /**
     * Public function `number`.
     *
     * Returns true if `data` is a number, false otherwise.
     */
    function number (data) {
      return typeof data === 'number' && data > neginf && data < posinf;
    }
  
    /**
     * Public function `integer`.
     *
     * Returns true if `data` is an integer, false otherwise.
     */
    function integer (data) {
      return typeof data === 'number' && data % 1 === 0;
    }
  
    /**
     * Public function `even`.
     *
     * Returns true if `data` is an even number, false otherwise.
     */
    function even (data) {
      return typeof data === 'number' && data % 2 === 0;
    }
  
    /**
     * Public function `odd`.
     *
     * Returns true if `data` is an odd number, false otherwise.
     */
    function odd (data) {
      return integer(data) && data % 2 !== 0;
    }
  
    /**
     * Public function `greater`.
     *
     * Returns true if `lhs` is a number greater than `rhs`, false otherwise.
     */
    function greater (lhs, rhs) {
      return number(lhs) && lhs > rhs;
    }
  
    /**
     * Public function `less`.
     *
     * Returns true if `lhs` is a number less than `rhs`, false otherwise.
     */
    function less (lhs, rhs) {
      return number(lhs) && lhs < rhs;
    }
  
    /**
     * Public function `between`.
     *
     * Returns true if `data` is a number between `x` and `y`, false otherwise.
     */
    function between (data, x, y) {
      if (x < y) {
        return greater(data, x) && data < y;
      }
  
      return less(data, x) && data > y;
    }
  
    /**
     * Public function `greaterOrEqual`.
     *
     * Returns true if `lhs` is a number greater than or equal to `rhs`, false
     * otherwise.
     */
    function greaterOrEqual (lhs, rhs) {
      return number(lhs) && lhs >= rhs;
    }
  
    /**
     * Public function `lessOrEqual`.
     *
     * Returns true if `lhs` is a number less than or equal to `rhs`, false
     * otherwise.
     */
    function lessOrEqual (lhs, rhs) {
      return number(lhs) && lhs <= rhs;
    }
  
    /**
     * Public function `inRange`.
     *
     * Returns true if `data` is a number in the range `x..y`, false otherwise.
     */
    function inRange (data, x, y) {
      if (x < y) {
        return greaterOrEqual(data, x) && data <= y;
      }
  
      return lessOrEqual(data, x) && data >= y;
    }
  
    /**
     * Public function `positive`.
     *
     * Returns true if `data` is a positive number, false otherwise.
     */
    function positive (data) {
      return greater(data, 0);
    }
  
    /**
     * Public function `negative`.
     *
     * Returns true if `data` is a negative number, false otherwise.
     */
    function negative (data) {
      return less(data, 0);
    }
  
    /**
     * Public function `string`.
     *
     * Returns true if `data` is a string, false otherwise.
     */
    function string (data) {
      return typeof data === 'string';
    }
  
    /**
     * Public function `emptyString`.
     *
     * Returns true if `data` is the empty string, false otherwise.
     */
    function emptyString (data) {
      return data === '';
    }
  
    /**
     * Public function `nonEmptyString`.
     *
     * Returns true if `data` is a non-empty string, false otherwise.
     */
    function nonEmptyString (data) {
      return string(data) && data !== '';
    }
  
    /**
     * Public function `contains`.
     *
     * Returns true if `data` is a string that contains `substring`, false
     * otherwise.
     */
    function contains (data, substring) {
      return string(data) && data.indexOf(substring) !== -1;
    }
  
    /**
     * Public function `match`.
     *
     * Returns true if `data` is a string that matches `regex`, false otherwise.
     */
    function match (data, regex) {
      return string(data) && !! data.match(regex);
    }
  
    /**
     * Public function `boolean`.
     *
     * Returns true if `data` is a boolean value, false otherwise.
     */
    function boolean (data) {
      return data === false || data === true;
    }
  
    /**
     * Public function `object`.
     *
     * Returns true if `data` is a plain-old JS object, false otherwise.
     */
    function object (data) {
      return Object.prototype.toString.call(data) === '[object Object]';
    }
  
    /**
     * Public function `emptyObject`.
     *
     * Returns true if `data` is an empty object, false otherwise.
     */
    function emptyObject (data) {
      return object(data) && Object.keys(data).length === 0;
    }
  
    /**
     * Public function `nonEmptyObject`.
     *
     * Returns true if `data` is a non-empty object, false otherwise.
     */
    function nonEmptyObject (data) {
      return object(data) && Object.keys(data).length > 0;
    }
  
    /**
     * Public function `instanceStrict`.
     *
     * Returns true if `data` is an instance of `prototype`, false otherwise.
     */
    function instanceStrict (data, prototype) {
      try {
        return data instanceof prototype;
      } catch (error) {
        return false;
      }
    }
  
    /**
     * Public function `instance`.
     *
     * Returns true if `data` is an instance of `prototype`, false otherwise.
     * Falls back to testing constructor.name and Object.prototype.toString
     * if the initial instanceof test fails.
     */
    function instance (data, prototype) {
      try {
        return instanceStrict(data, prototype) ||
          data.constructor.name === prototype.name ||
          Object.prototype.toString.call(data) === '[object ' + prototype.name + ']';
      } catch (error) {
        return false;
      }
    }
  
    /**
     * Public function `like`.
     *
     * Tests whether `data` 'quacks like a duck'. Returns true if `data` has all
     * of the properties of `archetype` (the 'duck'), false otherwise.
     */
    function like (data, archetype) {
      var name;
  
      for (name in archetype) {
        if (archetype.hasOwnProperty(name)) {
          if (data.hasOwnProperty(name) === false || typeof data[name] !== typeof archetype[name]) {
            return false;
          }
  
          if (object(data[name]) && like(data[name], archetype[name]) === false) {
            return false;
          }
        }
      }
  
      return true;
    }
  
    /**
     * Public function `array`.
     *
     * Returns true if `data` is an array, false otherwise.
     */
    function array (data) {
      return isArray(data);
    }
  
    /**
     * Public function `emptyArray`.
     *
     * Returns true if `data` is an empty array, false otherwise.
     */
    function emptyArray (data) {
      return array(data) && data.length === 0;
    }
  
    /**
     * Public function `nonEmptyArray`.
     *
     * Returns true if `data` is a non-empty array, false otherwise.
     */
    function nonEmptyArray (data) {
      return array(data) && greater(data.length, 0);
    }
  
    /**
     * Public function `arrayLike`.
     *
     * Returns true if `data` is an array-like object, false otherwise.
     */
    function arrayLike (data) {
      return assigned(data) && greaterOrEqual(data.length, 0);
    }
  
    /**
     * Public function `iterable`.
     *
     * Returns true if `data` is an iterable, false otherwise.
     */
    function iterable (data) {
      if (! haveSymbols) {
        // Fall back to `arrayLike` predicate in pre-ES6 environments.
        return arrayLike(data);
      }
  
      return assigned(data) && isFunction(data[Symbol.iterator]);
    }
  
    /**
     * Public function `includes`.
     *
     * Returns true if `data` contains `value`, false otherwise.
     */
    function includes (data, value) {
      var iterator, iteration, keys, length, i;
  
      if (! assigned(data)) {
        return false;
      }
  
      if (haveSymbols && data[Symbol.iterator] && isFunction(data.values)) {
        iterator = data.values();
  
        do {
          iteration = iterator.next();
  
          if (iteration.value === value) {
            return true;
          }
        } while (! iteration.done);
  
        return false;
      }
  
      keys = Object.keys(data);
      length = keys.length;
      for (i = 0; i < length; ++i) {
        if (data[keys[i]] === value) {
          return true;
        }
      }
  
      return false;
    }
  
    /**
     * Public function `hasLength`.
     *
     * Returns true if `data` has a length property that equals `length`, false
     * otherwise.
     */
    function hasLength (data, length) {
      return assigned(data) && data.length === length;
    }
  
    /**
     * Public function `date`.
     *
     * Returns true if `data` is a valid date, false otherwise.
     */
    function date (data) {
      return instanceStrict(data, Date) && integer(data.getTime());
    }
  
    /**
     * Public function `function`.
     *
     * Returns true if `data` is a function, false otherwise.
     */
    function isFunction (data) {
      return typeof data === 'function';
    }
  
    /**
     * Public function `apply`.
     *
     * 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.
     *
     */
    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 `map`.
     *
     * 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.m;
          } 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`).
     *
     */
    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 `any`
     *
     * Check that at least one boolean value is true
     * in an array (returned from `apply`)
     * or object (returned from `map`).
     *
     */
    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 modifier `assert`.
     *
     * Throws if `predicate` returns false.
     */
    function assertModifier (predicate, defaultMessage) {
      return function () {
        return assertPredicate(predicate, arguments, defaultMessage);
      };
    }
  
    function assertPredicate (predicate, args, defaultMessage) {
      var argCount = predicate.l || predicate.length;
      var message = args[argCount];
      var ErrorType = args[argCount + 1];
      assertImpl(
        predicate.apply(null, args),
        nonEmptyString(message) ? message : defaultMessage,
        isFunction(ErrorType) ? ErrorType : TypeError
      );
      return args[0];
    }
  
    function assertImpl (value, message, ErrorType) {
      if (value) {
        return value;
      }
      throw new (ErrorType || Error)(message || 'Assertion failed');
    }
  
    /**
     * Public modifier `not`.
     *
     * Negates `predicate`.
     */
    function notModifier (predicate) {
      var modifiedPredicate = function () {
        return notImpl(predicate.apply(null, arguments));
      };
      modifiedPredicate.l = predicate.length;
      return modifiedPredicate;
    }
  
    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 (not.assigned(arguments[0])) {
          return true;
        }
  
        return predicate.apply(null, arguments);
      };
      modifiedPredicate.l = predicate.length;
  
      // 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.m = true;
  
      return modifiedPredicate;
    }
  
    function maybeImpl (value) {
      if (assigned(value) === false) {
        return true;
      }
  
      return value;
    }
  
    /**
     * Public modifier `of`.
     *
     * Applies the chained predicate to members of the collection.
     */
    function ofModifier (target, type, predicate) {
      var modifiedPredicate = function () {
        var collection, args;
  
        collection = arguments[0];
  
        if (target === 'maybe' && not.assigned(collection)) {
          return true;
        }
  
        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))
            ) {
              // TODO: Replace with for...of when ES6 is required.
              throw 0;
            }
          });
        } catch (ignore) {
          return false;
        }
  
        return true;
      };
      modifiedPredicate.l = predicate.length;
      return modifiedPredicate;
    }
  
    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 && module.exports) {
        module.exports = functions;
      } else {
        globals.check = functions;
      }
    }
  }(this));
  