/**@class java.text.Bidi
@extends java.lang.Object

 This class implements the Unicode Bidirectional Algorithm.
 <p>
 A Bidi object provides information on the bidirectional reordering of the text
 used to create it.  This is required, for example, to properly display Arabic
 or Hebrew text.  These languages are inherently mixed directional, as they order
 numbers from left-to-right while ordering most other text from right-to-left.
 <p>
 Once created, a Bidi object can be queried to see if the text it represents is
 all left-to-right or all right-to-left.  Such objects are very lightweight and
 this text is relatively easy to process.
 <p>
 If there are multiple runs of text, information about the runs can be accessed
 by indexing to get the start, limit, and level of a run.  The level represents
 both the direction and the 'nesting level' of a directional run.  Odd levels
 are right-to-left, while even levels are left-to-right.  So for example level
 0 represents left-to-right text, while level 1 represents right-to-left text, and
 level 2 represents left-to-right text embedded in a right-to-left run.

 @since 1.4
*/
var Bidi = {

/**Constant indicating base direction is left-to-right. */
DIRECTION_LEFT_TO_RIGHT : "0",
/**Constant indicating base direction is right-to-left. */
DIRECTION_RIGHT_TO_LEFT : "1",
/** Constant indicating that the base direction depends on the first strong
 directional character in the text according to the Unicode
 Bidirectional Algorithm.  If no strong directional character is present,
 the base direction is left-to-right.
*/
DIRECTION_DEFAULT_LEFT_TO_RIGHT : "-2",
/** Constant indicating that the base direction depends on the first strong
 directional character in the text according to the Unicode
 Bidirectional Algorithm.  If no strong directional character is present,
 the base direction is right-to-left.
*/
DIRECTION_DEFAULT_RIGHT_TO_LEFT : "-1",
/**Create a Bidi object representing the bidi information on a line of text within
 the paragraph represented by the current Bidi.  This call is not required if the
 entire paragraph fits on one line.
@param {Number} lineStart the offset from the start of the paragraph to the start of the line.
@param {Number} lineLimit the offset from the start of the paragraph to the limit of the line.
@return {Object {java.text.Bidi}} a {@code Bidi} object
*/
createLineBidi : function(  ) {},

/**Return true if the line is not left-to-right or right-to-left.  This means it either has mixed runs of left-to-right
 and right-to-left text, or the base direction differs from the direction of the only run of text.
@return {Boolean} true if the line is not left-to-right or right-to-left.
*/
isMixed : function(  ) {},

/**Return true if the line is all left-to-right text and the base direction is left-to-right.
@return {Boolean} true if the line is all left-to-right text and the base direction is left-to-right
*/
isLeftToRight : function(  ) {},

/**Return true if the line is all right-to-left text, and the base direction is right-to-left.
@return {Boolean} true if the line is all right-to-left text, and the base direction is right-to-left
*/
isRightToLeft : function(  ) {},

/**Return the length of text in the line.
@return {Number} the length of text in the line
*/
getLength : function(  ) {},

/**Return true if the base direction is left-to-right.
@return {Boolean} true if the base direction is left-to-right
*/
baseIsLeftToRight : function(  ) {},

/**Return the base level (0 if left-to-right, 1 if right-to-left).
@return {Number} the base level
*/
getBaseLevel : function(  ) {},

/**Return the resolved level of the character at offset.  If offset is
 {@literal <} 0 or &ge; the length of the line, return the base direction
 level.
@param {Number} offset the index of the character for which to return the level
@return {Number} the resolved level of the character at offset
*/
getLevelAt : function(  ) {},

/**Return the number of level runs.
@return {Number} the number of level runs
*/
getRunCount : function(  ) {},

/**Return the level of the nth logical run in this line.
@param {Number} run the index of the run, between 0 and <code>getRunCount()</code>
@return {Number} the level of the run
*/
getRunLevel : function(  ) {},

/**Return the index of the character at the start of the nth logical run in this line, as
 an offset from the start of the line.
@param {Number} run the index of the run, between 0 and <code>getRunCount()</code>
@return {Number} the start of the run
*/
getRunStart : function(  ) {},

/**Return the index of the character past the end of the nth logical run in this line, as
 an offset from the start of the line.  For example, this will return the length
 of the line for the last run on the line.
@param {Number} run the index of the run, between 0 and <code>getRunCount()</code>
@return {Number} limit the limit of the run
*/
getRunLimit : function(  ) {},

/**Return true if the specified text requires bidi analysis.  If this returns false,
 the text will display left-to-right.  Clients can then avoid constructing a Bidi object.
 Text in the Arabic Presentation Forms area of Unicode is presumed to already be shaped
 and ordered for display, and so will not cause this function to return true.
@param {Object {char[]}} text the text containing the characters to test
@param {Number} start the start of the range of characters to test
@param {Number} limit the limit of the range of characters to test
@return {Boolean} true if the range of characters requires bidi analysis
*/
requiresBidi : function(  ) {},

/**Reorder the objects in the array into visual order based on their levels.
 This is a utility function to use when you have a collection of objects
 representing runs of text in logical order, each run containing text
 at a single level.  The elements at <code>index</code> from
 <code>objectStart</code> up to <code>objectStart + count</code>
 in the objects array will be reordered into visual order assuming
 each run of text has the level indicated by the corresponding element
 in the levels array (at <code>index - objectStart + levelStart</code>).
@param {Object {byte[]}} levels an array representing the bidi level of each object
@param {Number} levelStart the start position in the levels array
@param {Object {java.lang.Object[]}} objects the array of objects to be reordered into visual order
@param {Number} objectStart the start position in the objects array
@param {Number} count the number of objects to reorder
*/
reorderVisually : function(  ) {},

/**Display the bidi internal state, used in debugging.
*/
toString : function(  ) {},


};