code: function autobind(obj, prop, descriptor) {
    if (arguments.length === 1) return autobindClass()(obj);
  
    var _ref = descriptor || {},
        fn = _ref.value,
        configurable = _ref.configurable;
  
    if (!isFunction(fn)) {
      throw new TypeError('@autobind can only be used on functions, not "' + fn + '" in ' + (typeof fn === 'undefined' ? 'undefined' : _typeof(fn)) + ' on property "' + prop + '"');
    }
    var constructor = obj.constructor;
  
    return {
      configurable: configurable,
      enumerable: false,
      get: function get() {
        var _this = this;
  
        var boundFn = function boundFn() {
          for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
            args[_key] = arguments[_key];
          }
  
          return fn.call.apply(fn, [_this].concat(_toConsumableArray(args)));
        };
        // Someone accesses the property directly on the prototype on which it is
        // actually defined on, i.e. Class.prototype.hasOwnProperty(key)
        if (this === obj) {
          return fn;
        }
        // Someone accesses the property directly on a prototype,
        // but it was found up the chain, not defined directly on it
        // i.e. Class.prototype.hasOwnProperty(key) == false && key in Class.prototype
        if (this.constructor !== constructor && _Object$getPrototypeOf(this).constructor === constructor) {
          return fn;
        }
  
        // Autobound method calling super.sameMethod() which is also autobound and so on.
        if (this.constructor !== constructor && prop in this.constructor.prototype) {
          return getBoundSuper(this, fn);
        }
        _Object$defineProperty(this, prop, {
          configurable: true,
          writable: true,
          // NOT enumerable when it's a bound method
          enumerable: false,
          value: boundFn
        });
  
        return boundFn;
      },
  
      set: createDefaultSetter(prop)
    };
  }
docs: auto bind the function on the class, just support function
  @param {Object} obj Target Object
  @param {string} prop prop strong
  @param {Object} descriptor