Check whether the character is a vowel letter.
422113
def is_vowel(char):
	
	if is_letter(char, strict=True):
		return char in chart.vowels

	return False
145912
function maybeIdentifier(key) {
        var result = false,
            i;

        for (i = 0; i < key.length; i++) {
            result = Acorn.isIdentifierChar(key.charCodeAt(i));
            if (!result) {
                break;
            }
        }

        return result;
    }
1080907
def _is_punctuation(char):
    """"""
    cp = ord(char)
    # We treat all non-letter/number ASCII as punctuation.
    # Characters such as "^", "$", and "`" are not in the Unicode
    # Punctuation class but we treat them as punctuation anyways, for
    # consistency.
    if ((cp >= 33 and cp <= 47) or (cp >= 58 and cp <= 64) or
            (cp >= 91 and cp <= 96) or (cp >= 123 and cp <= 126)):
        return True
    cat = unicodedata.category(char)
    if cat.startswith("P"):
        return True
    return False
79067
def _cons(self, word, i):
        """"""
        if word[i] in self.vowels:
            return False
        if word[i] == 'y':
            if i == 0:
                return True
            else:
                return (not self._cons(word, i - 1))
        return True
156525
private static boolean isStopChar(String word){
        if(word.length() == 1){
            char _char = word.charAt(0);
            if(_char < 48){
                return true;
            }
            if(_char > 57 && _char < 19968){
                return true;
            }
            if(_char > 40869){
                return true;
            }
        }
        return false;
    }
273975
def vowel_in_stem(self):
        
        for i in range(0, self.j+1):
            if not self.cons(i):
                return True
        return False
1256661
private static boolean isSafeFilenameCharacter(char c)
	{
		if (Character.isLetterOrDigit(c))
		{
			return true;
		}
		else if (c == '-' || c == '_' || c == '.')
		{
			return true;
		}
		else
		{
			return false;
		}
	}
745150
private boolean isWord(String token) {
    if (token.length() == 1) {
      char c = token.charAt(0);
      if (!Character.isLetter(c)) {
        return false;
      }
    }
    return true;
  }
552145
static boolean hasFunkyChars(String s) {
        int length = s.length();

        if (length == 0)
            return false;

        for (int i = 0; i < length; ++i) {
            char c = s.charAt(i);

            if (Character.isLetterOrDigit(c) || c == '-' || c == '_')
                continue;
            else
                return true;
        }
        return false;
    }
926948
public static boolean hasCharset(String ctype)
    {
        if (ctype == null)
        {
            return false;
        }
        Matcher matcher = CHARSET_PATT.matcher(ctype);
        if (matcher.find())
        {
            return true;
        }
        else
        {
            return false;
        }
    }
403246
def _validate_charset(data, charset):
        """""""
        if len(charset) > 1:
            charset_data_length = 0
            for symbol_charset in charset:
                if symbol_charset not in ('A', 'B', 'C'):
                    raise Code128.CharsetError
                charset_data_length += 2 if symbol_charset is 'C' else 1
            if charset_data_length != len(data):
                raise Code128.CharsetLengthError
        elif len(charset) == 1:
            if charset not in ('A', 'B', 'C'):
                raise Code128.CharsetError
        elif charset is not None:
            raise Code128.CharsetError
797334
def match(self, chars):
        """"""
        start_index = self.next_index
        for char in self:
            if char not in chars:
                self.next_index -= 1
                break
        return self[start_index:self.next_index]
917971
function(charCode) {
                var isSpecialCharacterEmoji = charCode === 0x3030 || charCode === 0x00AE || charCode === 0x00A9,
                    inEmoticonBlock = 0x1F600 <= charCode && charCode <= 0x1F64F,
                    miscSymbolsAndPictogram = 0x1F300 <= charCode && charCode <= 0x1F5FF,
                    transportAndMap = 0x1F680 <= charCode && charCode <= 0x1F6FF,
                    miscSymbol = 0x2600 <= charCode && charCode <= 0x26FF,
                    dingbat = 0x2700 <= charCode && charCode <= 0x27BF,
                    variation = 0xFE00 <= charCode && charCode <= 0xFE0F,
                    arrow = 0x20D0 <= charCode && charCode <= 0x20FF;

                return isSpecialCharacterEmoji || miscSymbolsAndPictogram || transportAndMap || inEmoticonBlock || miscSymbol || dingbat || variation || arrow;
            }
346994
def fontChar(self, font, char):
        
        font_files = self._getCharFont(self._getFont(font), char)
        print('The character is {0}present in this font.'.format('' if font_files else 'not '))
822835
def l_sa_check(template, literal, is_standalone):
    """"""

    # If there is a newline, or the previous tag was a standalone
    if literal.find('\n') != -1 or is_standalone:
        padding = literal.split('\n')[-1]

        # If all the characters since the last newline are spaces
        if padding.isspace() or padding == '':
            # Then the next tag could be a standalone
            return True
        else:
            # Otherwise it can't be
            return False
759122
def check_bidi(chars):
    

    # the empty string is valid, as it cannot violate the RandALCat constraints
    if not chars:
        return

    # first_is_RorAL = unicodedata.bidirectional(chars[0]) in {"R", "AL"}
    # if first_is_RorAL:

    has_RandALCat = any(is_RandALCat(c) for c in chars)
    if not has_RandALCat:
        return

    has_LCat = any(is_LCat(c) for c in chars)
    if has_LCat:
        raise ValueError("L and R/AL characters must not occur in the same"
                         " string")

    if not is_RandALCat(chars[0]) or not is_RandALCat(chars[-1]):
        raise ValueError("R/AL string must start and end with R/AL character.")
908803
def _check(self, terms):
        """"""
        for t in terms:
            try:
                _ = urllib.parse.quote(six.text_type(t).encode('utf8'))
            except:
                self.logger.error('Unknown character in [{0}]!'.format(t))
                self.logger.error('.... remove character and try again.')
                raise EncodingError