check obj[key] if not defiend
@param {Object} obj
@param {String} key
@return {Boolean}
964733
function notDefined(obj, key) {
  return obj[key] === undefined
    && obj.__lookupGetter__(key) === undefined
    && obj.__lookupSetter__(key) === undefined;
}
1111626
function (key, obj) {
        'use strict';
        var keysArr = key.split('.'),
            lastKeyPart = keysArr.pop(),
            len = keysArr.length,
            i, k, objNext;
        for (i = 0; i < len; i += 1) {
            k = keysArr[i];
            objNext = obj[k];
            if (!isObj(objNext)) {
                objNext = obj[k] = {};
            }
            obj = objNext;
        }
        return {
            node: obj,
            key: lastKeyPart
        };
    }
45163
function objectForKey(object, key, primitives){
  var proto = primitives.getPrototypeOf(object)
  if (!proto || hasOwnProperty(object, key)){
    return object
  } else {
    return objectForKey(proto, key, primitives)
  }
}
363987
function(obj) {
		return Object.keys(obj).every(function(key) {
			var is = false;
			switch (key) {
				case "getter":
				case "setter":
					is = gui.Type.isFunction(obj[key]);
					break;
			}
			return is;
		});
	}
651030
function (key) {
            var self = this, _queryMap;
            parseQuery(self);
            _queryMap = self._queryMap;
            if (key) {
                return key in _queryMap;
            } else {
                return !S.isEmptyObject(_queryMap);
            }
        }
160641
function(obj) {
			var result = {};
			var keys = this.toArray(arguments, 1);
			Object.keys(obj).forEach(function(key) {
				if (~keys.indexOf(key)) {
					result[key] = obj[key];
				}
			});
			return result;
		}
630265
function(obj, fn) {
      var _keys, filtered;
      filtered = objelity.filterObject(obj, fn);
      _keys = objelity.deepKeys(filtered);
      if (_keys.length <= 0) {
        return {};
      } else {
        return _.get(filtered, _keys[0]);
      }
    }
154133
function obj(/*key,value, key,value ...*/) {
    var result = {}
    for(var n=0; n<arguments.length; n+=2) {
        result[arguments[n]] = arguments[n+1]
    }
    return result
}
25795
function(obj, parts) {
    if (parts.length === 0) { return true; }
    
    var key = parts.shift();

    if (!_(obj).has(key)) {
      return false;
    } else {
      return hasKeyPath(obj[key], parts);
    }
  }
798486
function isGetSet(obj) {
        var keys, length;
        if (obj && typeof obj === 'object') {
            keys = Object.getOwnPropertyNames(obj)
                .sort();
            length = keys.length;

            if ((length === 1 && (keys[0] === 'get' && typeof obj.get ===
                    'function' ||
                    keys[0] === 'set' && typeof obj.set === 'function'
                )) ||
                (length === 2 && (keys[0] === 'get' && typeof obj.get ===
                    'function' &&
                    keys[1] === 'set' && typeof obj.set === 'function'
                ))) {
                return true;
            }
        }
        return false;
    }
1068558
function isEmpty(obj) {
  for (var key in obj) if (__own.call(obj, key)) {
    return false;
  }
  return true;
}
513907
function(key) {
			var idx;
			do {
				idx = this.contents.indexOf(key, idx);
			} while(idx !== -1 && !isEven(idx));
			return idx;
		}
1058842
function _eachObj(obj, callback, scope, own) {
  let key, isOwn

  scope = scope || obj
  for (key in obj) {
    isOwn = hasOwnProp(obj, key)
    if (own === false || isOwn) {
      if (callback.call(scope, obj[key], key, obj, isOwn) === false)
        return false
    }
  }
  return true
}
926915
function hasPath (obj, ks) {
      ks = typeof ks == "string" ? keysFromPath(ks) : ks;

      var i = -1, length = ks.length;
      while (++i < length && _.isObject(obj)) {
        if (ks[i] in obj) {
          obj = obj[ks[i]];
        } else {
          return false;
        }
      }
      return i === length;
    }
87281
function(obj, extObj) {
        this.each(extObj, function(value, key) {
            if (extObj.hasOwnProperty(key)) obj[key] = value
        })
        return obj
    }
303127
function(obj) {
		if (arguments.length < 2) throw new Error('cannot call _.get() without specifying at least one key');

		for (var i = 1; i < arguments.length; i++) {
			if (obj === undefined || obj === null) return;

			obj = obj[arguments[i]];
		}

		return obj;
	}
921643
function hasEmptyProperty(obj) {
  return Object.keys(obj)
    .map(key => obj[key])
    .every(
      keyObject =>
        typeof keyObject === 'object' &&
        Object.keys(keyObject).every(key => !(key in keyObject))
    );
}