code: function check (expected, control) {
    /**
     * > Type checking which throws AssertionError
     * if `value` not match to wanted type.
     *
     * **Example**
     *
     * ```js
     * var is = require('assert-kindof')
     *
     * is.object(123) // => AssertionError: number !== object
     * is.object(null) // => AssertionError: null !== object
     *
     * is.object({ foo: 'bar' }) // => nothing
     *
     * is.date('foo') // => AssertionError: string !== date
     * is.date(new Date()) // => nothing
     * ```
     *
     * @param  {Any} `value` value to be checked
     * @param  {String|Function} `message` if function, called with `fn(actual, expected, value)` signature
     */
  
    return function assertIs (value, message) {
      var actual = utils.kindOf(value)
      var result = utils.is[expected](value)
      var operator = control === false ? '===' : '!=='
  
      if (utils.kindOf(message) === 'function') {
        message = message(actual, expected, value)
      }
  
      message = utils.kindOf(message) === 'string'
        ? utils.format(message, { expected: expected, actual: actual })
        : actual + ' ' + operator + ' ' + expected
  
      test(result === control, {
        value: value,
        actual: actual,
        expected: expected,
        operator: operator,
        message: message,
        stackStartFunction: assertIs
      })
    }
  }
docs: > Creates exported methods. Such as `assert.strictEqual`, in
  the context of `assert-kindof` it is like `is.object(val)`,
  `is.number(val)`, `is.null(val)` or negative `is.not.null(val)` and
  etc.
  
  @param  {String} `type` type of the given value
  @param  {Boolean} `control` is normal or `is.not.object` for example
  @return {Function} `fn` actual exported method to check type of some value
  @api private