docs: function matchQueryPart(obj, queryKey, queryValue, treatObjAsValue) {
    var objValue = getDotValue(obj, queryKey),
      i,
      keys,
      firstChars,
      dollarFirstChars;
  
    // Check if the value is an array if we don't force a treatment as value
    if (util.isArray(objValue) && !treatObjAsValue) {
      // If the queryValue is an array, try to perform an exact match
      if (util.isArray(queryValue)) {
        return matchQueryPart(obj, queryKey, queryValue, true);
      }
  
      // Check if we are using an array-specific comparison function
      if (queryValue !== null && typeof queryValue === 'object' && !util.isRegExp(queryValue)) {
        keys = Object.keys(queryValue);
        for (i = 0; i < keys.length; i += 1) {
          if (arrayComparisonFunctions[keys[i]]) {
            return matchQueryPart(obj, queryKey, queryValue, true);
          }
        }
      }
  
      // If not, treat it as an array of { obj, query } where there needs to be at least one match
      for (i = 0; i < objValue.length; i += 1) {
        if (matchQueryPart({ k: objValue[i] }, 'k', queryValue)) {
          return true;
        } // k here could be any string
      }
      return false;
    }
  
    // queryValue is an actual object. Determine whether it contains comparison operators
    // or only normal fields. Mixed objects are not allowed
    if (
      queryValue !== null &&
      typeof queryValue === 'object' &&
      !util.isRegExp(queryValue) &&
      !util.isArray(queryValue)
    ) {
      keys = Object.keys(queryValue);
      firstChars = _.map(keys, function(item) {
        return item[0];
      });
      dollarFirstChars = _.filter(firstChars, function(c) {
        return c === '$';
      });
  
      if (dollarFirstChars.length !== 0 && dollarFirstChars.length !== firstChars.length) {
        throw new Error('You cannot mix operators and normal fields');
      }
  
      // queryValue is an object of this form: { $comparisonOperator1: value1, ... }
      if (dollarFirstChars.length > 0) {
        for (i = 0; i < keys.length; i += 1) {
          if (!comparisonFunctions[keys[i]]) {
            throw new Error('Unknown comparison function ' + keys[i]);
          }
  
          if (!comparisonFunctions[keys[i]](objValue, queryValue[keys[i]])) {
            return false;
          }
        }
        return true;
      }
    }
  
    // Using regular expressions with basic querying
    if (util.isRegExp(queryValue)) {
      return comparisonFunctions.$regex(objValue, queryValue);
    }
  
    // queryValue is either a native value or a normal object
    // Basic matching is possible
    if (!areThingsEqual(objValue, queryValue)) {
      return false;
    }
  
    return true;
  }