/**@class java.lang.Character
 implements java.io.Serializable

 implements java.lang.Comparable

@extends java.lang.Object

 The wrapper for the primitive type {@code char}. This class also provides a
 number of utility methods for working with characters.

 <p>Character data is kept up to date as Unicode evolves.
 See the <a href="../util/Locale.html#locale_data">Locale data</a> section of
 the {@code Locale} documentation for details of the Unicode versions implemented by current
 and historical Android releases.

 <p>The Unicode specification, character tables, and other information are available at
 <a href="http://www.unicode.org/">http://www.unicode.org/</a>.

 <p>Unicode characters are referred to as <i>code points</i>. The range of valid
 code points is U+0000 to U+10FFFF. The <i>Basic Multilingual Plane (BMP)</i>
 is the code point range U+0000 to U+FFFF. Characters above the BMP are
 referred to as <i>Supplementary Characters</i>. On the Java platform, UTF-16
 encoding and {@code char} pairs are used to represent code points in the
 supplementary range. A pair of {@code char} values that represent a
 supplementary character are made up of a <i>high surrogate</i> with a value
 range of 0xD800 to 0xDBFF and a <i>low surrogate</i> with a value range of
 0xDC00 to 0xDFFF.
 <p>
 On the Java platform a {@code char} value represents either a single BMP code
 point or a UTF-16 unit that's part of a surrogate pair. The {@code int} type
 is used to represent all Unicode code points.

 <a name="unicode_categories"></a><h3>Unicode categories</h3>
 <p>Here's a list of the Unicode character categories and the corresponding Java constant,
 grouped semantically to provide a convenient overview. This table is also useful in
 conjunction with {@code \p} and {@code \P} in {@link java.util.regex.Pattern regular expressions}.
 <span class="datatable">
 <style type="text/css">
 .datatable td { padding-right: 20px; }
 </style>
 <p><table>
 <tr> <td> Cn </td> <td> Unassigned </td>  <td>{@link #UNASSIGNED}</td> </tr>
 <tr> <td> Cc </td> <td> Control </td>     <td>{@link #CONTROL}</td> </tr>
 <tr> <td> Cf </td> <td> Format </td>      <td>{@link #FORMAT}</td> </tr>
 <tr> <td> Co </td> <td> Private use </td> <td>{@link #PRIVATE_USE}</td> </tr>
 <tr> <td> Cs </td> <td> Surrogate </td>   <td>{@link #SURROGATE}</td> </tr>
 <tr> <td><br></td> </tr>
 <tr> <td> Lu </td> <td> Uppercase letter </td> <td>{@link #UPPERCASE_LETTER}</td> </tr>
 <tr> <td> Ll </td> <td> Lowercase letter </td> <td>{@link #LOWERCASE_LETTER}</td> </tr>
 <tr> <td> Lt </td> <td> Titlecase letter </td> <td>{@link #TITLECASE_LETTER}</td> </tr>
 <tr> <td> Lm </td> <td> Modifier letter </td>  <td>{@link #MODIFIER_LETTER}</td> </tr>
 <tr> <td> Lo </td> <td> Other letter </td>     <td>{@link #OTHER_LETTER}</td> </tr>
 <tr> <td><br></td> </tr>
 <tr> <td> Mn </td> <td> Non-spacing mark </td>       <td>{@link #NON_SPACING_MARK}</td> </tr>
 <tr> <td> Me </td> <td> Enclosing mark </td>         <td>{@link #ENCLOSING_MARK}</td> </tr>
 <tr> <td> Mc </td> <td> Combining spacing mark </td> <td>{@link #COMBINING_SPACING_MARK}</td> </tr>
 <tr> <td><br></td> </tr>
 <tr> <td> Nd </td> <td> Decimal digit number </td> <td>{@link #DECIMAL_DIGIT_NUMBER}</td> </tr>
 <tr> <td> Nl </td> <td> Letter number </td>        <td>{@link #LETTER_NUMBER}</td> </tr>
 <tr> <td> No </td> <td> Other number </td>         <td>{@link #OTHER_NUMBER}</td> </tr>
 <tr> <td><br></td> </tr>
 <tr> <td> Pd </td> <td> Dash punctuation </td>          <td>{@link #DASH_PUNCTUATION}</td> </tr>
 <tr> <td> Ps </td> <td> Start punctuation </td>         <td>{@link #START_PUNCTUATION}</td> </tr>
 <tr> <td> Pe </td> <td> End punctuation </td>           <td>{@link #END_PUNCTUATION}</td> </tr>
 <tr> <td> Pc </td> <td> Connector punctuation </td>     <td>{@link #CONNECTOR_PUNCTUATION}</td> </tr>
 <tr> <td> Pi </td> <td> Initial quote punctuation </td> <td>{@link #INITIAL_QUOTE_PUNCTUATION}</td> </tr>
 <tr> <td> Pf </td> <td> Final quote punctuation </td>   <td>{@link #FINAL_QUOTE_PUNCTUATION}</td> </tr>
 <tr> <td> Po </td> <td> Other punctuation </td>         <td>{@link #OTHER_PUNCTUATION}</td> </tr>
 <tr> <td><br></td> </tr>
 <tr> <td> Sm </td> <td> Math symbol </td>     <td>{@link #MATH_SYMBOL}</td> </tr>
 <tr> <td> Sc </td> <td> Currency symbol </td> <td>{@link #CURRENCY_SYMBOL}</td> </tr>
 <tr> <td> Sk </td> <td> Modifier symbol </td> <td>{@link #MODIFIER_SYMBOL}</td> </tr>
 <tr> <td> So </td> <td> Other symbol </td>    <td>{@link #OTHER_SYMBOL}</td> </tr>
 <tr> <td><br></td> </tr>
 <tr> <td> Zs </td> <td> Space separator </td>     <td>{@link #SPACE_SEPARATOR}</td> </tr>
 <tr> <td> Zl </td> <td> Line separator </td>      <td>{@link #LINE_SEPARATOR}</td> </tr>
 <tr> <td> Zp </td> <td> Paragraph separator </td> <td>{@link #PARAGRAPH_SEPARATOR}</td> </tr>
 </table>
 </span>

 @since 1.0
*/
var Character = {

/** The minimum {@code Character} value.
*/
MIN_VALUE : "0",
/** The maximum {@code Character} value.
*/
MAX_VALUE : "65535",
/** The minimum radix used for conversions between characters and integers.
*/
MIN_RADIX : "2",
/** The maximum radix used for conversions between characters and integers.
*/
MAX_RADIX : "36",
/** The {@link java.lang.Class} object that represents the primitive type {@code char}.
*/
TYPE : "null",
/** Unicode category constant Cn.
*/
UNASSIGNED : "0",
/** Unicode category constant Lu.
*/
UPPERCASE_LETTER : "1",
/** Unicode category constant Ll.
*/
LOWERCASE_LETTER : "2",
/** Unicode category constant Lt.
*/
TITLECASE_LETTER : "3",
/** Unicode category constant Lm.
*/
MODIFIER_LETTER : "4",
/** Unicode category constant Lo.
*/
OTHER_LETTER : "5",
/** Unicode category constant Mn.
*/
NON_SPACING_MARK : "6",
/** Unicode category constant Me.
*/
ENCLOSING_MARK : "7",
/** Unicode category constant Mc.
*/
COMBINING_SPACING_MARK : "8",
/** Unicode category constant Nd.
*/
DECIMAL_DIGIT_NUMBER : "9",
/** Unicode category constant Nl.
*/
LETTER_NUMBER : "10",
/** Unicode category constant No.
*/
OTHER_NUMBER : "11",
/** Unicode category constant Zs.
*/
SPACE_SEPARATOR : "12",
/** Unicode category constant Zl.
*/
LINE_SEPARATOR : "13",
/** Unicode category constant Zp.
*/
PARAGRAPH_SEPARATOR : "14",
/** Unicode category constant Cc.
*/
CONTROL : "15",
/** Unicode category constant Cf.
*/
FORMAT : "16",
/** Unicode category constant Co.
*/
PRIVATE_USE : "18",
/** Unicode category constant Cs.
*/
SURROGATE : "19",
/** Unicode category constant Pd.
*/
DASH_PUNCTUATION : "20",
/** Unicode category constant Ps.
*/
START_PUNCTUATION : "21",
/** Unicode category constant Pe.
*/
END_PUNCTUATION : "22",
/** Unicode category constant Pc.
*/
CONNECTOR_PUNCTUATION : "23",
/** Unicode category constant Po.
*/
OTHER_PUNCTUATION : "24",
/** Unicode category constant Sm.
*/
MATH_SYMBOL : "25",
/** Unicode category constant Sc.
*/
CURRENCY_SYMBOL : "26",
/** Unicode category constant Sk.
*/
MODIFIER_SYMBOL : "27",
/** Unicode category constant So.
*/
OTHER_SYMBOL : "28",
/** Unicode category constant Pi.

 @since 1.4
*/
INITIAL_QUOTE_PUNCTUATION : "29",
/** Unicode category constant Pf.

 @since 1.4
*/
FINAL_QUOTE_PUNCTUATION : "30",
/** Unicode bidirectional constant.

 @since 1.4
*/
DIRECTIONALITY_UNDEFINED : "-1",
/** Unicode bidirectional constant L.

 @since 1.4
*/
DIRECTIONALITY_LEFT_TO_RIGHT : "0",
/** Unicode bidirectional constant R.

 @since 1.4
*/
DIRECTIONALITY_RIGHT_TO_LEFT : "1",
/** Unicode bidirectional constant AL.

 @since 1.4
*/
DIRECTIONALITY_RIGHT_TO_LEFT_ARABIC : "2",
/** Unicode bidirectional constant EN.

 @since 1.4
*/
DIRECTIONALITY_EUROPEAN_NUMBER : "3",
/** Unicode bidirectional constant ES.

 @since 1.4
*/
DIRECTIONALITY_EUROPEAN_NUMBER_SEPARATOR : "4",
/** Unicode bidirectional constant ET.

 @since 1.4
*/
DIRECTIONALITY_EUROPEAN_NUMBER_TERMINATOR : "5",
/** Unicode bidirectional constant AN.

 @since 1.4
*/
DIRECTIONALITY_ARABIC_NUMBER : "6",
/** Unicode bidirectional constant CS.

 @since 1.4
*/
DIRECTIONALITY_COMMON_NUMBER_SEPARATOR : "7",
/** Unicode bidirectional constant NSM.

 @since 1.4
*/
DIRECTIONALITY_NONSPACING_MARK : "8",
/** Unicode bidirectional constant BN.

 @since 1.4
*/
DIRECTIONALITY_BOUNDARY_NEUTRAL : "9",
/** Unicode bidirectional constant B.

 @since 1.4
*/
DIRECTIONALITY_PARAGRAPH_SEPARATOR : "10",
/** Unicode bidirectional constant S.

 @since 1.4
*/
DIRECTIONALITY_SEGMENT_SEPARATOR : "11",
/** Unicode bidirectional constant WS.

 @since 1.4
*/
DIRECTIONALITY_WHITESPACE : "12",
/** Unicode bidirectional constant ON.

 @since 1.4
*/
DIRECTIONALITY_OTHER_NEUTRALS : "13",
/** Unicode bidirectional constant LRE.

 @since 1.4
*/
DIRECTIONALITY_LEFT_TO_RIGHT_EMBEDDING : "14",
/** Unicode bidirectional constant LRO.

 @since 1.4
*/
DIRECTIONALITY_LEFT_TO_RIGHT_OVERRIDE : "15",
/** Unicode bidirectional constant RLE.

 @since 1.4
*/
DIRECTIONALITY_RIGHT_TO_LEFT_EMBEDDING : "16",
/** Unicode bidirectional constant RLO.

 @since 1.4
*/
DIRECTIONALITY_RIGHT_TO_LEFT_OVERRIDE : "17",
/** Unicode bidirectional constant PDF.

 @since 1.4
*/
DIRECTIONALITY_POP_DIRECTIONAL_FORMAT : "18",
/** The minimum value of a high surrogate or leading surrogate unit in UTF-16
 encoding, {@code '?'}.

 @since 1.5
*/
MIN_HIGH_SURROGATE : "55296",
/** The maximum value of a high surrogate or leading surrogate unit in UTF-16
 encoding, {@code '?'}.

 @since 1.5
*/
MAX_HIGH_SURROGATE : "56319",
/** The minimum value of a low surrogate or trailing surrogate unit in UTF-16
 encoding, {@code '?'}.

 @since 1.5
*/
MIN_LOW_SURROGATE : "56320",
/** The maximum value of a low surrogate or trailing surrogate unit in UTF-16
 encoding, {@code '?'}.

 @since 1.5
*/
MAX_LOW_SURROGATE : "57343",
/** The minimum value of a surrogate unit in UTF-16 encoding, {@code '?'}.

 @since 1.5
*/
MIN_SURROGATE : "55296",
/** The maximum value of a surrogate unit in UTF-16 encoding, {@code '?'}.

 @since 1.5
*/
MAX_SURROGATE : "57343",
/** The minimum value of a supplementary code point, {@code U+010000}.

 @since 1.5
*/
MIN_SUPPLEMENTARY_CODE_POINT : "65536",
/** The minimum code point value, {@code U+0000}.

 @since 1.5
*/
MIN_CODE_POINT : "0",
/** The maximum code point value, {@code U+10FFFF}.

 @since 1.5
*/
MAX_CODE_POINT : "1114111",
/** The number of bits required to represent a {@code Character} value
 unsigned form.

 @since 1.5
*/
SIZE : "16",
/**Gets the primitive value of this character.
@return {String} this object's primitive value.
*/
charValue : function(  ) {},

/**Compares this object to the specified character object to determine their
 relative order.
@param {Object {Character}} c
            the character object to compare this object to.
@return {Number} {@code 0} if the value of this character and the value of
         {@code c} are equal; a positive value if the value of this
         character is greater than the value of {@code c}; a negative
         value if the value of this character is less than the value of
         {@code c}.
@see java.lang.Comparable
@since 1.2
*/
compareTo : function(  ) {},

/**Compares two {@code char} values.
@return {Number} 0 if lhs = rhs, less than 0 if lhs &lt; rhs, and greater than 0 if lhs &gt; rhs.
@since 1.7
*/
compare : function(  ) {},

/**Returns a {@code Character} instance for the {@code char} value passed.
 <p>
 If it is not necessary to get a new {@code Character} instance, it is
 recommended to use this method instead of the constructor, since it
 maintains a cache of instances which may result in better performance.
@param {String} c
            the char value for which to get a {@code Character} instance.
@return {Object {java.lang.Character}} the {@code Character} instance for {@code c}.
@since 1.5
*/
valueOf : function(  ) {},

/**Indicates whether {@code codePoint} is a valid Unicode code point.
@param {Number} codePoint
            the code point to test.
@return {Boolean} {@code true} if {@code codePoint} is a valid Unicode code point;
         {@code false} otherwise.
@since 1.5
*/
isValidCodePoint : function(  ) {},

/**Indicates whether {@code codePoint} is within the supplementary code
 point range.
@param {Number} codePoint
            the code point to test.
@return {Boolean} {@code true} if {@code codePoint} is within the supplementary
         code point range; {@code false} otherwise.
@since 1.5
*/
isSupplementaryCodePoint : function(  ) {},

/**Indicates whether {@code ch} is a high- (or leading-) surrogate code unit
 that is used for representing supplementary characters in UTF-16
 encoding.
@param {String} ch
            the character to test.
@return {Boolean} {@code true} if {@code ch} is a high-surrogate code unit;
         {@code false} otherwise.
@see #isLowSurrogate(char)
@since 1.5
*/
isHighSurrogate : function(  ) {},

/**Indicates whether {@code ch} is a low- (or trailing-) surrogate code unit
 that is used for representing supplementary characters in UTF-16
 encoding.
@param {String} ch
            the character to test.
@return {Boolean} {@code true} if {@code ch} is a low-surrogate code unit;
         {@code false} otherwise.
@see #isHighSurrogate(char)
@since 1.5
*/
isLowSurrogate : function(  ) {},

/**Returns true if the given character is a high or low surrogate.
@since 1.7
*/
isSurrogate : function(  ) {},

/**Indicates whether the specified character pair is a valid surrogate pair.
@param {String} high
            the high surrogate unit to test.
@param {String} low
            the low surrogate unit to test.
@return {Boolean} {@code true} if {@code high} is a high-surrogate code unit and
         {@code low} is a low-surrogate code unit; {@code false}
         otherwise.
@see #isHighSurrogate(char)
@see #isLowSurrogate(char)
@since 1.5
*/
isSurrogatePair : function(  ) {},

/**Calculates the number of {@code char} values required to represent the
 specified Unicode code point. This method checks if the {@code codePoint}
 is greater than or equal to {@code 0x10000}, in which case {@code 2} is
 returned, otherwise {@code 1}. To test if the code point is valid, use
 the {@link #isValidCodePoint}(int) method.
@param {Number} codePoint
            the code point for which to calculate the number of required
            chars.
@return {Number} {@code 2} if {@code codePoint >= 0x10000}; {@code 1} otherwise.
@see #isValidCodePoint(int)
@see #isSupplementaryCodePoint(int)
@since 1.5
*/
charCount : function(  ) {},

/**Converts a surrogate pair into a Unicode code point. This method assumes
 that the pair are valid surrogates. If the pair are <i>not</i> valid
 surrogates, then the result is indeterminate. The
 {@link #isSurrogatePair(char, char)} method should be used prior to this
 method to validate the pair.
@param {String} high
            the high surrogate unit.
@param {String} low
            the low surrogate unit.
@return {Number} the Unicode code point corresponding to the surrogate unit pair.
@see #isSurrogatePair(char, char)
@since 1.5
*/
toCodePoint : function(  ) {},

/**Returns the code point at {@code index} in the specified sequence of
 character units. If the unit at {@code index} is a high-surrogate unit,
 {@code index + 1} is less than the length of the sequence and the unit at
 {@code index + 1} is a low-surrogate unit, then the supplementary code
 point represented by the pair is returned; otherwise the {@code char}
 value at {@code index} is returned.
@param {Object {CharSequence}} seq
            the source sequence of {@code char} units.
@param {Number} index
            the position in {@code seq} from which to retrieve the code
            point.
@return {Number} the Unicode code point or {@code char} value at {@code index} in
         {@code seq}.
@throws NullPointerException
             if {@code seq} is {@code null}.
@throws IndexOutOfBoundsException
             if the {@code index} is negative or greater than or equal to
             the length of {@code seq}.
@since 1.5
*/
codePointAt : function(  ) {},

/**Returns the code point at {@code index} in the specified array of
 character units. If the unit at {@code index} is a high-surrogate unit,
 {@code index + 1} is less than the length of the array and the unit at
 {@code index + 1} is a low-surrogate unit, then the supplementary code
 point represented by the pair is returned; otherwise the {@code char}
 value at {@code index} is returned.
@param {Object {char[]}} seq
            the source array of {@code char} units.
@param {Number} index
            the position in {@code seq} from which to retrieve the code
            point.
@return {Number} the Unicode code point or {@code char} value at {@code index} in
         {@code seq}.
@throws NullPointerException
             if {@code seq} is {@code null}.
@throws IndexOutOfBoundsException
             if the {@code index} is negative or greater than or equal to
             the length of {@code seq}.
@since 1.5
*/
codePointAt : function(  ) {},

/**Returns the code point at {@code index} in the specified array of
 character units, where {@code index} has to be less than {@code limit}.
 If the unit at {@code index} is a high-surrogate unit, {@code index + 1}
 is less than {@code limit} and the unit at {@code index + 1} is a
 low-surrogate unit, then the supplementary code point represented by the
 pair is returned; otherwise the {@code char} value at {@code index} is
 returned.
@param {Object {char[]}} seq
            the source array of {@code char} units.
@param {Number} index
            the position in {@code seq} from which to get the code point.
@param {Number} limit
            the index after the last unit in {@code seq} that can be used.
@return {Number} the Unicode code point or {@code char} value at {@code index} in
         {@code seq}.
@throws NullPointerException
             if {@code seq} is {@code null}.
@throws IndexOutOfBoundsException
             if {@code index < 0}, {@code index >= limit},
             {@code limit < 0} or if {@code limit} is greater than the
             length of {@code seq}.
@since 1.5
*/
codePointAt : function(  ) {},

/**Returns the code point that precedes {@code index} in the specified
 sequence of character units. If the unit at {@code index - 1} is a
 low-surrogate unit, {@code index - 2} is not negative and the unit at
 {@code index - 2} is a high-surrogate unit, then the supplementary code
 point represented by the pair is returned; otherwise the {@code char}
 value at {@code index - 1} is returned.
@param {Object {CharSequence}} seq
            the source sequence of {@code char} units.
@param {Number} index
            the position in {@code seq} following the code
            point that should be returned.
@return {Number} the Unicode code point or {@code char} value before {@code index}
         in {@code seq}.
@throws NullPointerException
             if {@code seq} is {@code null}.
@throws IndexOutOfBoundsException
             if the {@code index} is less than 1 or greater than the
             length of {@code seq}.
@since 1.5
*/
codePointBefore : function(  ) {},

/**Returns the code point that precedes {@code index} in the specified
 array of character units. If the unit at {@code index - 1} is a
 low-surrogate unit, {@code index - 2} is not negative and the unit at
 {@code index - 2} is a high-surrogate unit, then the supplementary code
 point represented by the pair is returned; otherwise the {@code char}
 value at {@code index - 1} is returned.
@param {Object {char[]}} seq
            the source array of {@code char} units.
@param {Number} index
            the position in {@code seq} following the code
            point that should be returned.
@return {Number} the Unicode code point or {@code char} value before {@code index}
         in {@code seq}.
@throws NullPointerException
             if {@code seq} is {@code null}.
@throws IndexOutOfBoundsException
             if the {@code index} is less than 1 or greater than the
             length of {@code seq}.
@since 1.5
*/
codePointBefore : function(  ) {},

/**Returns the code point that precedes the {@code index} in the specified
 array of character units and is not less than {@code start}. If the unit
 at {@code index - 1} is a low-surrogate unit, {@code index - 2} is not
 less than {@code start} and the unit at {@code index - 2} is a
 high-surrogate unit, then the supplementary code point represented by the
 pair is returned; otherwise the {@code char} value at {@code index - 1}
 is returned.
@param {Object {char[]}} seq
            the source array of {@code char} units.
@param {Number} index
            the position in {@code seq} following the code point that
            should be returned.
@param {Number} start
            the index of the first element in {@code seq}.
@return {Number} the Unicode code point or {@code char} value before {@code index}
         in {@code seq}.
@throws NullPointerException
             if {@code seq} is {@code null}.
@throws IndexOutOfBoundsException
             if the {@code index <= start}, {@code start < 0},
             {@code index} is greater than the length of {@code seq}, or
             if {@code start} is equal or greater than the length of
             {@code seq}.
@since 1.5
*/
codePointBefore : function(  ) {},

/**Converts the specified Unicode code point into a UTF-16 encoded sequence
 and copies the value(s) into the char array {@code dst}, starting at
 index {@code dstIndex}.
@param {Number} codePoint
            the Unicode code point to encode.
@param {Object {char[]}} dst
            the destination array to copy the encoded value into.
@param {Number} dstIndex
            the index in {@code dst} from where to start copying.
@return {Number} the number of {@code char} value units copied into {@code dst}.
@throws IllegalArgumentException if {@code codePoint} is not a valid code point.
@throws NullPointerException
             if {@code dst} is {@code null}.
@throws IndexOutOfBoundsException
             if {@code dstIndex} is negative, greater than or equal to
             {@code dst.length} or equals {@code dst.length - 1} when
             {@code codePoint} is a
             {@link #isSupplementaryCodePoint(int) supplementary code point}.
@since 1.5
*/
toChars : function(  ) {},

/**Converts the specified Unicode code point into a UTF-16 encoded sequence
 and returns it as a char array.
@param {Number} codePoint
            the Unicode code point to encode.
@return {String} the UTF-16 encoded char sequence. If {@code codePoint} is a
         {@link #isSupplementaryCodePoint(int) supplementary code point},
         then the returned array contains two characters, otherwise it
         contains just one character.
@throws IllegalArgumentException if {@code codePoint} is not a valid code point.
@since 1.5
*/
toChars : function(  ) {},

/**Counts the number of Unicode code points in the subsequence of the
 specified character sequence, as delineated by {@code beginIndex} and
 {@code endIndex}. Any surrogate values with missing pair values will be
 counted as one code point.
@param {Object {CharSequence}} seq
            the {@code CharSequence} to look through.
@param {Number} beginIndex
            the inclusive index to begin counting at.
@param {Number} endIndex
            the exclusive index to stop counting at.
@return {Number} the number of Unicode code points.
@throws NullPointerException
             if {@code seq} is {@code null}.
@throws IndexOutOfBoundsException
             if {@code beginIndex < 0}, {@code beginIndex > endIndex} or
             if {@code endIndex} is greater than the length of {@code seq}.
@since 1.5
*/
codePointCount : function(  ) {},

/**Counts the number of Unicode code points in the subsequence of the
 specified char array, as delineated by {@code offset} and {@code count}.
 Any surrogate values with missing pair values will be counted as one code
 point.
@param {Object {char[]}} seq
            the char array to look through
@param {Number} offset
            the inclusive index to begin counting at.
@param {Number} count
            the number of {@code char} values to look through in
            {@code seq}.
@return {Number} the number of Unicode code points.
@throws NullPointerException
             if {@code seq} is {@code null}.
@throws IndexOutOfBoundsException
             if {@code offset < 0}, {@code count < 0} or if
             {@code offset + count} is greater than the length of
             {@code seq}.
@since 1.5
*/
codePointCount : function(  ) {},

/**Determines the index in the specified character sequence that is offset
 {@code codePointOffset} code points from {@code index}.
@param {Object {CharSequence}} seq
            the character sequence to find the index in.
@param {Number} index
            the start index in {@code seq}.
@param {Number} codePointOffset
            the number of code points to look backwards or forwards; may
            be a negative or positive value.
@return {Number} the index in {@code seq} that is {@code codePointOffset} code
         points away from {@code index}.
@throws NullPointerException
             if {@code seq} is {@code null}.
@throws IndexOutOfBoundsException
             if {@code index < 0}, {@code index} is greater than the
             length of {@code seq}, or if there are not enough values in
             {@code seq} to skip {@code codePointOffset} code points
             forwards or backwards (if {@code codePointOffset} is
             negative) from {@code index}.
@since 1.5
*/
offsetByCodePoints : function(  ) {},

/**Determines the index in a subsequence of the specified character array
 that is offset {@code codePointOffset} code points from {@code index}.
 The subsequence is delineated by {@code start} and {@code count}.
@param {Object {char[]}} seq
            the character array to find the index in.
@param {Number} start
            the inclusive index that marks the beginning of the
            subsequence.
@param {Number} count
            the number of {@code char} values to include within the
            subsequence.
@param {Number} index
            the start index in the subsequence of the char array.
@param {Number} codePointOffset
            the number of code points to look backwards or forwards; may
            be a negative or positive value.
@return {Number} the index in {@code seq} that is {@code codePointOffset} code
         points away from {@code index}.
@throws NullPointerException
             if {@code seq} is {@code null}.
@throws IndexOutOfBoundsException
             if {@code start < 0}, {@code count < 0},
             {@code index < start}, {@code index > start + count},
             {@code start + count} is greater than the length of
             {@code seq}, or if there are not enough values in
             {@code seq} to skip {@code codePointOffset} code points
             forward or backward (if {@code codePointOffset} is
             negative) from {@code index}.
@since 1.5
*/
offsetByCodePoints : function(  ) {},

/**Convenience method to determine the value of the specified character
 {@code c} in the supplied radix. The value of {@code radix} must be
 between MIN_RADIX and MAX_RADIX.
@param {String} c
            the character to determine the value of.
@param {Number} radix
            the radix.
@return {Number} the value of {@code c} in {@code radix} if {@code radix} lies
         between {@link #MIN_RADIX} and {@link #MAX_RADIX}; -1 otherwise.
*/
digit : function(  ) {},

/**Convenience method to determine the value of the character
 {@code codePoint} in the supplied radix. The value of {@code radix} must
 be between MIN_RADIX and MAX_RADIX.
@param {Number} codePoint
            the character, including supplementary characters.
@param {Number} radix
            the radix.
@return {Number} if {@code radix} lies between {@link #MIN_RADIX} and
         {@link #MAX_RADIX} then the value of the character in the radix;
         -1 otherwise.
*/
digit : function(  ) {},

/**Compares this object with the specified object and indicates if they are
 equal. In order to be equal, {@code object} must be an instance of
 {@code Character} and have the same char value as this object.
@param {Object {Object}} object
            the object to compare this double with.
@return {Boolean} {@code true} if the specified object is equal to this
         {@code Character}; {@code false} otherwise.
*/
equals : function(  ) {},

/**Returns the character which represents the specified digit in the
 specified radix. The {@code radix} must be between {@code MIN_RADIX} and
 {@code MAX_RADIX} inclusive; {@code digit} must not be negative and
 smaller than {@code radix}. If any of these conditions does not hold, 0
 is returned.
@param {Number} digit
            the integer value.
@param {Number} radix
            the radix.
@return {String} the character which represents the {@code digit} in the
         {@code radix}.
*/
forDigit : function(  ) {},

/**Returns a human-readable name for the given code point,
 or null if the code point is unassigned.

 <p>As a fallback mechanism this method returns strings consisting of the Unicode
 block name (with underscores replaced by spaces), a single space, and the uppercase
 hex value of the code point, using as few digits as necessary.

 <p>Examples:
 <ul>
 <li>{@code Character.getName(0)} returns "NULL".
 <li>{@code Character.getName('e')} returns "LATIN SMALL LETTER E".
 <li>{@code Character.getName('٦')} returns "ARABIC-INDIC DIGIT SIX".
 <li>{@code Character.getName(0xe000)} returns "PRIVATE USE AREA E000".
 </ul>

 <p>Note that the exact strings returned will vary from release to release.
@throws IllegalArgumentException if {@code codePoint} is not a valid code point.
@since 1.7
*/
getName : function(  ) {},

/**Returns the numeric value of the specified Unicode character.
 See {@link #getNumericValue}(int).
@param {String} c the character
@return {Number} a non-negative numeric integer value if a numeric value for
         {@code c} exists, -1 if there is no numeric value for {@code c},
         -2 if the numeric value can not be represented as an integer.
*/
getNumericValue : function(  ) {},

/**Gets the numeric value of the specified Unicode code point. For example,
 the code point 'Ⅻ' stands for the Roman number XII, which has the
 numeric value 12.

 <p>There are two points of divergence between this method and the Unicode
 specification. This method treats the letters a-z (in both upper and lower
 cases, and their full-width variants) as numbers from 10 to 35. The
 Unicode specification also supports the idea of code points with non-integer
 numeric values; this method does not (except to the extent of returning -2
 for such code points).
@param {Number} codePoint the code point
@return {Number} a non-negative numeric integer value if a numeric value for
         {@code codePoint} exists, -1 if there is no numeric value for
         {@code codePoint}, -2 if the numeric value can not be
         represented with an integer.
*/
getNumericValue : function(  ) {},

/**Gets the general Unicode category of the specified character.
@param {String} c
            the character to get the category of.
@return {Number} the Unicode category of {@code c}.
*/
getType : function(  ) {},

/**Gets the general Unicode category of the specified code point.
@param {Number} codePoint
            the Unicode code point to get the category of.
@return {Number} the Unicode category of {@code codePoint}.
*/
getType : function(  ) {},

/**Gets the Unicode directionality of the specified character.
@param {String} c
            the character to get the directionality of.
@return {Number} the Unicode directionality of {@code c}.
*/
getDirectionality : function(  ) {},

/**Returns the Unicode directionality of the given code point.
 This will be one of the {@code DIRECTIONALITY_} constants.
 For characters whose directionality is undefined, or whose
 directionality has no appropriate constant in this class,
 {@code DIRECTIONALITY_UNDEFINED} is returned.
*/
getDirectionality : function(  ) {},

/**
@hide - internal use only.
*/
getIcuDirectionality : function(  ) {},

/**Indicates whether the specified character is mirrored.
@param {String} c
            the character to check.
@return {Boolean} {@code true} if {@code c} is mirrored; {@code false}
         otherwise.
*/
isMirrored : function(  ) {},

/**Indicates whether the specified code point is mirrored.
@param {Number} codePoint
            the code point to check.
@return {Boolean} {@code true} if {@code codePoint} is mirrored, {@code false}
         otherwise.
*/
isMirrored : function(  ) {},

/**
*/
hashCode : function(  ) {},

/**Returns the high surrogate for the given code point. The result is meaningless if
 the given code point is not a supplementary character.
@since 1.7
*/
highSurrogate : function(  ) {},

/**Returns the low surrogate for the given code point. The result is meaningless if
 the given code point is not a supplementary character.
@since 1.7
*/
lowSurrogate : function(  ) {},

/**Returns true if the given code point is alphabetic. That is,
 if it is in any of the Lu, Ll, Lt, Lm, Lo, Nl, or Other_Alphabetic categories.
@since 1.7
*/
isAlphabetic : function(  ) {},

/**Returns true if the given code point is in the Basic Multilingual Plane (BMP).
 Such code points can be represented by a single {@code char}.
@since 1.7
*/
isBmpCodePoint : function(  ) {},

/**Indicates whether the specified character is defined in the Unicode
 specification.
@param {String} c
            the character to check.
@return {Boolean} {@code true} if the general Unicode category of the character is
         not {@code UNASSIGNED}; {@code false} otherwise.
*/
isDefined : function(  ) {},

/**Indicates whether the specified code point is defined in the Unicode
 specification.
@param {Number} codePoint
            the code point to check.
@return {Boolean} {@code true} if the general Unicode category of the code point is
         not {@code UNASSIGNED}; {@code false} otherwise.
*/
isDefined : function(  ) {},

/**Indicates whether the specified character is a digit.
@param {String} c
            the character to check.
@return {Boolean} {@code true} if {@code c} is a digit; {@code false}
         otherwise.
*/
isDigit : function(  ) {},

/**Indicates whether the specified code point is a digit.
@param {Number} codePoint
            the code point to check.
@return {Boolean} {@code true} if {@code codePoint} is a digit; {@code false}
         otherwise.
*/
isDigit : function(  ) {},

/**Indicates whether the specified character is ignorable in a Java or
 Unicode identifier.
@param {String} c
            the character to check.
@return {Boolean} {@code true} if {@code c} is ignorable; {@code false} otherwise.
*/
isIdentifierIgnorable : function(  ) {},

/**Returns true if the given code point is a CJKV ideographic character.
@since 1.7
*/
isIdeographic : function(  ) {},

/**Indicates whether the specified code point is ignorable in a Java or
 Unicode identifier.
@param {Number} codePoint
            the code point to check.
@return {Boolean} {@code true} if {@code codePoint} is ignorable; {@code false}
         otherwise.
*/
isIdentifierIgnorable : function(  ) {},

/**Indicates whether the specified character is an ISO control character.
@param {String} c
            the character to check.
@return {Boolean} {@code true} if {@code c} is an ISO control character;
         {@code false} otherwise.
*/
isISOControl : function(  ) {},

/**Indicates whether the specified code point is an ISO control character.
@param {Number} c
            the code point to check.
@return {Boolean} {@code true} if {@code c} is an ISO control character;
         {@code false} otherwise.
*/
isISOControl : function(  ) {},

/**Indicates whether the specified character is a valid part of a Java
 identifier other than the first character.
@param {String} c
            the character to check.
@return {Boolean} {@code true} if {@code c} is valid as part of a Java identifier;
         {@code false} otherwise.
*/
isJavaIdentifierPart : function(  ) {},

/**Indicates whether the specified code point is a valid part of a Java
 identifier other than the first character.
@param {Number} codePoint
            the code point to check.
@return {Boolean} {@code true} if {@code c} is valid as part of a Java identifier;
         {@code false} otherwise.
*/
isJavaIdentifierPart : function(  ) {},

/**Indicates whether the specified character is a valid first character for
 a Java identifier.
@param {String} c
            the character to check.
@return {Boolean} {@code true} if {@code c} is a valid first character of a Java
         identifier; {@code false} otherwise.
*/
isJavaIdentifierStart : function(  ) {},

/**Indicates whether the specified code point is a valid first character for
 a Java identifier.
@param {Number} codePoint
            the code point to check.
@return {Boolean} {@code true} if {@code codePoint} is a valid start of a Java
         identifier; {@code false} otherwise.
*/
isJavaIdentifierStart : function(  ) {},

/**Indicates whether the specified character is a Java letter.
@param {String} c
            the character to check.
@return {Boolean} {@code true} if {@code c} is a Java letter; {@code false}
         otherwise.
@deprecated Use {@link #isJavaIdentifierStart(char)} instead.
*/
isJavaLetter : function(  ) {},

/**Indicates whether the specified character is a Java letter or digit
 character.
@param {String} c
            the character to check.
@return {Boolean} {@code true} if {@code c} is a Java letter or digit;
         {@code false} otherwise.
@deprecated Use {@link #isJavaIdentifierPart(char)} instead.
*/
isJavaLetterOrDigit : function(  ) {},

/**Indicates whether the specified character is a letter.
@param {String} c
            the character to check.
@return {Boolean} {@code true} if {@code c} is a letter; {@code false} otherwise.
*/
isLetter : function(  ) {},

/**Indicates whether the specified code point is a letter.
@param {Number} codePoint
            the code point to check.
@return {Boolean} {@code true} if {@code codePoint} is a letter; {@code false}
         otherwise.
*/
isLetter : function(  ) {},

/**Indicates whether the specified character is a letter or a digit.
@param {String} c
            the character to check.
@return {Boolean} {@code true} if {@code c} is a letter or a digit; {@code false}
         otherwise.
*/
isLetterOrDigit : function(  ) {},

/**Indicates whether the specified code point is a letter or a digit.
@param {Number} codePoint
            the code point to check.
@return {Boolean} {@code true} if {@code codePoint} is a letter or a digit;
         {@code false} otherwise.
*/
isLetterOrDigit : function(  ) {},

/**Indicates whether the specified character is a lower case letter.
@param {String} c
            the character to check.
@return {Boolean} {@code true} if {@code c} is a lower case letter; {@code false}
         otherwise.
*/
isLowerCase : function(  ) {},

/**Indicates whether the specified code point is a lower case letter.
@param {Number} codePoint
            the code point to check.
@return {Boolean} {@code true} if {@code codePoint} is a lower case letter;
         {@code false} otherwise.
*/
isLowerCase : function(  ) {},

/**Use {@link #isWhitespace}(char) instead.
@deprecated Use {@link #isWhitespace(char)} instead.
*/
isSpace : function(  ) {},

/**See {@link #isSpaceChar}(int).
*/
isSpaceChar : function(  ) {},

/**Returns true if the given code point is a Unicode space character.
 The exact set of characters considered as whitespace varies with Unicode version.
 Note that non-breaking spaces are considered whitespace.
 Note also that line separators are not considered whitespace; see {@link #isWhitespace}
 for an alternative.
*/
isSpaceChar : function(  ) {},

/**Indicates whether the specified character is a titlecase character.
@param {String} c
            the character to check.
@return {Boolean} {@code true} if {@code c} is a titlecase character, {@code false}
         otherwise.
*/
isTitleCase : function(  ) {},

/**Indicates whether the specified code point is a titlecase character.
@param {Number} codePoint
            the code point to check.
@return {Boolean} {@code true} if {@code codePoint} is a titlecase character,
         {@code false} otherwise.
*/
isTitleCase : function(  ) {},

/**Indicates whether the specified character is valid as part of a Unicode
 identifier other than the first character.
@param {String} c
            the character to check.
@return {Boolean} {@code true} if {@code c} is valid as part of a Unicode
         identifier; {@code false} otherwise.
*/
isUnicodeIdentifierPart : function(  ) {},

/**Indicates whether the specified code point is valid as part of a Unicode
 identifier other than the first character.
@param {Number} codePoint
            the code point to check.
@return {Boolean} {@code true} if {@code codePoint} is valid as part of a Unicode
         identifier; {@code false} otherwise.
*/
isUnicodeIdentifierPart : function(  ) {},

/**Indicates whether the specified character is a valid initial character
 for a Unicode identifier.
@param {String} c
            the character to check.
@return {Boolean} {@code true} if {@code c} is a valid first character for a
         Unicode identifier; {@code false} otherwise.
*/
isUnicodeIdentifierStart : function(  ) {},

/**Indicates whether the specified code point is a valid initial character
 for a Unicode identifier.
@param {Number} codePoint
            the code point to check.
@return {Boolean} {@code true} if {@code codePoint} is a valid first character for
         a Unicode identifier; {@code false} otherwise.
*/
isUnicodeIdentifierStart : function(  ) {},

/**Indicates whether the specified character is an upper case letter.
@param {String} c
            the character to check.
@return {Boolean} {@code true} if {@code c} is a upper case letter; {@code false}
         otherwise.
*/
isUpperCase : function(  ) {},

/**Indicates whether the specified code point is an upper case letter.
@param {Number} codePoint
            the code point to check.
@return {Boolean} {@code true} if {@code codePoint} is a upper case letter;
         {@code false} otherwise.
*/
isUpperCase : function(  ) {},

/**See {@link #isWhitespace}(int).
*/
isWhitespace : function(  ) {},

/**Returns true if the given code point is a Unicode whitespace character.
 The exact set of characters considered as whitespace varies with Unicode version.
 Note that non-breaking spaces are not considered whitespace.
 Note also that line separators are considered whitespace; see {@link #isSpaceChar}
 for an alternative.
*/
isWhitespace : function(  ) {},

/**Reverses the order of the first and second byte in the specified
 character.
@param {String} c
            the character to reverse.
@return {String} the character with reordered bytes.
*/
reverseBytes : function(  ) {},

/**Returns the lower case equivalent for the specified character if the
 character is an upper case letter. Otherwise, the specified character is
 returned unchanged.
@param {String} c
            the character
@return {String} if {@code c} is an upper case character then its lower case
         counterpart, otherwise just {@code c}.
*/
toLowerCase : function(  ) {},

/**Returns the lower case equivalent for the specified code point if it is
 an upper case letter. Otherwise, the specified code point is returned
 unchanged.
@param {Number} codePoint
            the code point to check.
@return {Number} if {@code codePoint} is an upper case character then its lower
         case counterpart, otherwise just {@code codePoint}.
*/
toLowerCase : function(  ) {},

/**
*/
toString : function(  ) {},

/**Converts the specified character to its string representation.
@param {String} value
            the character to convert.
@return {String} the character converted to a string.
*/
toString : function(  ) {},

/**Returns the title case equivalent for the specified character if it
 exists. Otherwise, the specified character is returned unchanged.
@param {String} c
            the character to convert.
@return {String} the title case equivalent of {@code c} if it exists, otherwise
         {@code c}.
*/
toTitleCase : function(  ) {},

/**Returns the title case equivalent for the specified code point if it
 exists. Otherwise, the specified code point is returned unchanged.
@param {Number} codePoint
            the code point to convert.
@return {Number} the title case equivalent of {@code codePoint} if it exists,
         otherwise {@code codePoint}.
*/
toTitleCase : function(  ) {},

/**Returns the upper case equivalent for the specified character if the
 character is a lower case letter. Otherwise, the specified character is
 returned unchanged.
@param {String} c
            the character to convert.
@return {String} if {@code c} is a lower case character then its upper case
         counterpart, otherwise just {@code c}.
*/
toUpperCase : function(  ) {},

/**Returns the upper case equivalent for the specified code point if the
 code point is a lower case letter. Otherwise, the specified code point is
 returned unchanged.
@param {Number} codePoint
            the code point to convert.
@return {Number} if {@code codePoint} is a lower case character then its upper
         case counterpart, otherwise just {@code codePoint}.
*/
toUpperCase : function(  ) {},


};