code: function only (o, types) {
                      types = libs.object.toArray(arguments);
                      types.shift();
  
                      // Allows the 'plural' form of the type...
                      libs.object.each(types, function (type, key) { this[key] = type.replace(/s$/, ''); });
  
                      if(typeof o !== 'object' || !o) return o;
                      var isArray  = o instanceof Array ? true : false,
                          filtered = isArray ? [] : {},
                          typeArr  = types.indexOf('array'),
                          typeObj  = types.indexOf('object object');
  
                      libs.object.each(o, function (item, key) {
                          var typeItem = types.indexOf(typeof item);
  
                          if(typeObj !== -1 && typeArr === -1) {
                              if((typeof item === 'object' && !(item instanceof Array)) || (typeof item !== 'object' && typeItem !== -1)) {
                                  if(isArray) filtered.push(item); else filtered[key] = item;
                              }
                          }
                          else if(typeObj !== -1 && typeArr !== -1) {
                              types.push('object');
                              if(typeItem !== -1) {
                                  if(isArray) filtered.push(item); else filtered[key] = item;
                              }
                          }
                          else if(typeItem !== -1 || (item instanceof Array && typeArr !== -1)) {
                              if(isArray) filtered.push(item); else filtered[key] = item;
                          }
                      });
                      return filtered;
                  }
docs: Filters an array or object using only the types allowed. That is, if the item in the array is of a type listed
  in the arguments, then it will be added to the filtered array. In this case 'array' is a valid type.
  @param {Object} o The object to operate on.
  @param {...String} types A list of typeof types that are allowed in the array.
  @return {Array<*>} An array filtered by only the allowed types.