Recursively traverses `obj` and returns all the elements for which a truth test fails.
424983
function(obj, strategy, visitor, context) {
      return this.filter(obj, strategy, function(value, key, parent) {
        return !visitor.call(context, value, key, parent);
      });
    }
956306
function checkFallback(obj) {
      var props = [];
      var hasFallback = [];
      var values = [];

      for (var prop in obj) {
        if (obj.hasOwnProperty(prop)) {
          var pro = obj[prop].prop;

          if (obj[prop].type === 'comment') {
            continue;
          }

          if (props.indexOf(pro) === -1) {
            props.push(pro);
            values.push({prop: pro, val:obj[prop].value});
          } else {
            var lookup = {};

            for (var i = 0, len = values.length; i < len; i++) {
              lookup[values[i].prop] = values[i].val;
            }

            if (lookup[pro].search('px') === -1 && obj[prop].value.search('rem') === -1 ||
            lookup[pro].search('rem') === -1 && obj[prop].value.search('px') === -1) {
              hasFallback.push(pro);
            }
          }
        }
      }

      return hasFallback;
    }
652720
def matches(self):
        
        def ret(obj, *args):
            if self.obj is obj:
                return True  # avoid comparing an object to itself.

            for key in self.obj:
                if self.obj[key] != obj[key]:
                    return False

            return True

        return self._wrap(ret)
709972
def resolve_deps(self, obj):
        '''
        
        '''
        deps = self.get_deps(obj)
        return list(self.iresolve(*deps))
977814
function contains(ast, fn, descendOn) {
        if (!ast) 
            return null;
        if (fn && typeof fn === 'object') {
            var keys = Object.keys(fn);
            return contains(ast, function (node) {
                return keys.every(function (k) {
                    return node[k] == fn[k];
                });
            });
        }
        var n, found = {};
        if (Array.isArray(ast)) {
            for (var i = 0;i < ast.length; i++) 
                if (n = contains(ast[i], fn)) 
                return n;
            return null;
        }
        var subScopes = descendOn;
        if (typeof descendOn !== "function") {
            if (descendOn) {
                subScopes = function (n) {
                    return true;
                };
            } else {
                subScopes = function (n) {
                    return !examine(n).isScope;
                };
            }
        }
        try {
            treeWalk(ast, function (node, descend, path) {
                if (fn(node)) {
                    found.path = path;
                    throw found;
                }
                if (node === ast || subScopes(node)) 
                    descend();
            });
        } catch (ex) {
            if (ex === found) 
                return found.path;
            throw ex;
        }
        return null;
    }
501598
def is_null_slice(obj):
    
    return (isinstance(obj, slice) and obj.start is None and
            obj.stop is None and obj.step is None)
1042190
function getIterableObjectEntries(obj) {

  let index = 0;
  const propKeys = Reflect.ownKeys(obj);

  return {
    [Symbol.iterator]() {
      return this;
    },
    next() {

      if (index < propKeys.length) {

        const key = propKeys[index];

        index += 1;
        return {"value": [key, obj[key]]};
      }

      return {"done": true};
    }
  };
}
745374
function failures (items) {
      var fs = [], i, v;
      for (i = 0; i < items.length; i += 1) {
          v = items[i];
          if (!v.passed_) {
              fs.push(v);
          }
      }
      return fs;
  }
404023
def all_inspections(obj):
    

    for name, callback in INSPECTIONS:
        result = callback(obj)
        if result:
            yield name, result
170694
private static boolean contains(Object[] arr, Object obj) {
	for (Object o : arr) {
	    if (o.equals(obj)) return true;
	}
	return false;
    }
316328
function (obj, keys) {
  return _.all(obj, function (v, k) {
    return _.contains(keys, k);
  });
}
540552
def find_all_checks(self, **kwargs):
        
        found = []
        searches = kwargs.items()
        for obj in self.list():
            try:
                if all(getattr(obj, attr) == value
                        for (attr, value) in searches):
                    found.append(obj)
            except AttributeError:
                continue
        return found
108883
function _getPathInfo (obj, parts, walkNonEnumerables) {
    if (isNil(obj)) {
        throw _makeTypeErrorFor(obj, "object");
    }

    var target = obj;
    var i = -1;
    var len = parts.length;
    var key;

    while (++i < len) {
        key = _getPathKey(target, parts[i], walkNonEnumerables);

        if (isUndefined(key)) {
            break;
        }

        target = target[key];
    }

    return i === len ? { isValid: true, target: target } : { isValid: false, target: void 0 };
}
581803
function objectIsEmpty(obj) {
	if (obj === null || obj === undefined) return true;
	if (obj.isEmpty) return obj.isEmpty();
	for (let k in obj) {
		if (hasOwnProperty(obj, k)) return false;
	}
	return true;
}
401931
def values(obj, glob, separator="/", afilter=None, dirs=True):
    
    return [x[1] for x in dpath.util.search(obj, glob, yielded=True, separator=separator, afilter=afilter, dirs=dirs)]
317288
function findAll(predicate) {
        var key,
            elem,
            result = [];
        for (key in _idMap) {
            if (_idMap.hasOwnProperty(key)) {
                elem = _idMap[key];
                if (predicate(elem)) {
                    result.push(elem);
                }
            }
        }
        return result;
    }
806819
function traverse(util, searchTerm, options) {
      options = options || {};
      var obj = options.obj || window;
      var path = options.path || ((obj == window) ? 'window' : '');
      var props = Object.keys(obj);
      props.forEach(function(prop) {
        if ((tests[util] || util)(searchTerm, obj, prop)) {
          console.log([path, '.', prop].join(''), '->', ['(', typeof obj[prop], ')'].join(''), obj[prop]);
        }
        if (Object.prototype.toString.call(obj[prop]) == '[object Object]' && (obj[prop] != obj) && path.split('.').indexOf(prop) == -1) {
          traverse(util, searchTerm, {obj: obj[prop], path: [path,prop].join('.')});
        }
      });
    }