/// Function emptyp //////////////////////////////////////////////////////  (obj:Obj) ↦ Bool  Checks if an object has any own properties.
181807
function emptyp(obj) { var key
        for (key in obj)
            if (hasp(obj, key)) return false

        return true
    }
493733
function emptyObject(o, {keep}) {
  keep = keep || {};
  for (let pair of objectPairs(o)) {
    let [k, v] = pair;
    var ctor = v && v.constructor;
    if (keep && ctor === Object) emptyObject(v);
    else o[k] = ctor && ctor();
  }
}
813258
function cleanDeep(object) {
  var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
      _ref$emptyArrays = _ref.emptyArrays,
      emptyArrays = _ref$emptyArrays === undefined ? true : _ref$emptyArrays,
      _ref$emptyObjects = _ref.emptyObjects,
      emptyObjects = _ref$emptyObjects === undefined ? true : _ref$emptyObjects,
      _ref$emptyStrings = _ref.emptyStrings,
      emptyStrings = _ref$emptyStrings === undefined ? true : _ref$emptyStrings,
      _ref$nullValues = _ref.nullValues,
      nullValues = _ref$nullValues === undefined ? true : _ref$nullValues,
      _ref$undefinedValues = _ref.undefinedValues,
      undefinedValues = _ref$undefinedValues === undefined ? true : _ref$undefinedValues;

  return (0, _lodash6.default)(object, function (result, value, key) {
    // Recurse into arrays and objects.
    if (Array.isArray(value) || (0, _lodash4.default)(value)) {
      value = cleanDeep(value, { emptyArrays: emptyArrays, emptyObjects: emptyObjects, emptyStrings: emptyStrings, nullValues: nullValues, undefinedValues: undefinedValues });
    }

    // Exclude empty objects.
    if (emptyObjects && (0, _lodash4.default)(value) && (0, _lodash2.default)(value)) {
      return;
    }

    // Exclude empty arrays.
    if (emptyArrays && Array.isArray(value) && !value.length) {
      return;
    }

    // Exclude empty strings.
    if (emptyStrings && value === '') {
      return;
    }

    // Exclude null values.
    if (nullValues && value === null) {
      return;
    }

    // Exclude undefined values.
    if (undefinedValues && value === undefined) {
      return;
    }

    // Append when recursing arrays.
    if (Array.isArray(result)) {
      return result.push(value);
    }

    result[key] = value;
  });
}
338479
public static function emptyValues($obj)
    {
        if (is_array($obj)) {
            $values = $obj;
        } elseif ($obj instanceof StripeObject) {
            $values = $obj->_values;
        } else {
            throw new \InvalidArgumentException(
                "empty_values got got unexpected object type: " . get_class($obj)
            );
        }
        $update = array_fill_keys(array_keys($values), "");
        return $update;
    }
1093971
function deletePropertyAt(object, prop) {
		if (object == null) { return object; }
		var value = object[prop];
		delete object[prop];
		return value;
	}
1007318
function clean(obj) {
  var ret = {};

  // Remove traits/properties that are already represented
  // outside of the data container
  // TODO: Refactor into `omit` call
  var excludeKeys = ['id', 'name', 'firstName', 'lastName'];
  each(excludeKeys, function(omitKey) {
    clear(obj, omitKey);
  });

  // Flatten nested hierarchy, preserving arrays
  obj = flatten(obj);

  // Discard nulls, represent arrays as comma-separated strings
  // FIXME: This also discards `undefined`s. Is that OK?
  for (var key in obj) {
    if (has.call(obj, key)) {
      var val = obj[key];
      if (val == null) {
        continue;
      }

      if (is.array(val)) {
        ret[key] = val.toString();
        continue;
      }

      ret[key] = val;
    }
  }

  return ret;
}
90981
function empty (args) {
    // make sure args is object
    args = requireValidOptionalObject(args)
    // to empty object data must be set to null
    args.data = null
    // use update method to empty
    return this.updateMeta(args)
}
577429
function exclude (object, excludedProperties) {
  const strippedObject = Object.assign({}, object)

  excludedProperties.forEach(excludedProperty => {
    delete strippedObject[excludedProperty]
  })

  return strippedObject
}
1332715
function cleanObjectStrings (obj) {
  let cleanObj = {};
  for (let field in obj) {
    if (obj.hasOwnProperty(field)) {
      cleanObj[cleanString(field, true)] = ('' + obj[field]).trim();
    }
  }
  return cleanObj;
}
500643
def empty_values(obj)
      values = case obj
               when Hash         then obj
               when StripeObject then obj.instance_variable_get(:@values)
               else
                 raise ArgumentError, "#empty_values got unexpected object type: #{obj.class.name}"
               end

      values.each_with_object({}) do |(k, _), update|
        update[k] = ""
      end
    end
214839
function withProperties(validatedObject, validatedProperties) {
  notNil(validatedObject);

  const undefinedProperties = _.filter(validatedProperties, function(property) {
    return !validatedObject.hasOwnProperty(property);
  });

  if (!_.isEmpty(undefinedProperties)) {
    throw new ValidationError("Validated object doesn't have properties: " + undefinedProperties);
  }
  return validatedObject;
}
443417
function isEmpty(x) {
    if (!x) {
      // if '', 0, `null`, `undefined`, `NaN`, or `false` then is empty
      return true;
    }

    if (isNumber(x) || isFunction(x)) {
      return false;
    }

    if (isArray(x)) {
      // takes care of 'instances of Array'
      return !x.length;
    }

    if (x.size !== undefined && !(0, _object.instanceOf)(Function, x.size)) {
      return !x.size;
    }

    if (isObject(x)) {
      return !(0, _object.keys)(x).length;
    }

    return false;
  }
530912
function _blank(obj) {
        var cache;

        if((cache = typeof obj) !== 'boolean' && (cache !== 'number' || isNaN(obj)) && !obj) return true;
        if(cache == 'string' && obj.replace(/\s/g, '').length === 0) return true;
        if(cache == 'object') {
          if((cache = toString.call(obj)) == '[object Array]' && obj.length === 0) return true;
          if(cache == '[object Object]') {
            for(cache in obj) {
              return false;
            }
            return true;
          }
        }
        return false;
      }
171610
function trimStringProperties (obj) {

    if (obj !== null && typeof obj === 'object') {

        for ( var prop in obj ) {

            // if the property is an object trim it too
            if ( typeof obj[prop] === 'object' ) {
                return trimStringProperties(obj[prop]);
            } 
            
            // if it's a string remove begin and end whitespaces
            if ( typeof obj[prop] === 'string' ) {
                obj[prop] = obj[prop].trim();
            }

        }

    }

}
428863
function clearOwnProperties(obj) {
  _.forOwn(obj, function (value, key) {
    delete obj[key];
  });

  return obj;
}
68152
function isPlainObject(obj) {
    return (
        typeof obj === 'object' &&
        obj !== null &&
        obj.constructor === Object &&
        Object.prototype.toString.call(obj) === '[object Object]'
    );
}
1030234
function isEmpty(obj) {
    var empty = false;

    if (isFalsy(obj)) {
        empty = true;
    } else if (isArray(obj)) {
        empty = obj.length === 0;
    } else if (isObject(obj)) {
        empty = Object.keys(obj).length === 0;
    }

    return empty;
}