/*
upcase(input)

convert a input string to UPCASE
972464
@Override
    public Object apply(Object value, Object... params) {

        return super.asString(value).toUpperCase();
    }
264017
function dashProperCase(str) {
        if ( !str.length ) {
            return str;
        }
        return str.split('-').map(function (piece) {
            if ( piece.length ) {
                return piece.substring(0, 1).toUpperCase() + piece.substring(1);
            }
            return piece;
        }).join('-');
    }
747890
function camelCase(input) {
  let str = input.toLowerCase().replace(/-(.)/g, function (match, group1) {
    return group1.toUpperCase();
  });

  str = str.replace(/_(.)/g, function (match, group1) {
    return group1.toUpperCase();
  });
  return str
}
1150220
function capitalize(val) {
    if (!is_1.isValue(val))
        return null;
    val = val.toLowerCase();
    return "" + val.charAt(0).toUpperCase() + val.slice(1);
}
562533
String convertCase(String s, String sample, Language lang) {
    return CaseConversionHelper.convertCase(match.getCaseConversionType(), s, sample, lang);
  }
814111
static String convertToSnakeCase(final String string) {
        final StringBuilder builder = new StringBuilder();
        boolean isPrevCharLowerCase = false;
        for (int index = 0; index < string.length(); index++) {
            final char character = string.charAt(index);
            if (character == ' ') {
                builder.append("_");
            } else if (Character.isUpperCase(character) && isPrevCharLowerCase) {
                builder.append("_").append(Character.toLowerCase(character));
            } else {
                builder.append(Character.toLowerCase(character));
            }
            isPrevCharLowerCase = Character.isLowerCase(character);
        }
        return builder.toString();
    }
1365623
function upper (value) {
  if (value === null || value === undefined) {
    return value
  }
  return String.prototype.toUpperCase.call(value)
}
146471
public static function toCase($string, $case)
    {
        switch ($case) {
            case self::UPPER:
                $string = mb_strtoupper($string);
                break;
            case self::LOWER:
                $string = mb_strtolower($string);
                break;
            case self::UPPER_FIRST:
                $string = mb_strtoupper(mb_substr($string, 0, 1)) . mb_substr($string, 1);
                break;
            case self::UPPER_WORDS:
                $string = mb_convert_case($string, MB_CASE_TITLE);
                break;
            case self::NONE:
                break;
            default:
                throw new InvalidArgumentException("Cannot set case {$case}");
        }

        return $string;
    }
130229
def _to_camelcase(input_string):
    ''' '''
    camel_string = ''
    for i in range(len(input_string)):
        if input_string[i] == '_':
            pass
        elif not camel_string:
            camel_string += input_string[i].upper()
        elif input_string[i-1] == '_':
            camel_string += input_string[i].upper()
        else:
            camel_string += input_string[i]
    return camel_string
928452
function transferCase(source, target) {
  let cased = '';

  for (let i = 0, l = target.length; i < l; i++) {
    const c = source[i].toLowerCase() === source[i] ?
      'toLowerCase' :
      'toUpperCase';

    cased += target[i][c]();
  }

  return cased;
}
792696
function uppercaseFirstLetter(options) {
  const string = options.fn(this);
  return string.charAt(0).toUpperCase() + string.slice(1);
}
834925
def upcaseTokens(s,l,t):
    """"""
    return [ tt.upper() for tt in map(_ustr,t) ]
420208
public static boolean isOnlyUpperCase(String string) {
        boolean result = isNotEmpty(string);
        int idx = 0;
        int len = string.length();
        while (result) {
            if (idx >= len) {
                break;
            }
            result = isUpperCase(string.charAt(idx));
            idx++;
        }
        return result;
    }
350787
public static boolean isUniCase(String value) {
        if (value.toLowerCase().equals(value) || value.toUpperCase().equals(value)) {
            return true;
        }
        return false;
    }
658997
String convertCase(String str) {
        if (str == null) {
            return null;
        }
        return sensitive ? str : str.toLowerCase();
    }
1039801
function stringToCamelCase (str) {
  return str.toLowerCase().replace(rCamel, function (match, group1) {
    return group1.toUpperCase()
  })
}
779609
function camelcase(str) {
  if (!/[\s\W]/.test(str)) return str;
  if (str.length === 1) {
    return str.toLowerCase();
  }
  str = str.replace(/^[\W_]+|[\W_]+$/g, '').toLowerCase();
  return str.replace(/[\W_]+(\w|$)/g, function(_, ch) {
    return ch.toUpperCase();
  });
}