eventman/static/js/api-check.js

//! api-check version 7.5.5 built with ♥ by Kent C. Dodds <kent@doddsfamily.us> (http://kent.doddsfamily.us) (ó ì_í)=óò=(ì_í ò)

(function webpackUniversalModuleDefinition(root, factory) {
	if(typeof exports === 'object' && typeof module === 'object')
		module.exports = factory();
	else if(typeof define === 'function' && define.amd)
		define(factory);
	else if(typeof exports === 'object')
		exports["apiCheck"] = factory();
	else
		root["apiCheck"] = factory();
})(this, function() {
return /******/ (function(modules) { // webpackBootstrap
/******/ 	// The module cache
/******/ 	var installedModules = {};

/******/ 	// The require function
/******/ 	function __webpack_require__(moduleId) {

/******/ 		// Check if module is in cache
/******/ 		if(installedModules[moduleId])
/******/ 			return installedModules[moduleId].exports;

/******/ 		// Create a new module (and put it into the cache)
/******/ 		var module = installedModules[moduleId] = {
/******/ 			exports: {},
/******/ 			id: moduleId,
/******/ 			loaded: false
/******/ 		};

/******/ 		// Execute the module function
/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);

/******/ 		// Flag the module as loaded
/******/ 		module.loaded = true;

/******/ 		// Return the exports of the module
/******/ 		return module.exports;
/******/ 	}


/******/ 	// expose the modules object (__webpack_modules__)
/******/ 	__webpack_require__.m = modules;

/******/ 	// expose the module cache
/******/ 	__webpack_require__.c = installedModules;

/******/ 	// __webpack_public_path__
/******/ 	__webpack_require__.p = "";

/******/ 	// Load entry module and return exports
/******/ 	return __webpack_require__(0);
/******/ })
/************************************************************************/
/******/ ([
/* 0 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';

	Object.defineProperty(exports, '__esModule', {
	  value: true
	});

	function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }

	var _apiCheck = __webpack_require__(1);

	var _apiCheck2 = _interopRequireDefault(_apiCheck);

	exports['default'] = _apiCheck2['default'];
	module.exports = exports['default'];

/***/ },
/* 1 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';

	var stringify = __webpack_require__(2);
	var apiCheckUtil = __webpack_require__(3);
	var each = apiCheckUtil.each;
	var isError = apiCheckUtil.isError;
	var t = apiCheckUtil.t;
	var arrayify = apiCheckUtil.arrayify;
	var getCheckerDisplay = apiCheckUtil.getCheckerDisplay;
	var typeOf = apiCheckUtil.typeOf;
	var getError = apiCheckUtil.getError;

	var checkers = __webpack_require__(4);
	var apiCheckApis = getApiCheckApis();

	module.exports = getApiCheckInstance;
	module.exports.VERSION = ("7.5.5");
	module.exports.utils = apiCheckUtil;
	module.exports.globalConfig = {
	  verbose: false,
	  disabled: false
	};

	var apiCheckApiCheck = getApiCheckInstance({
	  output: { prefix: 'apiCheck' }
	});
	module.exports.internalChecker = apiCheckApiCheck;

	each(checkers, function (checker, name) {
	  return module.exports[name] = checker;
	});

	function getApiCheckInstance() {
	  var config = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];
	  var extraCheckers = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];

	  /* eslint complexity:[2, 6] */
	  if (apiCheckApiCheck && arguments.length) {
	    apiCheckApiCheck['throw'](apiCheckApis.getApiCheckInstanceCheckers, arguments, {
	      prefix: 'creating an apiCheck instance'
	    });
	  }

	  var additionalProperties = {
	    'throw': getApiCheck(true),
	    warn: getApiCheck(false),
	    getErrorMessage: getErrorMessage,
	    handleErrorMessage: handleErrorMessage,
	    config: {
	      output: config.output || {
	        prefix: '',
	        suffix: '',
	        docsBaseUrl: ''
	      },
	      verbose: config.verbose || false,
	      disabled: config.disabled || false
	    },
	    utils: apiCheckUtil
	  };

	  each(additionalProperties, function (wrapper, name) {
	    return apiCheck[name] = wrapper;
	  });

	  var disabled = apiCheck.disabled || module.exports.globalConfig.disabled;
	  each(checkers.getCheckers(disabled), function (checker, name) {
	    return apiCheck[name] = checker;
	  });
	  each(extraCheckers, function (checker, name) {
	    return apiCheck[name] = checker;
	  });

	  return apiCheck;

	  /**
	   * This is the instance function. Other things are attached to this see additional properties above.
	   * @param {Array} api - the checkers to check with
	   * @param {Array} args - the args to check
	   * @param {Object} output - output options
	   * @returns {Object} - if this has a failed = true property, then it failed
	   */
	  function apiCheck(api, args, output) {
	    /* eslint complexity:[2, 8] */
	    if (apiCheck.config.disabled || module.exports.globalConfig.disabled) {
	      return {
	        apiTypes: {}, argTypes: {},
	        passed: true, message: '',
	        failed: false
	      }; // empty version of what is normally returned
	    }
	    checkApiCheckApi(arguments);
	    if (!Array.isArray(api)) {
	      api = [api];
	      args = [args];
	    } else {
	      // turn arguments into an array
	      args = Array.prototype.slice.call(args);
	    }
	    var messages = checkEnoughArgs(api, args);
	    if (!messages.length) {
	      // this is where we actually go perform the checks.
	      messages = checkApiWithArgs(api, args);
	    }

	    var returnObject = getTypes(api, args);
	    returnObject.args = args;
	    if (messages.length) {
	      returnObject.message = apiCheck.getErrorMessage(api, args, messages, output);
	      returnObject.failed = true;
	      returnObject.passed = false;
	    } else {
	      returnObject.message = '';
	      returnObject.failed = false;
	      returnObject.passed = true;
	    }
	    return returnObject;
	  }

	  /**
	   * checkApiCheckApi, should be read like: check apiCheck api. As in, check the api for apiCheck :-)
	   * @param {Array} checkApiArgs - args provided to apiCheck function
	   */
	  function checkApiCheckApi(checkApiArgs) {
	    var api = checkApiArgs[0];
	    var args = checkApiArgs[1];
	    var isArrayOrArgs = Array.isArray(args) || args && typeof args === 'object' && typeof args.length === 'number';

	    if (Array.isArray(api) && !isArrayOrArgs) {
	      throw new Error(getErrorMessage(api, [args], ['If an array is provided for the api, an array must be provided for the args as well.'], { prefix: 'apiCheck' }));
	    }
	    // dog fooding here
	    var errors = checkApiWithArgs(apiCheckApis.checkApiCheckApi, checkApiArgs);
	    if (errors.length) {
	      var message = apiCheck.getErrorMessage(apiCheckApis.checkApiCheckApi, checkApiArgs, errors, {
	        prefix: 'apiCheck'
	      });
	      apiCheck.handleErrorMessage(message, true);
	    }
	  }

	  function getApiCheck(shouldThrow) {
	    return function apiCheckWrapper(api, args, output) {
	      var result = apiCheck(api, args, output);
	      apiCheck.handleErrorMessage(result.message, shouldThrow);
	      return result; // wont get here if an error is thrown
	    };
	  }

	  function handleErrorMessage(message, shouldThrow) {
	    if (shouldThrow && message) {
	      throw new Error(message);
	    } else if (message) {
	      /* eslint no-console:0 */
	      console.warn(message);
	    }
	  }

	  function getErrorMessage(api, args) {
	    var messages = arguments.length <= 2 || arguments[2] === undefined ? [] : arguments[2];
	    var output = arguments.length <= 3 || arguments[3] === undefined ? {} : arguments[3];

	    var gOut = apiCheck.config.output || {};
	    var prefix = getPrefix();
	    var suffix = getSuffix();
	    var url = getUrl();
	    var message = 'apiCheck failed! ' + messages.join(', ');
	    var passedAndShouldHavePassed = '\n\n' + buildMessageFromApiAndArgs(api, args);
	    return (prefix + ' ' + message + ' ' + suffix + ' ' + (url || '') + passedAndShouldHavePassed).trim();

	    function getPrefix() {
	      var p = output.onlyPrefix;
	      if (!p) {
	        p = ((gOut.prefix || '') + ' ' + (output.prefix || '')).trim();
	      }
	      return p;
	    }

	    function getSuffix() {
	      var s = output.onlySuffix;
	      if (!s) {
	        s = ((output.suffix || '') + ' ' + (gOut.suffix || '')).trim();
	      }
	      return s;
	    }

	    function getUrl() {
	      var u = output.url;
	      if (!u) {
	        u = gOut.docsBaseUrl && output.urlSuffix && ('' + gOut.docsBaseUrl + output.urlSuffix).trim();
	      }
	      return u;
	    }
	  }

	  function buildMessageFromApiAndArgs(api, args) {
	    var _getTypes = getTypes(api, args);

	    var apiTypes = _getTypes.apiTypes;
	    var argTypes = _getTypes.argTypes;

	    var copy = Array.prototype.slice.call(args || []);
	    var replacedItems = [];
	    replaceFunctionWithName(copy);
	    var passedArgs = getObjectString(copy);
	    argTypes = getObjectString(argTypes);
	    apiTypes = getObjectString(apiTypes);

	    return generateMessage();

	    // functions

	    function replaceFunctionWithName(obj) {
	      each(obj, function (val, name) {
	        /* eslint complexity:[2, 6] */
	        if (replacedItems.indexOf(val) === -1) {
	          // avoid recursive problems
	          replacedItems.push(val);
	          if (typeof val === 'object') {
	            replaceFunctionWithName(obj);
	          } else if (typeof val === 'function') {
	            obj[name] = val.displayName || val.name || 'anonymous function';
	          }
	        }
	      });
	    }

	    function getObjectString(types) {
	      if (!types || !types.length) {
	        return 'nothing';
	      } else if (types && types.length === 1) {
	        types = types[0];
	      }
	      return stringify(types, null, 2);
	    }

	    function generateMessage() {
	      var n = '\n';
	      var useS = true;
	      if (args && args.length === 1) {
	        if (typeof args[0] === 'object' && args[0] !== null) {
	          useS = !!Object.keys(args[0]).length;
	        } else {
	          useS = false;
	        }
	      }
	      var types = 'type' + (useS ? 's' : '');
	      var newLine = n + n;
	      return 'You passed:' + n + passedArgs + newLine + ('With the ' + types + ':' + n + argTypes + newLine) + ('The API calls for:' + n + apiTypes);
	    }
	  }

	  function getTypes(api, args) {
	    api = arrayify(api);
	    args = arrayify(args);
	    var apiTypes = api.map(function (checker, index) {
	      var specified = module.exports.globalConfig.hasOwnProperty('verbose');
	      return getCheckerDisplay(checker, {
	        terse: specified ? !module.exports.globalConfig.verbose : !apiCheck.config.verbose,
	        obj: args[index],
	        addHelpers: true
	      });
	    });
	    var argTypes = args.map(function (arg) {
	      return getArgDisplay(arg, []);
	    });
	    return { argTypes: argTypes, apiTypes: apiTypes };
	  }
	}

	// STATELESS FUNCTIONS

	/**
	 * This is where the magic happens for actually checking the arguments with the api.
	 * @param {Array} api - checkers
	 * @param  {Array} args - and arguments object
	 * @returns {Array} - the error messages
	 */
	function checkApiWithArgs(api, args) {
	  /* eslint complexity:[2, 7] */
	  var messages = [];
	  var failed = false;
	  var checkerIndex = 0;
	  var argIndex = 0;
	  var arg = undefined,
	      checker = undefined,
	      res = undefined,
	      lastChecker = undefined,
	      argName = undefined,
	      argFailed = undefined,
	      skipPreviousChecker = undefined;
	  /* jshint -W084 */
	  while ((checker = api[checkerIndex++]) && argIndex < args.length) {
	    arg = args[argIndex++];
	    argName = 'Argument ' + argIndex + (checker.isOptional ? ' (optional)' : '');
	    res = checker(arg, 'value', argName);
	    argFailed = isError(res);
	    lastChecker = checkerIndex >= api.length;
	    skipPreviousChecker = checkerIndex > 1 && api[checkerIndex - 1].isOptional;
	    if (argFailed && lastChecker || argFailed && !lastChecker && !checker.isOptional && !skipPreviousChecker) {
	      failed = true;
	      messages.push(getCheckerErrorMessage(res, checker, arg));
	    } else if (argFailed && checker.isOptional) {
	      argIndex--;
	    } else {
	      messages.push(t(argName) + ' passed');
	    }
	  }
	  return failed ? messages : [];
	}

	checkerTypeType.type = 'function with __apiCheckData property and `${function.type}` property';
	function checkerTypeType(checkerType, name, location) {
	  var apiCheckDataChecker = checkers.shape({
	    type: checkers.string,
	    optional: checkers.bool
	  });
	  var asFunc = checkers.func.withProperties({ __apiCheckData: apiCheckDataChecker });
	  var asShape = checkers.shape({ __apiCheckData: apiCheckDataChecker });
	  var wrongShape = checkers.oneOfType([asFunc, asShape])(checkerType, name, location);
	  if (isError(wrongShape)) {
	    return wrongShape;
	  }
	  if (typeof checkerType !== 'function' && !checkerType.hasOwnProperty(checkerType.__apiCheckData.type)) {
	    return getError(name, location, checkerTypeType.type);
	  }
	}

	function getCheckerErrorMessage(res, checker, val) {
	  var checkerHelp = getCheckerHelp(checker, val);
	  checkerHelp = checkerHelp ? ' - ' + checkerHelp : '';
	  return res.message + checkerHelp;
	}

	function getCheckerHelp(_ref, val) {
	  var help = _ref.help;

	  if (!help) {
	    return '';
	  }
	  if (typeof help === 'function') {
	    help = help(val);
	  }
	  return help;
	}

	function checkEnoughArgs(api, args) {
	  var requiredArgs = api.filter(function (a) {
	    return !a.isOptional;
	  });
	  if (args.length < requiredArgs.length) {
	    return ['Not enough arguments specified. Requires `' + requiredArgs.length + '`, you passed `' + args.length + '`'];
	  } else {
	    return [];
	  }
	}

	function getArgDisplay(arg, gottenArgs) {
	  /* eslint complexity:[2, 7] */
	  var cName = arg && arg.constructor && arg.constructor.name;
	  var type = typeOf(arg);
	  if (type === 'function') {
	    if (hasKeys()) {
	      var properties = stringify(getDisplayIfNotGotten());
	      return cName + ' (with properties: ' + properties + ')';
	    }
	    return cName;
	  }

	  if (arg === null) {
	    return 'null';
	  }

	  if (type !== 'array' && type !== 'object') {
	    return type;
	  }

	  if (hasKeys()) {
	    return getDisplayIfNotGotten();
	  }

	  return cName;

	  // utility functions
	  function hasKeys() {
	    return arg && Object.keys(arg).length;
	  }

	  function getDisplayIfNotGotten() {
	    if (gottenArgs.indexOf(arg) !== -1) {
	      return '[Circular]';
	    }
	    gottenArgs.push(arg);
	    return getDisplay(arg, gottenArgs);
	  }
	}

	function getDisplay(obj, gottenArgs) {
	  var argDisplay = {};
	  each(obj, function (v, k) {
	    return argDisplay[k] = getArgDisplay(v, gottenArgs);
	  });
	  return argDisplay;
	}

	function getApiCheckApis() {
	  var os = checkers.string.optional;

	  var checkerFnChecker = checkers.func.withProperties({
	    type: checkers.oneOfType([checkers.string, checkerTypeType]).optional,
	    displayName: checkers.string.optional,
	    shortType: checkers.string.optional,
	    notOptional: checkers.bool.optional,
	    notRequired: checkers.bool.optional
	  });

	  var getApiCheckInstanceCheckers = [checkers.shape({
	    output: checkers.shape({
	      prefix: checkers.string.optional,
	      suffix: checkers.string.optional,
	      docsBaseUrl: checkers.string.optional
	    }).strict.optional,
	    verbose: checkers.bool.optional,
	    disabled: checkers.bool.optional
	  }).strict.optional, checkers.objectOf(checkerFnChecker).optional];

	  var checkApiCheckApi = [checkers.typeOrArrayOf(checkerFnChecker), checkers.any.optional, checkers.shape({
	    prefix: os, suffix: os, urlSuffix: os, // appended case
	    onlyPrefix: os, onlySuffix: os, url: os // override case
	  }).strict.optional];

	  return {
	    checkerFnChecker: checkerFnChecker,
	    getApiCheckInstanceCheckers: getApiCheckInstanceCheckers,
	    checkApiCheckApi: checkApiCheckApi
	  };
	}

/***/ },
/* 2 */
/***/ function(module, exports) {

	module.exports = stringify;

	function getSerialize (fn, decycle) {
	  var seen = [], keys = [];
	  decycle = decycle || function(key, value) {
	    return '[Circular ' + getPath(value, seen, keys) + ']'
	  };
	  return function(key, value) {
	    var ret = value;
	    if (typeof value === 'object' && value) {
	      if (seen.indexOf(value) !== -1)
	        ret = decycle(key, value);
	      else {
	        seen.push(value);
	        keys.push(key);
	      }
	    }
	    if (fn) ret = fn(key, ret);
	    return ret;
	  }
	}

	function getPath (value, seen, keys) {
	  var index = seen.indexOf(value);
	  var path = [ keys[index] ];
	  for (index--; index >= 0; index--) {
	    if (seen[index][ path[0] ] === value) {
	      value = seen[index];
	      path.unshift(keys[index]);
	    }
	  }
	  return '~' + path.join('.');
	}

	function stringify(obj, fn, spaces, decycle) {
	  return JSON.stringify(obj, getSerialize(fn, decycle), spaces);
	}

	stringify.getSerialize = getSerialize;


/***/ },
/* 3 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';

	function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }

	var stringify = __webpack_require__(2);
	var checkerHelpers = {
	  addOptional: addOptional, getRequiredVersion: getRequiredVersion, setupChecker: setupChecker, addNullable: addNullable
	};

	module.exports = {
	  each: each, copy: copy, typeOf: typeOf, arrayify: arrayify, getCheckerDisplay: getCheckerDisplay,
	  isError: isError, list: list, getError: getError, nAtL: nAtL, t: t, undef: undef, checkerHelpers: checkerHelpers,
	  noop: noop
	};

	function copy(obj) {
	  var type = typeOf(obj);
	  var daCopy = undefined;
	  if (type === 'array') {
	    daCopy = [];
	  } else if (type === 'object') {
	    daCopy = {};
	  } else {
	    return obj;
	  }
	  each(obj, function (val, key) {
	    daCopy[key] = val; // cannot single-line this because we don't want to abort the each
	  });
	  return daCopy;
	}

	function typeOf(obj) {
	  if (Array.isArray(obj)) {
	    return 'array';
	  } else if (obj instanceof RegExp) {
	    return 'object';
	  } else {
	    return typeof obj;
	  }
	}

	function getCheckerDisplay(checker, options) {
	  /* eslint complexity:[2, 7] */
	  var display = undefined;
	  var short = options && options.short;
	  if (short && checker.shortType) {
	    display = checker.shortType;
	  } else if (!short && typeof checker.type === 'object' || checker.type === 'function') {
	    display = getCheckerType(checker, options);
	  } else {
	    display = getCheckerType(checker, options) || checker.displayName || checker.name;
	  }
	  return display;
	}

	function getCheckerType(_ref, options) {
	  var type = _ref.type;

	  if (typeof type === 'function') {
	    var __apiCheckData = type.__apiCheckData;
	    var typeTypes = type(options);
	    type = _defineProperty({
	      __apiCheckData: __apiCheckData
	    }, __apiCheckData.type, typeTypes);
	  }
	  return type;
	}

	function arrayify(obj) {
	  if (!obj) {
	    return [];
	  } else if (Array.isArray(obj)) {
	    return obj;
	  } else {
	    return [obj];
	  }
	}

	function each(obj, iterator, context) {
	  if (Array.isArray(obj)) {
	    return eachArry(obj, iterator, context);
	  } else {
	    return eachObj(obj, iterator, context);
	  }
	}

	function eachObj(obj, iterator, context) {
	  var ret = undefined;
	  var hasOwn = Object.prototype.hasOwnProperty;
	  /* eslint prefer-const:0 */ // some weird eslint bug?
	  for (var key in obj) {
	    if (hasOwn.call(obj, key)) {
	      ret = iterator.call(context, obj[key], key, obj);
	      if (ret === false) {
	        return ret;
	      }
	    }
	  }
	  return true;
	}

	function eachArry(obj, iterator, context) {
	  var ret = undefined;
	  var length = obj.length;
	  for (var i = 0; i < length; i++) {
	    ret = iterator.call(context, obj[i], i, obj);
	    if (ret === false) {
	      return ret;
	    }
	  }
	  return true;
	}

	function isError(obj) {
	  return obj instanceof Error;
	}

	function list(arry, join, finalJoin) {
	  arry = arrayify(arry);
	  var copy = arry.slice();
	  var last = copy.pop();
	  if (copy.length === 1) {
	    join = ' ';
	  }
	  return copy.join(join) + ('' + (copy.length ? join + finalJoin : '') + last);
	}

	function getError(name, location, checkerType) {
	  if (typeof checkerType === 'function') {
	    checkerType = checkerType({ short: true });
	  }
	  var stringType = typeof checkerType !== 'object' ? checkerType : stringify(checkerType);
	  return new Error(nAtL(name, location) + ' must be ' + t(stringType));
	}

	function nAtL(name, location) {
	  var tName = t(name || 'value');
	  var tLocation = !location ? '' : ' at ' + t(location);
	  return '' + tName + tLocation;
	}

	function t(thing) {
	  return '`' + thing + '`';
	}

	function undef(thing) {
	  return typeof thing === 'undefined';
	}

	/**
	 * This will set up the checker with all of the defaults that most checkers want like required by default and an
	 * optional version
	 *
	 * @param {Function} checker - the checker to setup with properties
	 * @param {Object} properties - properties to add to the checker
	 * @param {boolean} disabled - when set to true, this will set the checker to a no-op function
	 * @returns {Function} checker - the setup checker
	 */
	function setupChecker(checker, properties, disabled) {
	  /* eslint complexity:[2, 9] */
	  if (disabled) {
	    // swap out the checker for its own copy of noop
	    checker = getNoop();
	    checker.isNoop = true;
	  }

	  if (typeof checker.type === 'string') {
	    checker.shortType = checker.type;
	  }

	  // assign all properties given
	  each(properties, function (prop, name) {
	    return checker[name] = prop;
	  });

	  if (!checker.displayName) {
	    checker.displayName = 'apiCheck ' + t(checker.shortType || checker.type || checker.name) + ' type checker';
	  }

	  if (!checker.notRequired) {
	    checker = getRequiredVersion(checker, disabled);
	  }

	  if (!checker.notNullable) {
	    addNullable(checker, disabled);
	  }

	  if (!checker.notOptional) {
	    addOptional(checker, disabled);
	  }

	  return checker;
	}

	function getRequiredVersion(checker, disabled) {
	  var requiredChecker = disabled ? getNoop() : function requiredChecker(val, name, location, obj) {
	    if (undef(val) && !checker.isOptional) {
	      var tLocation = location ? ' in ' + t(location) : '';
	      var type = getCheckerDisplay(checker, { short: true });
	      var stringType = typeof type !== 'object' ? type : stringify(type);
	      return new Error('Required ' + t(name) + ' not specified' + tLocation + '. Must be ' + t(stringType));
	    } else {
	      return checker(val, name, location, obj);
	    }
	  };
	  copyProps(checker, requiredChecker);
	  requiredChecker.originalChecker = checker;
	  return requiredChecker;
	}

	function addOptional(checker, disabled) {
	  var optionalCheck = disabled ? getNoop() : function optionalCheck(val, name, location, obj) {
	    if (!undef(val)) {
	      return checker(val, name, location, obj);
	    }
	  };
	  // inherit all properties on the original checker
	  copyProps(checker, optionalCheck);

	  optionalCheck.isOptional = true;
	  optionalCheck.displayName = checker.displayName + ' (optional)';
	  optionalCheck.originalChecker = checker;

	  // the magic line that allows you to add .optional to the end of the checkers
	  checker.optional = optionalCheck;

	  fixType(checker, checker.optional);
	}

	function addNullable(checker, disabled) {
	  var nullableCheck = disabled ? getNoop() : function nullableCheck(val, name, location, obj) {
	    if (val !== null) {
	      return checker(val, name, location, obj);
	    }
	  };
	  // inherit all properties on the original checker
	  copyProps(checker, nullableCheck);

	  nullableCheck.isNullable = true;
	  nullableCheck.displayName = checker.displayName + ' (nullable)';
	  nullableCheck.originalChecker = checker;

	  // the magic line that allows you to add .nullable to the end of the checkers
	  checker.nullable = nullableCheck;

	  fixType(checker, checker.nullable);
	  if (!checker.notOptional) {
	    addOptional(checker.nullable, disabled);
	  }
	}

	function fixType(checker, checkerCopy) {
	  // fix type, because it's not a straight copy...
	  // the reason is we need to specify type.__apiCheckData.optional as true for the terse/verbose option.
	  // we also want to add "(optional)" to the types with a string
	  if (typeof checkerCopy.type === 'object') {
	    checkerCopy.type = copy(checkerCopy.type); // make our own copy of this
	  } else if (typeof checkerCopy.type === 'function') {
	      checkerCopy.type = function () {
	        return checker.type.apply(checker, arguments);
	      };
	    } else {
	      checkerCopy.type += ' (optional)';
	      return;
	    }
	  checkerCopy.type.__apiCheckData = copy(checker.type.__apiCheckData) || {}; // and this
	  checkerCopy.type.__apiCheckData.optional = true;
	}

	// UTILS

	function copyProps(src, dest) {
	  each(Object.keys(src), function (key) {
	    return dest[key] = src[key];
	  });
	}

	function noop() {}

	function getNoop() {
	  /* eslint no-shadow:0 */
	  /* istanbul ignore next */
	  return function noop() {};
	}

/***/ },
/* 4 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';

	var stringify = __webpack_require__(2);

	var _require = __webpack_require__(3);

	var typeOf = _require.typeOf;
	var each = _require.each;
	var copy = _require.copy;
	var getCheckerDisplay = _require.getCheckerDisplay;
	var isError = _require.isError;
	var arrayify = _require.arrayify;
	var list = _require.list;
	var getError = _require.getError;
	var nAtL = _require.nAtL;
	var t = _require.t;
	var checkerHelpers = _require.checkerHelpers;
	var undef = _require.undef;
	var setupChecker = checkerHelpers.setupChecker;

	var checkers = module.exports = getCheckers();
	module.exports.getCheckers = getCheckers;

	function getCheckers(disabled) {
	  return {
	    array: typeOfCheckGetter('Array'),
	    bool: typeOfCheckGetter('Boolean'),
	    number: typeOfCheckGetter('Number'),
	    string: typeOfCheckGetter('String'),
	    func: funcCheckGetter(),
	    object: objectCheckGetter(),

	    emptyObject: emptyObjectCheckGetter(),

	    instanceOf: instanceCheckGetter,
	    oneOf: oneOfCheckGetter,
	    oneOfType: oneOfTypeCheckGetter,

	    arrayOf: arrayOfCheckGetter,
	    objectOf: objectOfCheckGetter,
	    typeOrArrayOf: typeOrArrayOfCheckGetter,

	    range: rangeCheckGetter,
	    lessThan: lessThanCheckGetter,
	    greaterThan: greaterThanCheckGetter,

	    shape: getShapeCheckGetter(),
	    args: argumentsCheckerGetter(),

	    any: anyCheckGetter(),
	    'null': nullCheckGetter()

	  };

	  function typeOfCheckGetter(type) {
	    var lType = type.toLowerCase();
	    return setupChecker(function typeOfCheckerDefinition(val, name, location) {
	      if (typeOf(val) !== lType) {
	        return getError(name, location, type);
	      }
	    }, { type: type }, disabled);
	  }

	  function funcCheckGetter() {
	    var type = 'Function';
	    var functionChecker = setupChecker(function functionCheckerDefinition(val, name, location) {
	      if (typeOf(val) !== 'function') {
	        return getError(name, location, type);
	      }
	    }, { type: type }, disabled);

	    functionChecker.withProperties = function getWithPropertiesChecker(properties) {
	      var apiError = checkers.objectOf(checkers.func)(properties, 'properties', 'apiCheck.func.withProperties');
	      if (isError(apiError)) {
	        throw apiError;
	      }
	      var shapeChecker = checkers.shape(properties, true);
	      shapeChecker.type.__apiCheckData.type = 'func.withProperties';

	      return setupChecker(function functionWithPropertiesChecker(val, name, location) {
	        var notFunction = checkers.func(val, name, location);
	        if (isError(notFunction)) {
	          return notFunction;
	        }
	        return shapeChecker(val, name, location);
	      }, { type: shapeChecker.type, shortType: 'func.withProperties' }, disabled);
	    };
	    return functionChecker;
	  }

	  function objectCheckGetter() {
	    var type = 'Object';
	    var nullType = 'Object (null ok)';
	    var objectNullOkChecker = setupChecker(function objectNullOkCheckerDefinition(val, name, location) {
	      if (typeOf(val) !== 'object') {
	        return getError(name, location, nullType);
	      }
	    }, { type: nullType }, disabled);

	    var objectChecker = setupChecker(function objectCheckerDefinition(val, name, location) {
	      if (val === null || isError(objectNullOkChecker(val, name, location))) {
	        return getError(name, location, objectChecker.type);
	      }
	    }, { type: type, nullOk: objectNullOkChecker }, disabled);

	    return objectChecker;
	  }

	  function instanceCheckGetter(classToCheck) {
	    return setupChecker(function instanceCheckerDefinition(val, name, location) {
	      if (!(val instanceof classToCheck)) {
	        return getError(name, location, classToCheck.name);
	      }
	    }, { type: classToCheck.name }, disabled);
	  }

	  function oneOfCheckGetter(enums) {
	    var type = {
	      __apiCheckData: { optional: false, type: 'enum' },
	      'enum': enums
	    };
	    var shortType = 'oneOf[' + enums.map(function (enm) {
	      return stringify(enm);
	    }).join(', ') + ']';
	    return setupChecker(function oneOfCheckerDefinition(val, name, location) {
	      if (!enums.some(function (enm) {
	        return enm === val;
	      })) {
	        return getError(name, location, shortType);
	      }
	    }, { type: type, shortType: shortType }, disabled);
	  }

	  function oneOfTypeCheckGetter(typeCheckers) {
	    var checkersDisplay = typeCheckers.map(function (checker) {
	      return getCheckerDisplay(checker, { short: true });
	    });
	    var shortType = 'oneOfType[' + checkersDisplay.join(', ') + ']';
	    function type(options) {
	      if (options && options.short) {
	        return shortType;
	      }
	      return typeCheckers.map(function (checker) {
	        return getCheckerDisplay(checker, options);
	      });
	    }
	    type.__apiCheckData = { optional: false, type: 'oneOfType' };
	    return setupChecker(function oneOfTypeCheckerDefinition(val, name, location) {
	      if (!typeCheckers.some(function (checker) {
	        return !isError(checker(val, name, location));
	      })) {
	        return getError(name, location, shortType);
	      }
	    }, { type: type, shortType: shortType }, disabled);
	  }

	  function arrayOfCheckGetter(checker) {
	    var shortCheckerDisplay = getCheckerDisplay(checker, { short: true });
	    var shortType = 'arrayOf[' + shortCheckerDisplay + ']';

	    function type(options) {
	      if (options && options.short) {
	        return shortType;
	      }
	      return getCheckerDisplay(checker, options);
	    }
	    type.__apiCheckData = { optional: false, type: 'arrayOf' };

	    return setupChecker(function arrayOfCheckerDefinition(val, name, location) {
	      if (isError(checkers.array(val)) || !val.every(function (item) {
	        return !isError(checker(item));
	      })) {
	        return getError(name, location, shortType);
	      }
	    }, { type: type, shortType: shortType }, disabled);
	  }

	  function objectOfCheckGetter(checker) {
	    var checkerDisplay = getCheckerDisplay(checker, { short: true });
	    var shortType = 'objectOf[' + checkerDisplay + ']';

	    function type(options) {
	      if (options && options.short) {
	        return shortType;
	      }
	      return getCheckerDisplay(checker, options);
	    }
	    type.__apiCheckData = { optional: false, type: 'objectOf' };

	    return setupChecker(function objectOfCheckerDefinition(val, name, location) {
	      var notObject = checkers.object(val, name, location);
	      if (isError(notObject)) {
	        return notObject;
	      }
	      var allTypesSuccess = each(val, function (item, key) {
	        if (isError(checker(item, key, name))) {
	          return false;
	        }
	      });
	      if (!allTypesSuccess) {
	        return getError(name, location, shortType);
	      }
	    }, { type: type, shortType: shortType }, disabled);
	  }

	  function typeOrArrayOfCheckGetter(checker) {
	    var checkerDisplay = getCheckerDisplay(checker, { short: true });
	    var shortType = 'typeOrArrayOf[' + checkerDisplay + ']';

	    function type(options) {
	      if (options && options.short) {
	        return shortType;
	      }
	      return getCheckerDisplay(checker, options);
	    }

	    type.__apiCheckData = { optional: false, type: 'typeOrArrayOf' };
	    return setupChecker(function typeOrArrayOfDefinition(val, name, location, obj) {
	      if (isError(checkers.oneOfType([checker, checkers.arrayOf(checker)])(val, name, location, obj))) {
	        return getError(name, location, shortType);
	      }
	    }, { type: type, shortType: shortType }, disabled);
	  }

	  function getShapeCheckGetter() {
	    function shapeCheckGetter(shape, nonObject) {
	      var shapeTypes = {};
	      each(shape, function (checker, prop) {
	        shapeTypes[prop] = getCheckerDisplay(checker);
	      });
	      function type() {
	        var options = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];

	        var ret = {};
	        var terse = options.terse;
	        var obj = options.obj;
	        var addHelpers = options.addHelpers;

	        var parentRequired = options.required;
	        each(shape, function (checker, prop) {
	          /* eslint complexity:[2, 6] */
	          var specified = obj && obj.hasOwnProperty(prop);
	          var required = undef(parentRequired) ? !checker.isOptional : parentRequired;
	          if (!terse || (specified || !checker.isOptional)) {
	            ret[prop] = getCheckerDisplay(checker, { terse: terse, obj: obj && obj[prop], required: required, addHelpers: addHelpers });
	          }
	          if (addHelpers) {
	            modifyTypeDisplayToHelpOut(ret, prop, specified, checker, required);
	          }
	        });
	        return ret;

	        function modifyTypeDisplayToHelpOut(theRet, prop, specified, checker, required) {
	          if (!specified && required && !checker.isOptional) {
	            var item = 'ITEM';
	            if (checker.type && checker.type.__apiCheckData) {
	              item = checker.type.__apiCheckData.type.toUpperCase();
	            }
	            addHelper('missing', 'MISSING THIS ' + item, ' <-- YOU ARE MISSING THIS');
	          } else if (specified) {
	            var error = checker(obj[prop], prop, null, obj);
	            if (isError(error)) {
	              addHelper('error', 'THIS IS THE PROBLEM: ' + error.message, ' <-- THIS IS THE PROBLEM: ' + error.message);
	            }
	          }

	          function addHelper(property, objectMessage, stringMessage) {
	            if (typeof theRet[prop] === 'string') {
	              theRet[prop] += stringMessage;
	            } else {
	              theRet[prop].__apiCheckData[property] = objectMessage;
	            }
	          }
	        }
	      }

	      type.__apiCheckData = { strict: false, optional: false, type: 'shape' };
	      var shapeChecker = setupChecker(function shapeCheckerDefinition(val, name, location) {
	        /* eslint complexity:[2, 6] */
	        var isObject = !nonObject && checkers.object(val, name, location);
	        if (isError(isObject)) {
	          return isObject;
	        }
	        var shapePropError = undefined;
	        location = location ? location + (name ? '/' : '') : '';
	        name = name || '';
	        each(shape, function (checker, prop) {
	          if (val.hasOwnProperty(prop) || !checker.isOptional) {
	            shapePropError = checker(val[prop], prop, '' + location + name, val);
	            return !isError(shapePropError);
	          }
	        });
	        if (isError(shapePropError)) {
	          return shapePropError;
	        }
	      }, { type: type, shortType: 'shape' }, disabled);

	      function strictType() {
	        return type.apply(undefined, arguments);
	      }

	      strictType.__apiCheckData = copy(shapeChecker.type.__apiCheckData);
	      strictType.__apiCheckData.strict = true;
	      shapeChecker.strict = setupChecker(function strictShapeCheckerDefinition(val, name, location) {
	        var shapeError = shapeChecker(val, name, location);
	        if (isError(shapeError)) {
	          return shapeError;
	        }
	        var allowedProperties = Object.keys(shape);
	        var extraProps = Object.keys(val).filter(function (prop) {
	          return allowedProperties.indexOf(prop) === -1;
	        });
	        if (extraProps.length) {
	          return new Error(nAtL(name, location) + ' cannot have extra properties: ' + t(extraProps.join('`, `')) + '.' + ('It is limited to ' + t(allowedProperties.join('`, `'))));
	        }
	      }, { type: strictType, shortType: 'strict shape' }, disabled);

	      return shapeChecker;
	    }

	    shapeCheckGetter.ifNot = function ifNot(otherProps, propChecker) {
	      if (!Array.isArray(otherProps)) {
	        otherProps = [otherProps];
	      }
	      var description = undefined;
	      if (otherProps.length === 1) {
	        description = 'specified only if ' + otherProps[0] + ' is not specified';
	      } else {
	        description = 'specified only if none of the following are specified: [' + list(otherProps, ', ', 'and ') + ']';
	      }
	      var shortType = 'ifNot[' + otherProps.join(', ') + ']';
	      var type = getTypeForShapeChild(propChecker, description, shortType);
	      return setupChecker(function ifNotChecker(prop, propName, location, obj) {
	        var propExists = obj && obj.hasOwnProperty(propName);
	        var otherPropsExist = otherProps.some(function (otherProp) {
	          return obj && obj.hasOwnProperty(otherProp);
	        });
	        if (propExists === otherPropsExist) {
	          return getError(propName, location, type);
	        } else if (propExists) {
	          return propChecker(prop, propName, location, obj);
	        }
	      }, { notRequired: true, type: type, shortType: shortType }, disabled);
	    };

	    shapeCheckGetter.onlyIf = function onlyIf(otherProps, propChecker) {
	      otherProps = arrayify(otherProps);
	      var description = undefined;
	      if (otherProps.length === 1) {
	        description = 'specified only if ' + otherProps[0] + ' is also specified';
	      } else {
	        description = 'specified only if all of the following are specified: [' + list(otherProps, ', ', 'and ') + ']';
	      }
	      var shortType = 'onlyIf[' + otherProps.join(', ') + ']';
	      var type = getTypeForShapeChild(propChecker, description, shortType);
	      return setupChecker(function onlyIfCheckerDefinition(prop, propName, location, obj) {
	        var othersPresent = otherProps.every(function (property) {
	          return obj.hasOwnProperty(property);
	        });
	        if (!othersPresent) {
	          return getError(propName, location, type);
	        } else {
	          return propChecker(prop, propName, location, obj);
	        }
	      }, { type: type, shortType: shortType }, disabled);
	    };

	    shapeCheckGetter.requiredIfNot = function shapeRequiredIfNot(otherProps, propChecker) {
	      if (!Array.isArray(otherProps)) {
	        otherProps = [otherProps];
	      }
	      return getRequiredIfNotChecker(false, otherProps, propChecker);
	    };

	    shapeCheckGetter.requiredIfNot.all = function shapeRequiredIfNotAll(otherProps, propChecker) {
	      if (!Array.isArray(otherProps)) {
	        throw new Error('requiredIfNot.all must be passed an array');
	      }
	      return getRequiredIfNotChecker(true, otherProps, propChecker);
	    };

	    function getRequiredIfNotChecker(all, otherProps, propChecker) {
	      var props = t(otherProps.join(', '));
	      var ifProps = 'if ' + (all ? 'all of' : 'at least one of');
	      var description = 'specified ' + ifProps + ' these are not specified: ' + props + ' (otherwise it\'s optional)';
	      var shortType = 'requiredIfNot' + (all ? '.all' : '') + '[' + otherProps.join(', ') + '}]';
	      var type = getTypeForShapeChild(propChecker, description, shortType);
	      return setupChecker(function shapeRequiredIfNotDefinition(prop, propName, location, obj) {
	        var propExists = obj && obj.hasOwnProperty(propName);
	        var iteration = all ? 'every' : 'some';
	        var otherPropsExist = otherProps[iteration](function (otherProp) {
	          return obj && obj.hasOwnProperty(otherProp);
	        });
	        if (!otherPropsExist && !propExists) {
	          return getError(propName, location, type);
	        } else if (propExists) {
	          return propChecker(prop, propName, location, obj);
	        }
	      }, { type: type, notRequired: true }, disabled);
	    }

	    return shapeCheckGetter;

	    function getTypeForShapeChild(propChecker, description, shortType) {
	      function type(options) {
	        if (options && options.short) {
	          return shortType;
	        }
	        return getCheckerDisplay(propChecker);
	      }
	      type.__apiCheckData = { optional: false, type: 'ifNot', description: description };
	      return type;
	    }
	  }

	  function argumentsCheckerGetter() {
	    var type = 'function arguments';
	    return setupChecker(function argsCheckerDefinition(val, name, location) {
	      if (Array.isArray(val) || isError(checkers.object(val)) || isError(checkers.number(val.length))) {
	        return getError(name, location, type);
	      }
	    }, { type: type }, disabled);
	  }

	  function anyCheckGetter() {
	    return setupChecker(function anyCheckerDefinition() {
	      // don't do anything
	    }, { type: 'any' }, disabled);
	  }

	  function nullCheckGetter() {
	    var type = 'null';
	    return setupChecker(function nullChecker(val, name, location) {
	      if (val !== null) {
	        return getError(name, location, type);
	      }
	    }, { type: type }, disabled);
	  }

	  function rangeCheckGetter(min, max) {
	    var type = 'Range (' + min + ' - ' + max + ')';
	    return setupChecker(function rangeChecker(val, name, location) {
	      if (typeof val !== 'number' || val < min || val > max) {
	        return getError(name, location, type);
	      }
	    }, { type: type }, disabled);
	  }

	  function lessThanCheckGetter(min) {
	    var type = 'lessThan[' + min + ']';
	    return setupChecker(function lessThanChecker(val, name, location) {
	      if (typeof val !== 'number' || val > min) {
	        return getError(name, location, type);
	      }
	    }, { type: type }, disabled);
	  }

	  function greaterThanCheckGetter(max) {
	    var type = 'greaterThan[' + max + ']';
	    return setupChecker(function greaterThanChecker(val, name, location) {
	      if (typeof val !== 'number' || val < max) {
	        return getError(name, location, type);
	      }
	    }, { type: type }, disabled);
	  }

	  function emptyObjectCheckGetter() {
	    var type = 'empty object';
	    return setupChecker(function emptyObjectChecker(val, name, location) {
	      if (typeOf(val) !== 'object' || val === null || Object.keys(val).length) {
	        return getError(name, location, type);
	      }
	    }, { type: type }, disabled);
	  }
	}

/***/ }
/******/ ])
});
;