Check whether object's property could be overridden
@param   { Object }  obj - source object
@param   { String }  key - object property
@returns { Boolean } -
18087
function isWritable(obj, key) {
  var descriptor = Object.getOwnPropertyDescriptor(obj, key);
  return isUndefined(obj[key]) || descriptor && descriptor.writable
}
964733
function notDefined(obj, key) {
  return obj[key] === undefined
    && obj.__lookupGetter__(key) === undefined
    && obj.__lookupSetter__(key) === undefined;
}
1136846
function overwrite(obj, defaults) {
  var res = {};
  var dFlat = collapse(defaults);
  var oFlat = collapse(obj);
  for (var key in dFlat) {
    val(res, key, dFlat[key]);
  }
  for (var key in oFlat) {
    val(res, key, oFlat[key]);
  }
  return res;
}
85344
function isSafeProperty (object, prop) {
  if (!object || typeof object !== 'object') {
    return false
  }
  // SAFE: whitelisted
  // e.g length
  if (hasOwnProperty(safeNativeProperties, prop)) {
    return true
  }
  // UNSAFE: inherited from Object prototype
  // e.g constructor
  if (prop in Object.prototype) {
    // 'in' is used instead of hasOwnProperty for nodejs v0.10
    // which is inconsistent on root prototypes. It is safe
    // here because Object.prototype is a root object
    return false
  }
  // UNSAFE: inherited from Function prototype
  // e.g call, apply
  if (prop in Function.prototype) {
    // 'in' is used instead of hasOwnProperty for nodejs v0.10
    // which is inconsistent on root prototypes. It is safe
    // here because Function.prototype is a root object
    return false
  }
  return true
}
842110
function(obj, env, keypath) {
    if (!_.isObject(obj) || _.isArray(obj)) { return; }

    if (hasKeyPath(obj, ['options', 'reconfigureOverrides', env])) {
      var options = obj.options,
          overrides = obj.options.reconfigureOverrides[env];

      for (var key in overrides) {
        var update = { 
          key: keypath+'.options.'+key,
          oldVal: (typeof options[key] === 'undefined') ? 'undefined' : util.inspect(options[key]),
        };

        if (_.isObject(options[key]) && _.isObject(overrides[key])) { 
          var newVal = _.extend(options[key], overrides[key]);
          update.newVal = util.inspect(newVal);
        } else {
          options[key] = overrides[key];
          update.newVal = util.inspect(overrides[key]);
        }

        updates.push(update);
      }
    }
    
    for (var objKey in obj) {
      updateOptions(obj[objKey], env, keypath+'.'+objKey);
    }
  }
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;
	}
252370
function (obj) {
        return Boolean(obj) && ((obj instanceof ProxyConfig) ||
            _.inSuperChain(obj.constructor, '_postman_propertyName', ProxyConfig._postman_propertyName));
    }
1322324
function invertObject(obj, override) {
  if (!obj || typeof obj !== 'object') {
    throw new TypeError('First argument must be an object');
  }

  var key;
  var value;
  var isOverridePresent = typeof override === 'function';
  var overrides = {};
  var result = {};

  for (key in obj) {
    value = obj[key];

    if (isOverridePresent) {
      overrides = override(key, value);
      if (overrides && overrides.length === 2) {
        result[overrides[0]] = overrides[1];
        continue;
      }
    }

    if (typeof value === 'string') {
      result[value] = key;
    }
  }

  return result;
}
675352
function (obj, key, value) {
        return obj ? ((obj[key] === value) || _.inSuperChain(obj.super_, key, value)) : false;
    }
1099425
function (obj) {
        return Boolean(obj) && ((obj instanceof Request) ||
            _.inSuperChain(obj.constructor, '_postman_propertyName', Request._postman_propertyName));
    }
156580
function del(obj, key, immutable) {
    if (immutable)
        return _del(assign({}, obj), key);
    return _del(obj, key);
}
534672
function(obj) {
		var prop;

		if (!obj || typeOf(obj) !== 'object') {
			return true;
		}

		for (prop in obj) {
			return false;
		}

		return true;
	}
126775
function hasKeys(obj) {
		return (!Array.isArray(obj) && _.isObject(obj) && _.keys(obj).length > 0);
	}
999854
function object2array(obj, key) {
    if (typeof obj != "object") {
        return false;
    }
    if (key && typeof key != "string") {
        return false;
    }

    var arr = [];
    var index;
    if (key) {
        for (index in obj) {
            if (obj.hasOwnProperty(index)) {
                obj[index][key] = index;
                arr.push(obj[index]);
            }
        }
    } else {
        for (index in obj) {
            if (obj.hasOwnProperty(index)) {
                arr.push(obj[index]);
            }
        }
    }

    return arr;
}
526424
function (obj) {
      var inverted = {};
      for (var key in obj) {
        if (obj.hasOwnProperty(key)) {
          inverted[obj[key]] = key;
        }
      }
      return inverted;
    }
677486
function hasKey (obj, keys) {
    let o = obj;
    keys.slice(0,-1).forEach(function (key) {
        o = (o[key] || {});
    });

    let key = keys[keys.length - 1];
    return key in o;
}
796779
function(obj, propName, message) {	
	assert(typeof(propName) === 'string');
	if ( ! message) message = "Using this property indicates old/broken code.";
	// already blocked?	
	bphush = true;
	try {
		let v = obj[propName];
	} catch (err) {
		return obj;
	}
	bphush = false;
	if (obj[propName] !== undefined) {
		// already set to a value :(
		const ex = new Error("Having "+propName+" is blocked! "+message);
		if ( ! bphush) console.error(ex, this); // react can swallow stuff
		throw ex;
	}
	if ( ! Object.isExtensible(obj)) {	
		// no need -- frozen or sealed	
		return;
	}
	Object.defineProperty(obj, propName, { 
		get: function () { 
			const ex = new Error(propName+" is blocked! "+message); 
			if ( ! bphush) console.error(ex, this); // react can swallow stuff
			throw ex;					
		},
		set: function () { 
			const ex = new Error("Set "+propName+" is blocked! "+message);
			if ( ! bphush) console.error(ex, this); // react can swallow stuff
			throw ex;		
		} 
	});
	return obj;
}