diff --git a/include/gdi.h b/include/gdi.h index 930a032c..724ede16 100644 --- a/include/gdi.h +++ b/include/gdi.h @@ -9666,28 +9666,29 @@ MG_EXPORT Uint32 GUIAPI GetACharType (LOGFONT* logfont, Achar32 chv); #define BIDI_MASK_RTL 0x0001 /* Is right to left */ #define BIDI_MASK_ARABIC 0x0002 /* Is arabic */ -#define BIDI_MASK_NSM 0x0004 -#define BIDI_MASK_BN 0x0008 +#define BIDI_MASK_FIRST 0x0004 /* Whether direction is determined by first strong */ +#define BIDI_MASK_BN 0x0008 /* flag for BN */ -/* Each char can be only one of the three following. */ #define BIDI_SWN_MASK 0x0030 -#define BIDI_MASK_STRONG 0x0010 /* Is strong */ -#define BIDI_MASK_WEAK 0x0020 /* Is weak */ -#define BIDI_MASK_NEUTRAL 0x0030 /* Is neutral */ +#define BIDI_MASK_STRONG 0x0000 /* Is strong */ +#define BIDI_MASK_WEAK 0x0010 /* Is weak */ +#define BIDI_MASK_NEUTRAL 0x0020 /* Is neutral */ #define BIDI_MASK_WS 0x0040 #define BIDI_MASK_SENTINEL 0x0080 /* Is sentinel: SOT, EOT */ -/* Each char can be only one of the five following. */ +/* Each char can be only one of the seven following. */ #define BIDI_TYPE_MASK 0x0F00 #define BIDI_MASK_LETTER 0x0100 /* Is letter: L, R, AL */ #define BIDI_MASK_NUMBER 0x0200 /* Is number: EN, AN */ #define BIDI_MASK_NUMSEPTER 0x0300 /* Is number separator or terminator: ES, ET, CS */ #define BIDI_MASK_SPACE 0x0400 /* Is space: BN, BS, SS, WS */ #define BIDI_MASK_EXPLICIT 0x0500 /* Is expilict mark: LRE, RLE, LRO, RLO, PDF */ +#define BIDI_MASK_ISOLATE 0x0600 /* Is isolate mark: LRI, RLI, FSI, PDI */ +#define BIDI_MASK_NSM 0x0700 /* Is non spacing mark: NSM */ /* Can be on only if BIDI_MASK_SPACE is also on. */ -#define BIDI_MASK_SEPARATOR 0x0800 /* Is test separator: BS, SS */ +#define BIDI_MASK_SEPARATOR 0x0800 /* Is separator: BS, SS */ /* Can be on only if BIDI_MASK_EXPLICIT is also on. */ #define BIDI_MASK_OVERRIDE 0x8000 /* Is explicit override: LRO, RLO */ @@ -9711,121 +9712,108 @@ MG_EXPORT Uint32 GUIAPI GetACharType (LOGFONT* logfont, Achar32 chv); * \def BIDI_TYPE_LTR * \brief Strong left to right */ -#define BIDI_TYPE_LTR (BIDI_MASK_STRONG + BIDI_MASK_LETTER) +#define BIDI_TYPE_LTR (BIDI_MASK_STRONG | BIDI_MASK_LETTER) /** * \def BIDI_TYPE_RTL * \brief Right to left characters */ -#define BIDI_TYPE_RTL (BIDI_MASK_STRONG + BIDI_MASK_LETTER \ - + BIDI_MASK_RTL) +#define BIDI_TYPE_RTL (BIDI_MASK_STRONG | BIDI_MASK_LETTER | BIDI_MASK_RTL) /** * \def BIDI_TYPE_AL * \brief Arabic characters */ -#define BIDI_TYPE_AL (BIDI_MASK_STRONG + BIDI_MASK_LETTER \ - + BIDI_MASK_RTL + BIDI_MASK_ARABIC) +#define BIDI_TYPE_AL (BIDI_MASK_STRONG | BIDI_MASK_LETTER | BIDI_MASK_RTL | BIDI_MASK_ARABIC) /** * \def BIDI_TYPE_LRE * \brief Left-To-Right embedding */ -#define BIDI_TYPE_LRE (BIDI_MASK_STRONG + BIDI_MASK_EXPLICIT) +#define BIDI_TYPE_LRE (BIDI_MASK_STRONG | BIDI_MASK_EXPLICIT) /** * \def BIDI_TYPE_RLE * \brief Right-To-Left embedding */ -#define BIDI_TYPE_RLE (BIDI_MASK_STRONG + BIDI_MASK_EXPLICIT \ - + BIDI_MASK_RTL) +#define BIDI_TYPE_RLE (BIDI_MASK_STRONG | BIDI_MASK_EXPLICIT | BIDI_MASK_RTL) /** * \def BIDI_TYPE_LRO * \brief Left-To-Right override */ -#define BIDI_TYPE_LRO (BIDI_MASK_STRONG + BIDI_MASK_EXPLICIT \ - + BIDI_MASK_OVERRIDE) +#define BIDI_TYPE_LRO (BIDI_MASK_STRONG | BIDI_MASK_EXPLICIT | BIDI_MASK_OVERRIDE) /** * \def BIDI_TYPE_RLO * \brief Right-To-Left override */ -#define BIDI_TYPE_RLO (BIDI_MASK_STRONG + BIDI_MASK_EXPLICIT \ - + BIDI_MASK_RTL + BIDI_MASK_OVERRIDE) +#define BIDI_TYPE_RLO (BIDI_MASK_STRONG | BIDI_MASK_EXPLICIT | BIDI_MASK_RTL | BIDI_MASK_OVERRIDE) /** * \def BIDI_TYPE_PDF * \brief Pop directional override */ -#define BIDI_TYPE_PDF (BIDI_MASK_WEAK + BIDI_MASK_EXPLICIT) +#define BIDI_TYPE_PDF (BIDI_MASK_WEAK | BIDI_MASK_EXPLICIT) /** * \def BIDI_TYPE_EN * \brief European digit */ -#define BIDI_TYPE_EN (BIDI_MASK_WEAK + BIDI_MASK_NUMBER) +#define BIDI_TYPE_EN (BIDI_MASK_WEAK | BIDI_MASK_NUMBER) /** * \def BIDI_TYPE_AN * \brief Arabic digit */ -#define BIDI_TYPE_AN (BIDI_MASK_WEAK + BIDI_MASK_NUMBER \ - + BIDI_MASK_ARABIC) +#define BIDI_TYPE_AN (BIDI_MASK_WEAK | BIDI_MASK_NUMBER | BIDI_MASK_ARABIC) /** * \def BIDI_TYPE_ES * \brief European number separator */ -#define BIDI_TYPE_ES (BIDI_MASK_WEAK + BIDI_MASK_NUMSEPTER \ - + BIDI_MASK_ES) +#define BIDI_TYPE_ES (BIDI_MASK_WEAK | BIDI_MASK_NUMSEPTER | BIDI_MASK_ES) /** * \def BIDI_TYPE_ET * \brief European number terminator */ -#define BIDI_TYPE_ET (BIDI_MASK_WEAK + BIDI_MASK_NUMSEPTER \ - + BIDI_MASK_ET) +#define BIDI_TYPE_ET (BIDI_MASK_WEAK | BIDI_MASK_NUMSEPTER | BIDI_MASK_ET) /** * \def BIDI_TYPE_CS * \brief Common Separator */ -#define BIDI_TYPE_CS (BIDI_MASK_WEAK + BIDI_MASK_NUMSEPTER \ - + BIDI_MASK_CS) +#define BIDI_TYPE_CS (BIDI_MASK_WEAK | BIDI_MASK_NUMSEPTER | BIDI_MASK_CS) /** * \def BIDI_TYPE_NSM * \brief Non spacing mark */ -#define BIDI_TYPE_NSM (BIDI_MASK_WEAK + BIDI_MASK_NSM) +#define BIDI_TYPE_NSM (BIDI_MASK_WEAK | BIDI_MASK_NSM) /** * \def BIDI_TYPE_BN * \brief Boundary neutral */ -#define BIDI_TYPE_BN (BIDI_MASK_WEAK + BIDI_MASK_SPACE \ - + BIDI_MASK_BN) +#define BIDI_TYPE_BN (BIDI_MASK_WEAK | BIDI_MASK_SPACE | BIDI_MASK_BN) /** * \def BIDI_TYPE_BS - * \brief Block separator + * \brief Block separator (Paragraph separator) */ -#define BIDI_TYPE_BS (BIDI_MASK_NEUTRAL + BIDI_MASK_SPACE \ - + BIDI_MASK_SEPARATOR + BIDI_MASK_BS) +#define BIDI_TYPE_BS (BIDI_MASK_NEUTRAL | BIDI_MASK_SPACE | BIDI_MASK_SEPARATOR | BIDI_MASK_BS) /** * \def BIDI_TYPE_SS * \brief Segment separator */ -#define BIDI_TYPE_SS (BIDI_MASK_NEUTRAL + BIDI_MASK_SPACE \ - + BIDI_MASK_SEPARATOR + BIDI_MASK_SS) +#define BIDI_TYPE_SS (BIDI_MASK_NEUTRAL | BIDI_MASK_SPACE | BIDI_MASK_SEPARATOR | BIDI_MASK_SS) /** * \def BIDI_TYPE_WS * \brief Whitespace */ -#define BIDI_TYPE_WS (BIDI_MASK_NEUTRAL + BIDI_MASK_SPACE \ - + BIDI_MASK_WS) +#define BIDI_TYPE_WS (BIDI_MASK_NEUTRAL | BIDI_MASK_SPACE | BIDI_MASK_WS) /** * \def BIDI_TYPE_ON @@ -9833,20 +9821,32 @@ MG_EXPORT Uint32 GUIAPI GetACharType (LOGFONT* logfont, Achar32 chv); */ #define BIDI_TYPE_ON (BIDI_MASK_NEUTRAL) +/** + * \def BIDI_TYPE_LRI + * \brief Left-to-Right Isolate + */ +#define BIDI_TYPE_LRI (BIDI_MASK_NEUTRAL | BIDI_MASK_ISOLATE) + +/** + * \def BIDI_TYPE_RLI + * \brief Right-to-Left Isolate + */ +#define BIDI_TYPE_RLI (BIDI_MASK_NEUTRAL | BIDI_MASK_ISOLATE | BIDI_MASK_RTL) + +/** + * \def BIDI_TYPE_FSI + * \brief First Strong Isolate + */ +#define BIDI_TYPE_FSI (BIDI_MASK_NEUTRAL | BIDI_MASK_ISOLATE | BIDI_MASK_FIRST) + +/** + * \def BIDI_TYPE_PDI + * \brief Pop Directional Isolate + */ +#define BIDI_TYPE_PDI (BIDI_MASK_NEUTRAL | BIDI_MASK_WEAK | BIDI_MASK_ISOLATE) + /** @} end of glyph_bidi_types */ -/* The following are used to identify the paragraph direction, - types L, R, N are not used internally anymore, and recommended to use - LTR, RTL and ON instead, didn't removed because of compatability. */ - -#define BIDI_TYPE_L (BIDI_TYPE_LTR) -#define BIDI_TYPE_R (BIDI_TYPE_RTL) -#define BIDI_TYPE_N (BIDI_TYPE_ON) -/* Weak left to right */ -#define BIDI_TYPE_WL (BIDI_MASK_WEAK) -/* Weak right to left */ -#define BIDI_TYPE_WR (BIDI_MASK_WEAK + BIDI_MASK_RTL) - /* The following are only used internally */ /* Start of text */ @@ -9871,11 +9871,11 @@ MG_EXPORT Uint32 GUIAPI GetACharType (LOGFONT* logfont, Achar32 chv); #define BIDI_IS_ARABIC(p) ((p) & BIDI_MASK_ARABIC) /* Is strong? */ -#define BIDI_IS_STRONG(p) (((p) & BIDI_SWN_MASK) == BIDI_MASK_STRONG) +#define BIDI_IS_STRONG(p) (!((p) & BIDI_SWN_MASK)) /* Is weak? */ -#define BIDI_IS_WEAK(p) (((p) & BIDI_SWN_MASK) == BIDI_MASK_WEAK) +#define BIDI_IS_WEAK(p) ((p) & BIDI_MASK_WEAK) /* Is neutral? */ -#define BIDI_IS_NEUTRAL(p) (((p) & BIDI_SWN_MASK) == BIDI_MASK_NEUTRAL) +#define BIDI_IS_NEUTRAL(p) ((p) & BIDI_MASK_NEUTRAL) /* Is sentinel? */ #define BIDI_IS_SENTINEL(p) ((p) & BIDI_MASK_SENTINEL) diff --git a/src/font/charset-bidi.c b/src/font/charset-bidi.c index 5fb5452a..9da6fce3 100644 --- a/src/font/charset-bidi.c +++ b/src/font/charset-bidi.c @@ -1,39 +1,39 @@ /* - * This file is part of MiniGUI, a mature cross-platform windowing + * This file is part of MiniGUI, a mature cross-platform windowing * and Graphics User Interface (GUI) support system for embedded systems * and smart IoT devices. - * + * * Copyright (C) 2002~2018, Beijing FMSoft Technologies Co., Ltd. * Copyright (C) 1998~2002, WEI Yongming - * + * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. - * + * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. - * + * * You should have received a copy of the GNU General Public License * along with this program. If not, see . - * + * * Or, - * + * * As this program is a library, any link to this program must follow * GNU General Public License version 3 (GPLv3). If you cannot accept * GPLv3, you need to be licensed from FMSoft. - * + * * If you have got a commercial license of this program, please use it * under the terms and conditions of the commercial license. - * + * * For more information about the commercial license, please refer to * . */ /* ** charset-bidi.c: The charset Bidirectional Algorithm. -** +** ** Created by houhuihua at 2008/01/23 */ #include @@ -63,14 +63,14 @@ struct _TYPERUN struct _TYPERUN *prev; struct _TYPERUN *next; - Uint32 type; /* char type. */ - int pos, len; /* run start position、run len.*/ - BYTE level; /* Embedding level. */ + int pos, len; /* run start position, run len.*/ + Uint16 type; /* char type. */ + BYTE level; /* embedding level. */ }; #ifdef BIDI_DEBUG -static char bidi_type_name(Uint32 c) +static char bidi_type_name(Uint16 c) { switch (c){ case BIDI_TYPE_LTR: return 'L'; @@ -126,12 +126,12 @@ static void print_run_types(TYPERUN *pp) } else sprintf(level_str, "%c", bidi_level[(int)pp->level]); - fprintf(stderr, "pos:%d:len:%d(%c)[level:%s] || ", pp->pos, pp->len, + fprintf(stderr, "pos:%d:len:%d(%c)[level:%s] || ", pp->pos, pp->len, bidi_type_name(pp->type), level_str); pp = pp->next; } fprintf (stderr, "\n"); -} +} static void print_hexstr(Achar32* str, int len, BOOL reorder_state) { @@ -286,7 +286,7 @@ static void bidi_resolveExplicit (TYPERUN **ptype_rl_list, Uint32 base_dir) } /* 3.Resolving weak types */ -static void bidi_resolveWeak(TYPERUN **ptype_rl_list, Uint32 base_dir) +static void bidi_resolveWeak(TYPERUN **ptype_rl_list, Uint32 base_dir) { TYPERUN *type_rl_list = *ptype_rl_list, *pp = NULL; Uint32 last_strong, prev_type_org; @@ -328,7 +328,7 @@ static void bidi_resolveWeak(TYPERUN **ptype_rl_list, Uint32 base_dir) last_strong = base_dir; /* Resolving dependency of loops for rules W4 and W5, W5 may - want to prevent W4 to take effect in the next turn, do this + want to prevent W4 to take effect in the next turn, do this through "w4". */ w4 = TRUE; /* Resolving dependency of loops for rules W4 and W5 with W7, @@ -427,8 +427,8 @@ static void bidi_resolveNeutrals(TYPERUN **ptype_rl_list, Uint32 base_bir) if (BIDI_IS_NEUTRAL (this_type)) TYPE (pp) = (prev_type == next_type) ? - prev_type : /* N1. */ - BIDI_EMBEDDING_DIR(pp); /* N2. */ + prev_type : /* N1. */ + BIDI_EMBEDDING_DIR(pp); /* N2. */ } compact_list (type_rl_list); #ifdef BIDI_DEBUG @@ -472,8 +472,8 @@ static int bidi_resolveImplicit(TYPERUN **ptype_rl_list, int base_level) } /* 6.Resolving Mirrored Char. */ -static void -bidi_resolveMirrorChar (const CHARSETOPS* charset_ops, Achar32* achars, int len, +static void +bidi_resolveMirrorChar (const CHARSETOPS* charset_ops, Achar32* achars, int len, TYPERUN **ptype_rl_list, int base_level) { TYPERUN *type_rl_list = *ptype_rl_list, *pp = NULL; @@ -487,7 +487,8 @@ bidi_resolveMirrorChar (const CHARSETOPS* charset_ops, Achar32* achars, int len, for (i = POS (pp); i < POS (pp) + LEN (pp); i++) { Achar32 mirrored_ch; - if (charset_ops->bidi_mirror_char && charset_ops->bidi_mirror_char (achars[i], &mirrored_ch)) + if (charset_ops->bidi_mirror_char && + charset_ops->bidi_mirror_char (achars[i], &mirrored_ch)) achars[i] = mirrored_ch; } } @@ -501,7 +502,7 @@ static void bidi_resolve_string (const CHARSETOPS* charset_ops, TYPERUN **ptype_rl_list, BYTE *pmax_level) { BYTE base_level = 0; - Uint32 base_dir = BIDI_TYPE_L; + Uint32 base_dir = BIDI_TYPE_LTR; TYPERUN *type_rl_list = NULL; /* split the text to some runs. */ @@ -736,7 +737,7 @@ Uint32 __mg_charset_bidi_str_base_dir (const CHARSETOPS* charset_ops, Achar32* achars, int len) { BYTE base_level = 0; - Uint32 base_dir = BIDI_TYPE_L; + Uint32 base_dir = BIDI_TYPE_LTR; TYPERUN *type_rl_list = NULL; /* split the text to some runs. */ diff --git a/src/font/unicode-bidi-tables.h b/src/font/unicode-bidi-tables.h index 0d0f7498..979c8405 100644 --- a/src/font/unicode-bidi-tables.h +++ b/src/font/unicode-bidi-tables.h @@ -1,404 +1,1686 @@ +/* == Start of generated table == */ /* - * This file is part of MiniGUI, a mature cross-platform windowing - * and Graphics User Interface (GUI) support system for embedded systems - * and smart IoT devices. - * - * Copyright (C) 2002~2018, Beijing FMSoft Technologies Co., Ltd. - * Copyright (C) 1998~2002, WEI Yongming - * - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation, either version 3 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program. If not, see . - * - * Or, - * - * As this program is a library, any link to this program must follow - * GNU General Public License version 3 (GPLv3). If you cannot accept - * GPLv3, you need to be licensed from FMSoft. - * - * If you have got a commercial license of this program, please use it - * under the terms and conditions of the commercial license. - * - * For more information about the commercial license, please refer to - * . + * The following table is generated by running: + * + * ./gen-bidi-tables.py + * + * on ucd/extracted/DerivedBidiClass.txt, ucd/BidiBrackets.txt, and ucd/BidiMirroring.txt files with these headers: + * + * UnicodeData.txt does not have a header. + * # DerivedBidiClass-11.0.0.txt + * # Date: 2018-02-21, 05:34:00 GMT + * # BidiBrackets-11.0.0.txt + * # Date: 2018-02-18, 05:50:00 GMT [AG, LI, KW] + * # BidiMirroring-11.0.0.txt + * # Date: 2018-05-07, 18:02:00 GMT [KW, LI, RP] */ -/* -** unicode-bidi-tables.h: the Unicode BIDI tables. -** -** Created by VincentWei at 2018/08/27 -*/ #ifndef _UNICODE_BIDI_TABLES_H #define _UNICODE_BIDI_TABLES_H -typedef struct _bidichar_type_map +static const BIDICHAR_TYPE_MAP __mg_unicode_bidi_char_type_map[] = { - Uint16 type; // Type of Unicode characters - Uchar32 chv; // Starting index of Unicode character - Uint8 count; // Total number of Unicode characters of same type starting from glyphn -} BIDICHAR_TYPE_MAP; - -static const BIDICHAR_TYPE_MAP __mg_unicode_bidi_char_type_map []= -{ - { BIDI_TYPE_ON, 0x0000, 0x06}, - { BIDI_TYPE_NSM, 0x0006, 0x04}, - { BIDI_TYPE_BS, 0x000a, 0x01}, - { BIDI_TYPE_ON, 0x000b, 0x02}, - { BIDI_TYPE_BS, 0x000d, 0x01}, - { BIDI_TYPE_ON, 0x000e, 0x05}, - { BIDI_TYPE_WS, 0x0013, 0x01}, - { BIDI_TYPE_ON, 0x0014, 0x08}, - { BIDI_TYPE_ON, 0x001c, 0x04}, - { BIDI_TYPE_WS, 0x0020, 0x01}, - { BIDI_TYPE_ON, 0x0021, 0x02}, - { BIDI_TYPE_ET, 0x0023, 0x03}, - { BIDI_TYPE_ON, 0x0026, 0x05}, - { BIDI_TYPE_ET, 0x002b, 0x01}, - { BIDI_TYPE_CS, 0x002c, 0x01}, - { BIDI_TYPE_ES, 0x002d, 0x01}, - { BIDI_TYPE_CS, 0x002e, 0x02}, - { BIDI_TYPE_EN, 0x0030, 0x0a}, - { BIDI_TYPE_CS, 0x003a, 0x01}, - { BIDI_TYPE_ON, 0x003b, 0x06}, - { BIDI_TYPE_LTR, 0x0041, 0x1a}, - { BIDI_TYPE_ON, 0x005b, 0x02}, - { BIDI_TYPE_ON, 0x005d, 0x03}, - { BIDI_TYPE_NSM, 0x0060, 0x01}, - { BIDI_TYPE_LTR, 0x0061, 0x1a}, - { BIDI_TYPE_ON, 0x007b, 0x01}, - { BIDI_TYPE_SS, 0x007c, 0x01}, - { BIDI_TYPE_ON, 0x007d, 0x03}, - { BIDI_TYPE_BN, 0x0080, 0x05}, - { BIDI_TYPE_BS, 0x0085, 0x01}, - { BIDI_TYPE_BN, 0x0086, 0x1a}, - { BIDI_TYPE_CS, 0x00a0, 0x01}, - { BIDI_TYPE_ON, 0x00a1, 0x01}, - { BIDI_TYPE_ET, 0x00a2, 0x04}, - { BIDI_TYPE_ON, 0x00a6, 0x04}, - { BIDI_TYPE_LTR, 0x00aa, 0x01}, - { BIDI_TYPE_ON, 0x00ab, 0x05}, - { BIDI_TYPE_ET, 0x00b0, 0x02}, - { BIDI_TYPE_EN, 0x00b2, 0x02}, - { BIDI_TYPE_ON, 0x00b4, 0x01}, - { BIDI_TYPE_LTR, 0x00b5, 0x01}, - { BIDI_TYPE_ON, 0x00b6, 0x03}, - { BIDI_TYPE_EN, 0x00b9, 0x01}, - { BIDI_TYPE_LTR, 0x00ba, 0x01}, - { BIDI_TYPE_ON, 0x00bb, 0x05}, - { BIDI_TYPE_LTR, 0x00c0, 0x17}, - { BIDI_TYPE_ON, 0x00d7, 0x01}, - { BIDI_TYPE_LTR, 0x00d8, 0x1f}, - { BIDI_TYPE_ON, 0x00f7, 0x01}, - { BIDI_TYPE_LTR, 0x00f8, 0x29}, - { BIDI_TYPE_LTR, 0x0222, 0x12}, - { BIDI_TYPE_LTR, 0x0250, 0x5e}, - { BIDI_TYPE_LTR, 0x02b0, 0x09}, - { BIDI_TYPE_ON, 0x02b9, 0x02}, - { BIDI_TYPE_LTR, 0x02bb, 0x07}, - { BIDI_TYPE_ON, 0x02c2, 0x0e}, - { BIDI_TYPE_LTR, 0x02d0, 0x02}, - { BIDI_TYPE_ON, 0x02d2, 0x0e}, - { BIDI_TYPE_LTR, 0x02e0, 0x05}, - { BIDI_TYPE_ON, 0x02e5, 0x09}, - { BIDI_TYPE_LTR, 0x02ee, 0x01}, - { BIDI_TYPE_NSM, 0x0300, 0x50}, - { BIDI_TYPE_NSM, 0x0360, 0x10}, - { BIDI_TYPE_LTR, 0x0400, 0x83}, - { BIDI_TYPE_NSM, 0x0483, 0x04}, - { BIDI_TYPE_NSM, 0x0488, 0x02}, - { BIDI_TYPE_LTR, 0x048a, 0x45}, - { BIDI_TYPE_LTR, 0x04d0, 0x26}, - { BIDI_TYPE_LTR, 0x04f8, 0x02}, - { BIDI_TYPE_LTR, 0x0500, 0x10}, - { BIDI_TYPE_AL, 0x0591, 0x11}, - { BIDI_TYPE_AL, 0x05a3, 0x17}, - { BIDI_TYPE_AL, 0x05bb, 0x0A}, - { BIDI_TYPE_AL, 0x05d0, 0x1B}, - { BIDI_TYPE_AL, 0x05f0, 0x05}, - { BIDI_TYPE_CS, 0x060c, 0x01}, - { BIDI_TYPE_AL, 0x061b, 0x01}, - { BIDI_TYPE_AL, 0x061f, 0x01}, - { BIDI_TYPE_AL, 0x0621, 0x1a}, - { BIDI_TYPE_AL, 0x0640, 0x0b}, - { BIDI_TYPE_NSM, 0x064b, 0x0b}, - { BIDI_TYPE_AN, 0x0660, 0x0a}, - { BIDI_TYPE_ET, 0x066a, 0x01}, - { BIDI_TYPE_AN, 0x066b, 0x02}, - { BIDI_TYPE_AL, 0x066d, 0x03}, - { BIDI_TYPE_NSM, 0x0670, 0x01}, - { BIDI_TYPE_AL, 0x0671, 0x65}, - { BIDI_TYPE_NSM, 0x06d6, 0x07}, - { BIDI_TYPE_AL, 0x06dd, 0x01}, - { BIDI_TYPE_NSM, 0x06de, 0x07}, - { BIDI_TYPE_AL, 0x06e5, 0x02}, - { BIDI_TYPE_NSM, 0x06e7, 0x02}, - { BIDI_TYPE_ON, 0x06e9, 0x01}, - { BIDI_TYPE_NSM, 0x06ea, 0x04}, - { BIDI_TYPE_EN, 0x06f0, 0x0a}, - { BIDI_TYPE_AL, 0x06fa, 0x05}, - { BIDI_TYPE_LTR, 0x0e01, 0x30}, - { BIDI_TYPE_NSM, 0x0e31, 0x01}, - { BIDI_TYPE_LTR, 0x0e32, 0x02}, - { BIDI_TYPE_LTR, 0x0e34, 0x07}, - { BIDI_TYPE_ET, 0x0e3f, 0x01}, - { BIDI_TYPE_LTR, 0x0e40, 0x07}, - { BIDI_TYPE_LTR, 0x0e47, 0x08}, - { BIDI_TYPE_LTR, 0x0e4f, 0x0d}, - { BIDI_TYPE_LTR, 0x1e00, 0x9c}, - { BIDI_TYPE_LTR, 0x1ea0, 0x5a}, - { BIDI_TYPE_WS, 0x2000, 0x0b}, - { BIDI_TYPE_BN, 0x200b, 0x03}, - { BIDI_TYPE_LTR, 0x200e, 0x01}, - { BIDI_TYPE_RTL, 0x200f, 0x01}, - { BIDI_TYPE_ON, 0x2010, 0x18}, - { BIDI_TYPE_WS, 0x2028, 0x01}, - { BIDI_TYPE_BS, 0x2029, 0x01}, - { BIDI_TYPE_LRE, 0x202a, 0x01}, - { BIDI_TYPE_RLE, 0x202b, 0x01}, - { BIDI_TYPE_PDF, 0x202c, 0x01}, - { BIDI_TYPE_LRO, 0x202d, 0x01}, - { BIDI_TYPE_RLO, 0x202e, 0x01}, - { BIDI_TYPE_WS, 0x202f, 0x01}, - { BIDI_TYPE_ET, 0x2030, 0x05}, - { BIDI_TYPE_ON, 0x2035, 0x1e}, - { BIDI_TYPE_ON, 0x2057, 0x01}, - { BIDI_TYPE_WS, 0x205f, 0x01}, - { BIDI_TYPE_BN, 0x2060, 0x04}, - { BIDI_TYPE_BN, 0x206a, 0x06}, - { BIDI_TYPE_EN, 0x2070, 0x01}, - { BIDI_TYPE_LTR, 0x2071, 0x01}, - { BIDI_TYPE_EN, 0x2074, 0x06}, - { BIDI_TYPE_ET, 0x207a, 0x02}, - { BIDI_TYPE_ON, 0x207c, 0x03}, - { BIDI_TYPE_LTR, 0x207f, 0x01}, - { BIDI_TYPE_EN, 0x2080, 0x0a}, - { BIDI_TYPE_ET, 0x208a, 0x02}, - { BIDI_TYPE_ON, 0x208c, 0x03}, - { BIDI_TYPE_ET, 0x20a0, 0x12}, - { BIDI_TYPE_NSM, 0x20d0, 0x1b}, - { BIDI_TYPE_ON, 0x2100, 0x02}, - { BIDI_TYPE_LTR, 0x2102, 0x01}, - { BIDI_TYPE_ON, 0x2103, 0x04}, - { BIDI_TYPE_LTR, 0x2107, 0x01}, - { BIDI_TYPE_ON, 0x2108, 0x02}, - { BIDI_TYPE_LTR, 0x210a, 0x0a}, - { BIDI_TYPE_ON, 0x2114, 0x01}, - { BIDI_TYPE_LTR, 0x2115, 0x01}, - { BIDI_TYPE_ON, 0x2116, 0x03}, - { BIDI_TYPE_LTR, 0x2119, 0x05}, - { BIDI_TYPE_ON, 0x211e, 0x06}, - { BIDI_TYPE_LTR, 0x2124, 0x01}, - { BIDI_TYPE_ON, 0x2125, 0x01}, - { BIDI_TYPE_LTR, 0x2126, 0x01}, - { BIDI_TYPE_ON, 0x2127, 0x01}, - { BIDI_TYPE_LTR, 0x2128, 0x01}, - { BIDI_TYPE_ON, 0x2129, 0x01}, - { BIDI_TYPE_LTR, 0x212a, 0x04}, - { BIDI_TYPE_ET, 0x212e, 0x01}, - { BIDI_TYPE_LTR, 0x212f, 0x03}, - { BIDI_TYPE_ON, 0x2132, 0x01}, - { BIDI_TYPE_LTR, 0x2133, 0x07}, - { BIDI_TYPE_ON, 0x213a, 0x01}, - { BIDI_TYPE_LTR, 0x213d, 0x03}, - { BIDI_TYPE_ON, 0x2140, 0x05}, - { BIDI_TYPE_LTR, 0x2145, 0x05}, - { BIDI_TYPE_ON, 0x214a, 0x02}, - { BIDI_TYPE_ON, 0x2153, 0x0d}, - { BIDI_TYPE_LTR, 0x2160, 0x24}, - { BIDI_TYPE_ON, 0x2190, 0x82}, - { BIDI_TYPE_ET, 0x2212, 0x02}, - { BIDI_TYPE_ON, 0x2214, 0x22}, - { BIDI_TYPE_LTR, 0x2336, 0x45}, - { BIDI_TYPE_ON, 0x237b, 0x1a}, - { BIDI_TYPE_LTR, 0x2395, 0x01}, - { BIDI_TYPE_ON, 0x2396, 0x39}, - { BIDI_TYPE_ON, 0x2400, 0x27}, - { BIDI_TYPE_ON, 0x2440, 0x0b}, - { BIDI_TYPE_EN, 0x2460, 0x3c}, - { BIDI_TYPE_LTR, 0x249c, 0x4e}, - { BIDI_TYPE_EN, 0x24ea, 0x01}, - { BIDI_TYPE_ON, 0x24eb, 0x14}, - { BIDI_TYPE_ON, 0x2500, 0x14}, - { BIDI_TYPE_ON, 0x2616, 0x02}, - { BIDI_TYPE_ON, 0x2619, 0x65}, - { BIDI_TYPE_ON, 0x2680, 0x0a}, - { BIDI_TYPE_ON, 0x2701, 0x04}, - { BIDI_TYPE_ON, 0x2706, 0x04}, - { BIDI_TYPE_ON, 0x270c, 0x1c}, - { BIDI_TYPE_ON, 0x2729, 0x23}, - { BIDI_TYPE_ON, 0x274d, 0x01}, - { BIDI_TYPE_ON, 0x274f, 0x04}, - { BIDI_TYPE_ON, 0x2756, 0x01}, - { BIDI_TYPE_ON, 0x2758, 0x07}, - { BIDI_TYPE_ON, 0x2761, 0x34}, - { BIDI_TYPE_ON, 0x2798, 0x18}, - { BIDI_TYPE_ON, 0x27b1, 0x0e}, - { BIDI_TYPE_ON, 0x27d0, 0x1c}, - { BIDI_TYPE_ON, 0x27f0, 0x10}, - { BIDI_TYPE_ON, 0x2e80, 0x1a}, - { BIDI_TYPE_ON, 0x2e9b, 0x59}, - { BIDI_TYPE_ON, 0x2f00, 0xd6}, - { BIDI_TYPE_ON, 0x2ff0, 0x0c}, - { BIDI_TYPE_WS, 0x3000, 0x01}, - { BIDI_TYPE_ON, 0x3001, 0x04}, - { BIDI_TYPE_LTR, 0x3005, 0x03}, - { BIDI_TYPE_ON, 0x3008, 0x19}, - { BIDI_TYPE_LTR, 0x3021, 0x09}, - { BIDI_TYPE_NSM, 0x302a, 0x06}, - { BIDI_TYPE_ON, 0x3030, 0x01}, - { BIDI_TYPE_LTR, 0x3031, 0x05}, - { BIDI_TYPE_ON, 0x3036, 0x02}, - { BIDI_TYPE_LTR, 0x3038, 0x05}, - { BIDI_TYPE_ON, 0x303d, 0x03}, - { BIDI_TYPE_LTR, 0x3041, 0x56}, - { BIDI_TYPE_NSM, 0x3099, 0x02}, - { BIDI_TYPE_ON, 0x309b, 0x02}, - { BIDI_TYPE_LTR, 0x309d, 0x03}, - { BIDI_TYPE_ON, 0x30a0, 0x01}, - { BIDI_TYPE_LTR, 0x30a1, 0x5a}, - { BIDI_TYPE_ON, 0x30fb, 0x01}, - { BIDI_TYPE_LTR, 0x30fc, 0x04}, - { BIDI_TYPE_LTR, 0x3105, 0x28}, - { BIDI_TYPE_LTR, 0x3131, 0x5e}, - { BIDI_TYPE_LTR, 0x3190, 0x28}, - { BIDI_TYPE_LTR, 0x31f0, 0x2d}, - { BIDI_TYPE_LTR, 0x3220, 0x24}, - { BIDI_TYPE_ON, 0x3251, 0x0f}, - { BIDI_TYPE_LTR, 0x3260, 0x1c}, - { BIDI_TYPE_LTR, 0x327f, 0x32}, - { BIDI_TYPE_ON, 0x32b1, 0x0f}, - { BIDI_TYPE_LTR, 0x32c0, 0x0c}, - { BIDI_TYPE_LTR, 0x32d0, 0x2f}, - { BIDI_TYPE_LTR, 0x3300, 0x77}, - { BIDI_TYPE_LTR, 0x337b, 0x63}, - { BIDI_TYPE_LTR, 0x33e0, 0x1f}, - { BIDI_TYPE_LTR, 0x3400, 0x01}, - { BIDI_TYPE_LTR, 0x4db5, 0x01}, - { BIDI_TYPE_LTR, 0x4e00, 0x01}, - { BIDI_TYPE_LTR, 0x9fa5, 0x01}, - { BIDI_TYPE_ON, 0xEA00, 0xFF}, - { BIDI_TYPE_ON, 0xEB00, 0xFF}, - { BIDI_TYPE_ON, 0xEC00, 0xFF}, - { BIDI_TYPE_ON, 0xED00, 0xFF}, - { BIDI_TYPE_ON, 0xEE00, 0xFF}, - { BIDI_TYPE_ON, 0xEF00, 0xFF}, - { BIDI_TYPE_LTR, 0xf900, 0x2e}, - { BIDI_TYPE_LTR, 0xfa30, 0x3b}, - { BIDI_TYPE_LTR, 0xfb00, 0x07}, - { BIDI_TYPE_AL, 0xfb50, 0x62}, - { BIDI_TYPE_AL, 0xfbd3, 0x6b}, - { BIDI_TYPE_AL, 0xfc3f, 0x01}, - { BIDI_TYPE_AL, 0xfc40, 0x10}, - { BIDI_TYPE_AL, 0xfc60, 0x90}, - { BIDI_TYPE_AL, 0xfd0a, 0x07}, - { BIDI_TYPE_AL, 0xfd20, 0x10}, - { BIDI_TYPE_AL, 0xfd30, 0x0c}, - { BIDI_TYPE_ON, 0xfd3e, 0x02}, - { BIDI_TYPE_AL, 0xfd50, 0x40}, - { BIDI_TYPE_AL, 0xfd92, 0x36}, - { BIDI_TYPE_AL, 0xfdf0, 0x0d}, - { BIDI_TYPE_NSM, 0xfe00, 0x10}, - { BIDI_TYPE_NSM, 0xfe20, 0x04}, - { BIDI_TYPE_ON, 0xfe30, 0x17}, - { BIDI_TYPE_ON, 0xfe49, 0x07}, - { BIDI_TYPE_CS, 0xfe50, 0x01}, - { BIDI_TYPE_ON, 0xfe51, 0x01}, - { BIDI_TYPE_CS, 0xfe52, 0x01}, - { BIDI_TYPE_ON, 0xfe54, 0x01}, - { BIDI_TYPE_CS, 0xfe55, 0x01}, - { BIDI_TYPE_ON, 0xfe56, 0x09}, - { BIDI_TYPE_ET, 0xfe5f, 0x01}, - { BIDI_TYPE_ON, 0xfe60, 0x02}, - { BIDI_TYPE_ET, 0xfe62, 0x02}, - { BIDI_TYPE_ON, 0xfe64, 0x03}, - { BIDI_TYPE_ON, 0xfe68, 0x01}, - { BIDI_TYPE_ET, 0xfe69, 0x02}, - { BIDI_TYPE_ON, 0xfe6b, 0x01}, - { BIDI_TYPE_AL, 0xfe70, 0x05}, - { BIDI_TYPE_AL, 0xfe76, 0x87}, - { BIDI_TYPE_BN, 0xfeff, 0x01}, - { BIDI_TYPE_ON, 0xff01, 0x02}, - { BIDI_TYPE_ET, 0xff03, 0x03}, - { BIDI_TYPE_ON, 0xff06, 0x05}, - { BIDI_TYPE_ET, 0xff0b, 0x01}, - { BIDI_TYPE_CS, 0xff0c, 0x01}, - { BIDI_TYPE_ET, 0xff0d, 0x01}, - { BIDI_TYPE_CS, 0xff0e, 0x01}, - { BIDI_TYPE_ES, 0xff0f, 0x01}, - { BIDI_TYPE_EN, 0xff10, 0x0a}, - { BIDI_TYPE_CS, 0xff1a, 0x01}, - { BIDI_TYPE_ON, 0xff1b, 0x06}, - { BIDI_TYPE_LTR, 0xff21, 0x1a}, - { BIDI_TYPE_ON, 0xff3b, 0x06}, - { BIDI_TYPE_LTR, 0xff41, 0x1a}, - { BIDI_TYPE_ON, 0xff5b, 0x0b}, - { BIDI_TYPE_LTR, 0xff66, 0x59}, - { BIDI_TYPE_LTR, 0xffc2, 0x06}, - { BIDI_TYPE_LTR, 0xffca, 0x06}, - { BIDI_TYPE_LTR, 0xffd2, 0x06}, - { BIDI_TYPE_LTR, 0xffda, 0x03}, - { BIDI_TYPE_ET, 0xffe0, 0x02}, - { BIDI_TYPE_ON, 0xffe2, 0x03}, - { BIDI_TYPE_ET, 0xffe5, 0x02}, - { BIDI_TYPE_ON, 0xffe8, 0x07}, - { BIDI_TYPE_BN, 0xfff9, 0x03}, - { BIDI_TYPE_ON, 0xfffc, 0x02}, + { 0x000000, 0x0009, BIDI_TYPE_BN }, + { 0x000009, 0x0001, BIDI_TYPE_SS }, + { 0x00000A, 0x0001, BIDI_TYPE_BS }, + { 0x00000B, 0x0001, BIDI_TYPE_SS }, + { 0x00000C, 0x0001, BIDI_TYPE_WS }, + { 0x00000D, 0x0001, BIDI_TYPE_BS }, + { 0x00000E, 0x000E, BIDI_TYPE_BN }, + { 0x00001C, 0x0003, BIDI_TYPE_BS }, + { 0x00001F, 0x0001, BIDI_TYPE_SS }, + { 0x000020, 0x0001, BIDI_TYPE_WS }, + { 0x000021, 0x0002, BIDI_TYPE_ON }, + { 0x000023, 0x0003, BIDI_TYPE_ET }, + { 0x000026, 0x0005, BIDI_TYPE_ON }, + { 0x00002B, 0x0001, BIDI_TYPE_ES }, + { 0x00002C, 0x0001, BIDI_TYPE_CS }, + { 0x00002D, 0x0001, BIDI_TYPE_ES }, + { 0x00002E, 0x0002, BIDI_TYPE_CS }, + { 0x000030, 0x000A, BIDI_TYPE_EN }, + { 0x00003A, 0x0001, BIDI_TYPE_CS }, + { 0x00003B, 0x0006, BIDI_TYPE_ON }, + { 0x000041, 0x001A, BIDI_TYPE_LTR }, + { 0x00005B, 0x0006, BIDI_TYPE_ON }, + { 0x000061, 0x001A, BIDI_TYPE_LTR }, + { 0x00007B, 0x0004, BIDI_TYPE_ON }, + { 0x00007F, 0x0006, BIDI_TYPE_BN }, + { 0x000085, 0x0001, BIDI_TYPE_BS }, + { 0x000086, 0x001A, BIDI_TYPE_BN }, + { 0x0000A0, 0x0001, BIDI_TYPE_CS }, + { 0x0000A1, 0x0001, BIDI_TYPE_ON }, + { 0x0000A2, 0x0004, BIDI_TYPE_ET }, + { 0x0000A6, 0x0004, BIDI_TYPE_ON }, + { 0x0000AA, 0x0001, BIDI_TYPE_LTR }, + { 0x0000AB, 0x0002, BIDI_TYPE_ON }, + { 0x0000AD, 0x0001, BIDI_TYPE_BN }, + { 0x0000AE, 0x0002, BIDI_TYPE_ON }, + { 0x0000B0, 0x0002, BIDI_TYPE_ET }, + { 0x0000B2, 0x0002, BIDI_TYPE_EN }, + { 0x0000B4, 0x0001, BIDI_TYPE_ON }, + { 0x0000B5, 0x0001, BIDI_TYPE_LTR }, + { 0x0000B6, 0x0003, BIDI_TYPE_ON }, + { 0x0000B9, 0x0001, BIDI_TYPE_EN }, + { 0x0000BA, 0x0001, BIDI_TYPE_LTR }, + { 0x0000BB, 0x0005, BIDI_TYPE_ON }, + { 0x0000C0, 0x0017, BIDI_TYPE_LTR }, + { 0x0000D7, 0x0001, BIDI_TYPE_ON }, + { 0x0000D8, 0x001F, BIDI_TYPE_LTR }, + { 0x0000F7, 0x0001, BIDI_TYPE_ON }, + { 0x0000F8, 0x01C1, BIDI_TYPE_LTR }, + { 0x0002B9, 0x0002, BIDI_TYPE_ON }, + { 0x0002BB, 0x0007, BIDI_TYPE_LTR }, + { 0x0002C2, 0x000E, BIDI_TYPE_ON }, + { 0x0002D0, 0x0002, BIDI_TYPE_LTR }, + { 0x0002D2, 0x000E, BIDI_TYPE_ON }, + { 0x0002E0, 0x0005, BIDI_TYPE_LTR }, + { 0x0002E5, 0x0009, BIDI_TYPE_ON }, + { 0x0002EE, 0x0001, BIDI_TYPE_LTR }, + { 0x0002EF, 0x0011, BIDI_TYPE_ON }, + { 0x000300, 0x0070, BIDI_TYPE_NSM }, + { 0x000370, 0x0004, BIDI_TYPE_LTR }, + { 0x000374, 0x0002, BIDI_TYPE_ON }, + { 0x000376, 0x0008, BIDI_TYPE_LTR }, + { 0x00037E, 0x0001, BIDI_TYPE_ON }, + { 0x00037F, 0x0005, BIDI_TYPE_LTR }, + { 0x000384, 0x0002, BIDI_TYPE_ON }, + { 0x000386, 0x0001, BIDI_TYPE_LTR }, + { 0x000387, 0x0001, BIDI_TYPE_ON }, + { 0x000388, 0x006E, BIDI_TYPE_LTR }, + { 0x0003F6, 0x0001, BIDI_TYPE_ON }, + { 0x0003F7, 0x008C, BIDI_TYPE_LTR }, + { 0x000483, 0x0007, BIDI_TYPE_NSM }, + { 0x00048A, 0x0100, BIDI_TYPE_LTR }, + { 0x00058A, 0x0001, BIDI_TYPE_ON }, + { 0x00058B, 0x0002, BIDI_TYPE_LTR }, + { 0x00058D, 0x0002, BIDI_TYPE_ON }, + { 0x00058F, 0x0001, BIDI_TYPE_ET }, + { 0x000590, 0x0001, BIDI_TYPE_RTL }, + { 0x000591, 0x002D, BIDI_TYPE_NSM }, + { 0x0005BE, 0x0001, BIDI_TYPE_RTL }, + { 0x0005BF, 0x0001, BIDI_TYPE_NSM }, + { 0x0005C0, 0x0001, BIDI_TYPE_RTL }, + { 0x0005C1, 0x0002, BIDI_TYPE_NSM }, + { 0x0005C3, 0x0001, BIDI_TYPE_RTL }, + { 0x0005C4, 0x0002, BIDI_TYPE_NSM }, + { 0x0005C6, 0x0001, BIDI_TYPE_RTL }, + { 0x0005C7, 0x0001, BIDI_TYPE_NSM }, + { 0x0005C8, 0x0038, BIDI_TYPE_RTL }, + { 0x000600, 0x0006, BIDI_TYPE_AN }, + { 0x000606, 0x0002, BIDI_TYPE_ON }, + { 0x000608, 0x0001, BIDI_TYPE_AL }, + { 0x000609, 0x0002, BIDI_TYPE_ET }, + { 0x00060B, 0x0001, BIDI_TYPE_AL }, + { 0x00060C, 0x0001, BIDI_TYPE_CS }, + { 0x00060D, 0x0001, BIDI_TYPE_AL }, + { 0x00060E, 0x0002, BIDI_TYPE_ON }, + { 0x000610, 0x000B, BIDI_TYPE_NSM }, + { 0x00061B, 0x0030, BIDI_TYPE_AL }, + { 0x00064B, 0x0015, BIDI_TYPE_NSM }, + { 0x000660, 0x000A, BIDI_TYPE_AN }, + { 0x00066A, 0x0001, BIDI_TYPE_ET }, + { 0x00066B, 0x0002, BIDI_TYPE_AN }, + { 0x00066D, 0x0003, BIDI_TYPE_AL }, + { 0x000670, 0x0001, BIDI_TYPE_NSM }, + { 0x000671, 0x0065, BIDI_TYPE_AL }, + { 0x0006D6, 0x0007, BIDI_TYPE_NSM }, + { 0x0006DD, 0x0001, BIDI_TYPE_AN }, + { 0x0006DE, 0x0001, BIDI_TYPE_ON }, + { 0x0006DF, 0x0006, BIDI_TYPE_NSM }, + { 0x0006E5, 0x0002, BIDI_TYPE_AL }, + { 0x0006E7, 0x0002, BIDI_TYPE_NSM }, + { 0x0006E9, 0x0001, BIDI_TYPE_ON }, + { 0x0006EA, 0x0004, BIDI_TYPE_NSM }, + { 0x0006EE, 0x0002, BIDI_TYPE_AL }, + { 0x0006F0, 0x000A, BIDI_TYPE_EN }, + { 0x0006FA, 0x0017, BIDI_TYPE_AL }, + { 0x000711, 0x0001, BIDI_TYPE_NSM }, + { 0x000712, 0x001E, BIDI_TYPE_AL }, + { 0x000730, 0x001B, BIDI_TYPE_NSM }, + { 0x00074B, 0x005B, BIDI_TYPE_AL }, + { 0x0007A6, 0x000B, BIDI_TYPE_NSM }, + { 0x0007B1, 0x000F, BIDI_TYPE_AL }, + { 0x0007C0, 0x002B, BIDI_TYPE_RTL }, + { 0x0007EB, 0x0009, BIDI_TYPE_NSM }, + { 0x0007F4, 0x0002, BIDI_TYPE_RTL }, + { 0x0007F6, 0x0004, BIDI_TYPE_ON }, + { 0x0007FA, 0x0003, BIDI_TYPE_RTL }, + { 0x0007FD, 0x0001, BIDI_TYPE_NSM }, + { 0x0007FE, 0x0018, BIDI_TYPE_RTL }, + { 0x000816, 0x0004, BIDI_TYPE_NSM }, + { 0x00081A, 0x0001, BIDI_TYPE_RTL }, + { 0x00081B, 0x0009, BIDI_TYPE_NSM }, + { 0x000824, 0x0001, BIDI_TYPE_RTL }, + { 0x000825, 0x0003, BIDI_TYPE_NSM }, + { 0x000828, 0x0001, BIDI_TYPE_RTL }, + { 0x000829, 0x0005, BIDI_TYPE_NSM }, + { 0x00082E, 0x002B, BIDI_TYPE_RTL }, + { 0x000859, 0x0003, BIDI_TYPE_NSM }, + { 0x00085C, 0x0004, BIDI_TYPE_RTL }, + { 0x000860, 0x0010, BIDI_TYPE_AL }, + { 0x000870, 0x0030, BIDI_TYPE_RTL }, + { 0x0008A0, 0x0033, BIDI_TYPE_AL }, + { 0x0008D3, 0x000F, BIDI_TYPE_NSM }, + { 0x0008E2, 0x0001, BIDI_TYPE_AN }, + { 0x0008E3, 0x0020, BIDI_TYPE_NSM }, + { 0x000903, 0x0037, BIDI_TYPE_LTR }, + { 0x00093A, 0x0001, BIDI_TYPE_NSM }, + { 0x00093B, 0x0001, BIDI_TYPE_LTR }, + { 0x00093C, 0x0001, BIDI_TYPE_NSM }, + { 0x00093D, 0x0004, BIDI_TYPE_LTR }, + { 0x000941, 0x0008, BIDI_TYPE_NSM }, + { 0x000949, 0x0004, BIDI_TYPE_LTR }, + { 0x00094D, 0x0001, BIDI_TYPE_NSM }, + { 0x00094E, 0x0003, BIDI_TYPE_LTR }, + { 0x000951, 0x0007, BIDI_TYPE_NSM }, + { 0x000958, 0x000A, BIDI_TYPE_LTR }, + { 0x000962, 0x0002, BIDI_TYPE_NSM }, + { 0x000964, 0x001D, BIDI_TYPE_LTR }, + { 0x000981, 0x0001, BIDI_TYPE_NSM }, + { 0x000982, 0x003A, BIDI_TYPE_LTR }, + { 0x0009BC, 0x0001, BIDI_TYPE_NSM }, + { 0x0009BD, 0x0004, BIDI_TYPE_LTR }, + { 0x0009C1, 0x0004, BIDI_TYPE_NSM }, + { 0x0009C5, 0x0008, BIDI_TYPE_LTR }, + { 0x0009CD, 0x0001, BIDI_TYPE_NSM }, + { 0x0009CE, 0x0014, BIDI_TYPE_LTR }, + { 0x0009E2, 0x0002, BIDI_TYPE_NSM }, + { 0x0009E4, 0x000E, BIDI_TYPE_LTR }, + { 0x0009F2, 0x0002, BIDI_TYPE_ET }, + { 0x0009F4, 0x0007, BIDI_TYPE_LTR }, + { 0x0009FB, 0x0001, BIDI_TYPE_ET }, + { 0x0009FC, 0x0002, BIDI_TYPE_LTR }, + { 0x0009FE, 0x0001, BIDI_TYPE_NSM }, + { 0x0009FF, 0x0002, BIDI_TYPE_LTR }, + { 0x000A01, 0x0002, BIDI_TYPE_NSM }, + { 0x000A03, 0x0039, BIDI_TYPE_LTR }, + { 0x000A3C, 0x0001, BIDI_TYPE_NSM }, + { 0x000A3D, 0x0004, BIDI_TYPE_LTR }, + { 0x000A41, 0x0002, BIDI_TYPE_NSM }, + { 0x000A43, 0x0004, BIDI_TYPE_LTR }, + { 0x000A47, 0x0002, BIDI_TYPE_NSM }, + { 0x000A49, 0x0002, BIDI_TYPE_LTR }, + { 0x000A4B, 0x0003, BIDI_TYPE_NSM }, + { 0x000A4E, 0x0003, BIDI_TYPE_LTR }, + { 0x000A51, 0x0001, BIDI_TYPE_NSM }, + { 0x000A52, 0x001E, BIDI_TYPE_LTR }, + { 0x000A70, 0x0002, BIDI_TYPE_NSM }, + { 0x000A72, 0x0003, BIDI_TYPE_LTR }, + { 0x000A75, 0x0001, BIDI_TYPE_NSM }, + { 0x000A76, 0x000B, BIDI_TYPE_LTR }, + { 0x000A81, 0x0002, BIDI_TYPE_NSM }, + { 0x000A83, 0x0039, BIDI_TYPE_LTR }, + { 0x000ABC, 0x0001, BIDI_TYPE_NSM }, + { 0x000ABD, 0x0004, BIDI_TYPE_LTR }, + { 0x000AC1, 0x0005, BIDI_TYPE_NSM }, + { 0x000AC6, 0x0001, BIDI_TYPE_LTR }, + { 0x000AC7, 0x0002, BIDI_TYPE_NSM }, + { 0x000AC9, 0x0004, BIDI_TYPE_LTR }, + { 0x000ACD, 0x0001, BIDI_TYPE_NSM }, + { 0x000ACE, 0x0014, BIDI_TYPE_LTR }, + { 0x000AE2, 0x0002, BIDI_TYPE_NSM }, + { 0x000AE4, 0x000D, BIDI_TYPE_LTR }, + { 0x000AF1, 0x0001, BIDI_TYPE_ET }, + { 0x000AF2, 0x0008, BIDI_TYPE_LTR }, + { 0x000AFA, 0x0006, BIDI_TYPE_NSM }, + { 0x000B00, 0x0001, BIDI_TYPE_LTR }, + { 0x000B01, 0x0001, BIDI_TYPE_NSM }, + { 0x000B02, 0x003A, BIDI_TYPE_LTR }, + { 0x000B3C, 0x0001, BIDI_TYPE_NSM }, + { 0x000B3D, 0x0002, BIDI_TYPE_LTR }, + { 0x000B3F, 0x0001, BIDI_TYPE_NSM }, + { 0x000B40, 0x0001, BIDI_TYPE_LTR }, + { 0x000B41, 0x0004, BIDI_TYPE_NSM }, + { 0x000B45, 0x0008, BIDI_TYPE_LTR }, + { 0x000B4D, 0x0001, BIDI_TYPE_NSM }, + { 0x000B4E, 0x0008, BIDI_TYPE_LTR }, + { 0x000B56, 0x0001, BIDI_TYPE_NSM }, + { 0x000B57, 0x000B, BIDI_TYPE_LTR }, + { 0x000B62, 0x0002, BIDI_TYPE_NSM }, + { 0x000B64, 0x001E, BIDI_TYPE_LTR }, + { 0x000B82, 0x0001, BIDI_TYPE_NSM }, + { 0x000B83, 0x003D, BIDI_TYPE_LTR }, + { 0x000BC0, 0x0001, BIDI_TYPE_NSM }, + { 0x000BC1, 0x000C, BIDI_TYPE_LTR }, + { 0x000BCD, 0x0001, BIDI_TYPE_NSM }, + { 0x000BCE, 0x0025, BIDI_TYPE_LTR }, + { 0x000BF3, 0x0006, BIDI_TYPE_ON }, + { 0x000BF9, 0x0001, BIDI_TYPE_ET }, + { 0x000BFA, 0x0001, BIDI_TYPE_ON }, + { 0x000BFB, 0x0005, BIDI_TYPE_LTR }, + { 0x000C00, 0x0001, BIDI_TYPE_NSM }, + { 0x000C01, 0x0003, BIDI_TYPE_LTR }, + { 0x000C04, 0x0001, BIDI_TYPE_NSM }, + { 0x000C05, 0x0039, BIDI_TYPE_LTR }, + { 0x000C3E, 0x0003, BIDI_TYPE_NSM }, + { 0x000C41, 0x0005, BIDI_TYPE_LTR }, + { 0x000C46, 0x0003, BIDI_TYPE_NSM }, + { 0x000C49, 0x0001, BIDI_TYPE_LTR }, + { 0x000C4A, 0x0004, BIDI_TYPE_NSM }, + { 0x000C4E, 0x0007, BIDI_TYPE_LTR }, + { 0x000C55, 0x0002, BIDI_TYPE_NSM }, + { 0x000C57, 0x000B, BIDI_TYPE_LTR }, + { 0x000C62, 0x0002, BIDI_TYPE_NSM }, + { 0x000C64, 0x0014, BIDI_TYPE_LTR }, + { 0x000C78, 0x0007, BIDI_TYPE_ON }, + { 0x000C7F, 0x0002, BIDI_TYPE_LTR }, + { 0x000C81, 0x0001, BIDI_TYPE_NSM }, + { 0x000C82, 0x003A, BIDI_TYPE_LTR }, + { 0x000CBC, 0x0001, BIDI_TYPE_NSM }, + { 0x000CBD, 0x000F, BIDI_TYPE_LTR }, + { 0x000CCC, 0x0002, BIDI_TYPE_NSM }, + { 0x000CCE, 0x0014, BIDI_TYPE_LTR }, + { 0x000CE2, 0x0002, BIDI_TYPE_NSM }, + { 0x000CE4, 0x001C, BIDI_TYPE_LTR }, + { 0x000D00, 0x0002, BIDI_TYPE_NSM }, + { 0x000D02, 0x0039, BIDI_TYPE_LTR }, + { 0x000D3B, 0x0002, BIDI_TYPE_NSM }, + { 0x000D3D, 0x0004, BIDI_TYPE_LTR }, + { 0x000D41, 0x0004, BIDI_TYPE_NSM }, + { 0x000D45, 0x0008, BIDI_TYPE_LTR }, + { 0x000D4D, 0x0001, BIDI_TYPE_NSM }, + { 0x000D4E, 0x0014, BIDI_TYPE_LTR }, + { 0x000D62, 0x0002, BIDI_TYPE_NSM }, + { 0x000D64, 0x0066, BIDI_TYPE_LTR }, + { 0x000DCA, 0x0001, BIDI_TYPE_NSM }, + { 0x000DCB, 0x0007, BIDI_TYPE_LTR }, + { 0x000DD2, 0x0003, BIDI_TYPE_NSM }, + { 0x000DD5, 0x0001, BIDI_TYPE_LTR }, + { 0x000DD6, 0x0001, BIDI_TYPE_NSM }, + { 0x000DD7, 0x005A, BIDI_TYPE_LTR }, + { 0x000E31, 0x0001, BIDI_TYPE_NSM }, + { 0x000E32, 0x0002, BIDI_TYPE_LTR }, + { 0x000E34, 0x0007, BIDI_TYPE_NSM }, + { 0x000E3B, 0x0004, BIDI_TYPE_LTR }, + { 0x000E3F, 0x0001, BIDI_TYPE_ET }, + { 0x000E40, 0x0007, BIDI_TYPE_LTR }, + { 0x000E47, 0x0008, BIDI_TYPE_NSM }, + { 0x000E4F, 0x0062, BIDI_TYPE_LTR }, + { 0x000EB1, 0x0001, BIDI_TYPE_NSM }, + { 0x000EB2, 0x0002, BIDI_TYPE_LTR }, + { 0x000EB4, 0x0006, BIDI_TYPE_NSM }, + { 0x000EBA, 0x0001, BIDI_TYPE_LTR }, + { 0x000EBB, 0x0002, BIDI_TYPE_NSM }, + { 0x000EBD, 0x000B, BIDI_TYPE_LTR }, + { 0x000EC8, 0x0006, BIDI_TYPE_NSM }, + { 0x000ECE, 0x004A, BIDI_TYPE_LTR }, + { 0x000F18, 0x0002, BIDI_TYPE_NSM }, + { 0x000F1A, 0x001B, BIDI_TYPE_LTR }, + { 0x000F35, 0x0001, BIDI_TYPE_NSM }, + { 0x000F36, 0x0001, BIDI_TYPE_LTR }, + { 0x000F37, 0x0001, BIDI_TYPE_NSM }, + { 0x000F38, 0x0001, BIDI_TYPE_LTR }, + { 0x000F39, 0x0001, BIDI_TYPE_NSM }, + { 0x000F3A, 0x0004, BIDI_TYPE_ON }, + { 0x000F3E, 0x0033, BIDI_TYPE_LTR }, + { 0x000F71, 0x000E, BIDI_TYPE_NSM }, + { 0x000F7F, 0x0001, BIDI_TYPE_LTR }, + { 0x000F80, 0x0005, BIDI_TYPE_NSM }, + { 0x000F85, 0x0001, BIDI_TYPE_LTR }, + { 0x000F86, 0x0002, BIDI_TYPE_NSM }, + { 0x000F88, 0x0005, BIDI_TYPE_LTR }, + { 0x000F8D, 0x000B, BIDI_TYPE_NSM }, + { 0x000F98, 0x0001, BIDI_TYPE_LTR }, + { 0x000F99, 0x0024, BIDI_TYPE_NSM }, + { 0x000FBD, 0x0009, BIDI_TYPE_LTR }, + { 0x000FC6, 0x0001, BIDI_TYPE_NSM }, + { 0x000FC7, 0x0066, BIDI_TYPE_LTR }, + { 0x00102D, 0x0004, BIDI_TYPE_NSM }, + { 0x001031, 0x0001, BIDI_TYPE_LTR }, + { 0x001032, 0x0006, BIDI_TYPE_NSM }, + { 0x001038, 0x0001, BIDI_TYPE_LTR }, + { 0x001039, 0x0002, BIDI_TYPE_NSM }, + { 0x00103B, 0x0002, BIDI_TYPE_LTR }, + { 0x00103D, 0x0002, BIDI_TYPE_NSM }, + { 0x00103F, 0x0019, BIDI_TYPE_LTR }, + { 0x001058, 0x0002, BIDI_TYPE_NSM }, + { 0x00105A, 0x0004, BIDI_TYPE_LTR }, + { 0x00105E, 0x0003, BIDI_TYPE_NSM }, + { 0x001061, 0x0010, BIDI_TYPE_LTR }, + { 0x001071, 0x0004, BIDI_TYPE_NSM }, + { 0x001075, 0x000D, BIDI_TYPE_LTR }, + { 0x001082, 0x0001, BIDI_TYPE_NSM }, + { 0x001083, 0x0002, BIDI_TYPE_LTR }, + { 0x001085, 0x0002, BIDI_TYPE_NSM }, + { 0x001087, 0x0006, BIDI_TYPE_LTR }, + { 0x00108D, 0x0001, BIDI_TYPE_NSM }, + { 0x00108E, 0x000F, BIDI_TYPE_LTR }, + { 0x00109D, 0x0001, BIDI_TYPE_NSM }, + { 0x00109E, 0x02BF, BIDI_TYPE_LTR }, + { 0x00135D, 0x0003, BIDI_TYPE_NSM }, + { 0x001360, 0x0030, BIDI_TYPE_LTR }, + { 0x001390, 0x000A, BIDI_TYPE_ON }, + { 0x00139A, 0x0066, BIDI_TYPE_LTR }, + { 0x001400, 0x0001, BIDI_TYPE_ON }, + { 0x001401, 0x027F, BIDI_TYPE_LTR }, + { 0x001680, 0x0001, BIDI_TYPE_WS }, + { 0x001681, 0x001A, BIDI_TYPE_LTR }, + { 0x00169B, 0x0002, BIDI_TYPE_ON }, + { 0x00169D, 0x0075, BIDI_TYPE_LTR }, + { 0x001712, 0x0003, BIDI_TYPE_NSM }, + { 0x001715, 0x001D, BIDI_TYPE_LTR }, + { 0x001732, 0x0003, BIDI_TYPE_NSM }, + { 0x001735, 0x001D, BIDI_TYPE_LTR }, + { 0x001752, 0x0002, BIDI_TYPE_NSM }, + { 0x001754, 0x001E, BIDI_TYPE_LTR }, + { 0x001772, 0x0002, BIDI_TYPE_NSM }, + { 0x001774, 0x0040, BIDI_TYPE_LTR }, + { 0x0017B4, 0x0002, BIDI_TYPE_NSM }, + { 0x0017B6, 0x0001, BIDI_TYPE_LTR }, + { 0x0017B7, 0x0007, BIDI_TYPE_NSM }, + { 0x0017BE, 0x0008, BIDI_TYPE_LTR }, + { 0x0017C6, 0x0001, BIDI_TYPE_NSM }, + { 0x0017C7, 0x0002, BIDI_TYPE_LTR }, + { 0x0017C9, 0x000B, BIDI_TYPE_NSM }, + { 0x0017D4, 0x0007, BIDI_TYPE_LTR }, + { 0x0017DB, 0x0001, BIDI_TYPE_ET }, + { 0x0017DC, 0x0001, BIDI_TYPE_LTR }, + { 0x0017DD, 0x0001, BIDI_TYPE_NSM }, + { 0x0017DE, 0x0012, BIDI_TYPE_LTR }, + { 0x0017F0, 0x000A, BIDI_TYPE_ON }, + { 0x0017FA, 0x0006, BIDI_TYPE_LTR }, + { 0x001800, 0x000B, BIDI_TYPE_ON }, + { 0x00180B, 0x0003, BIDI_TYPE_NSM }, + { 0x00180E, 0x0001, BIDI_TYPE_BN }, + { 0x00180F, 0x0076, BIDI_TYPE_LTR }, + { 0x001885, 0x0002, BIDI_TYPE_NSM }, + { 0x001887, 0x0022, BIDI_TYPE_LTR }, + { 0x0018A9, 0x0001, BIDI_TYPE_NSM }, + { 0x0018AA, 0x0076, BIDI_TYPE_LTR }, + { 0x001920, 0x0003, BIDI_TYPE_NSM }, + { 0x001923, 0x0004, BIDI_TYPE_LTR }, + { 0x001927, 0x0002, BIDI_TYPE_NSM }, + { 0x001929, 0x0009, BIDI_TYPE_LTR }, + { 0x001932, 0x0001, BIDI_TYPE_NSM }, + { 0x001933, 0x0006, BIDI_TYPE_LTR }, + { 0x001939, 0x0003, BIDI_TYPE_NSM }, + { 0x00193C, 0x0004, BIDI_TYPE_LTR }, + { 0x001940, 0x0001, BIDI_TYPE_ON }, + { 0x001941, 0x0003, BIDI_TYPE_LTR }, + { 0x001944, 0x0002, BIDI_TYPE_ON }, + { 0x001946, 0x0098, BIDI_TYPE_LTR }, + { 0x0019DE, 0x0022, BIDI_TYPE_ON }, + { 0x001A00, 0x0017, BIDI_TYPE_LTR }, + { 0x001A17, 0x0002, BIDI_TYPE_NSM }, + { 0x001A19, 0x0002, BIDI_TYPE_LTR }, + { 0x001A1B, 0x0001, BIDI_TYPE_NSM }, + { 0x001A1C, 0x003A, BIDI_TYPE_LTR }, + { 0x001A56, 0x0001, BIDI_TYPE_NSM }, + { 0x001A57, 0x0001, BIDI_TYPE_LTR }, + { 0x001A58, 0x0007, BIDI_TYPE_NSM }, + { 0x001A5F, 0x0001, BIDI_TYPE_LTR }, + { 0x001A60, 0x0001, BIDI_TYPE_NSM }, + { 0x001A61, 0x0001, BIDI_TYPE_LTR }, + { 0x001A62, 0x0001, BIDI_TYPE_NSM }, + { 0x001A63, 0x0002, BIDI_TYPE_LTR }, + { 0x001A65, 0x0008, BIDI_TYPE_NSM }, + { 0x001A6D, 0x0006, BIDI_TYPE_LTR }, + { 0x001A73, 0x000A, BIDI_TYPE_NSM }, + { 0x001A7D, 0x0002, BIDI_TYPE_LTR }, + { 0x001A7F, 0x0001, BIDI_TYPE_NSM }, + { 0x001A80, 0x0030, BIDI_TYPE_LTR }, + { 0x001AB0, 0x000F, BIDI_TYPE_NSM }, + { 0x001ABF, 0x0041, BIDI_TYPE_LTR }, + { 0x001B00, 0x0004, BIDI_TYPE_NSM }, + { 0x001B04, 0x0030, BIDI_TYPE_LTR }, + { 0x001B34, 0x0001, BIDI_TYPE_NSM }, + { 0x001B35, 0x0001, BIDI_TYPE_LTR }, + { 0x001B36, 0x0005, BIDI_TYPE_NSM }, + { 0x001B3B, 0x0001, BIDI_TYPE_LTR }, + { 0x001B3C, 0x0001, BIDI_TYPE_NSM }, + { 0x001B3D, 0x0005, BIDI_TYPE_LTR }, + { 0x001B42, 0x0001, BIDI_TYPE_NSM }, + { 0x001B43, 0x0028, BIDI_TYPE_LTR }, + { 0x001B6B, 0x0009, BIDI_TYPE_NSM }, + { 0x001B74, 0x000C, BIDI_TYPE_LTR }, + { 0x001B80, 0x0002, BIDI_TYPE_NSM }, + { 0x001B82, 0x0020, BIDI_TYPE_LTR }, + { 0x001BA2, 0x0004, BIDI_TYPE_NSM }, + { 0x001BA6, 0x0002, BIDI_TYPE_LTR }, + { 0x001BA8, 0x0002, BIDI_TYPE_NSM }, + { 0x001BAA, 0x0001, BIDI_TYPE_LTR }, + { 0x001BAB, 0x0003, BIDI_TYPE_NSM }, + { 0x001BAE, 0x0038, BIDI_TYPE_LTR }, + { 0x001BE6, 0x0001, BIDI_TYPE_NSM }, + { 0x001BE7, 0x0001, BIDI_TYPE_LTR }, + { 0x001BE8, 0x0002, BIDI_TYPE_NSM }, + { 0x001BEA, 0x0003, BIDI_TYPE_LTR }, + { 0x001BED, 0x0001, BIDI_TYPE_NSM }, + { 0x001BEE, 0x0001, BIDI_TYPE_LTR }, + { 0x001BEF, 0x0003, BIDI_TYPE_NSM }, + { 0x001BF2, 0x003A, BIDI_TYPE_LTR }, + { 0x001C2C, 0x0008, BIDI_TYPE_NSM }, + { 0x001C34, 0x0002, BIDI_TYPE_LTR }, + { 0x001C36, 0x0002, BIDI_TYPE_NSM }, + { 0x001C38, 0x0098, BIDI_TYPE_LTR }, + { 0x001CD0, 0x0003, BIDI_TYPE_NSM }, + { 0x001CD3, 0x0001, BIDI_TYPE_LTR }, + { 0x001CD4, 0x000D, BIDI_TYPE_NSM }, + { 0x001CE1, 0x0001, BIDI_TYPE_LTR }, + { 0x001CE2, 0x0007, BIDI_TYPE_NSM }, + { 0x001CE9, 0x0004, BIDI_TYPE_LTR }, + { 0x001CED, 0x0001, BIDI_TYPE_NSM }, + { 0x001CEE, 0x0006, BIDI_TYPE_LTR }, + { 0x001CF4, 0x0001, BIDI_TYPE_NSM }, + { 0x001CF5, 0x0003, BIDI_TYPE_LTR }, + { 0x001CF8, 0x0002, BIDI_TYPE_NSM }, + { 0x001CFA, 0x00C6, BIDI_TYPE_LTR }, + { 0x001DC0, 0x003A, BIDI_TYPE_NSM }, + { 0x001DFA, 0x0001, BIDI_TYPE_LTR }, + { 0x001DFB, 0x0005, BIDI_TYPE_NSM }, + { 0x001E00, 0x01BD, BIDI_TYPE_LTR }, + { 0x001FBD, 0x0001, BIDI_TYPE_ON }, + { 0x001FBE, 0x0001, BIDI_TYPE_LTR }, + { 0x001FBF, 0x0003, BIDI_TYPE_ON }, + { 0x001FC2, 0x000B, BIDI_TYPE_LTR }, + { 0x001FCD, 0x0003, BIDI_TYPE_ON }, + { 0x001FD0, 0x000D, BIDI_TYPE_LTR }, + { 0x001FDD, 0x0003, BIDI_TYPE_ON }, + { 0x001FE0, 0x000D, BIDI_TYPE_LTR }, + { 0x001FED, 0x0003, BIDI_TYPE_ON }, + { 0x001FF0, 0x000D, BIDI_TYPE_LTR }, + { 0x001FFD, 0x0002, BIDI_TYPE_ON }, + { 0x001FFF, 0x0001, BIDI_TYPE_LTR }, + { 0x002000, 0x000B, BIDI_TYPE_WS }, + { 0x00200B, 0x0003, BIDI_TYPE_BN }, + { 0x00200E, 0x0001, BIDI_TYPE_LTR }, + { 0x00200F, 0x0001, BIDI_TYPE_RTL }, + { 0x002010, 0x0018, BIDI_TYPE_ON }, + { 0x002028, 0x0001, BIDI_TYPE_WS }, + { 0x002029, 0x0001, BIDI_TYPE_BS }, + { 0x00202A, 0x0001, BIDI_TYPE_LRE }, + { 0x00202B, 0x0001, BIDI_TYPE_RLE }, + { 0x00202C, 0x0001, BIDI_TYPE_PDF }, + { 0x00202D, 0x0001, BIDI_TYPE_LRO }, + { 0x00202E, 0x0001, BIDI_TYPE_RLO }, + { 0x00202F, 0x0001, BIDI_TYPE_CS }, + { 0x002030, 0x0005, BIDI_TYPE_ET }, + { 0x002035, 0x000F, BIDI_TYPE_ON }, + { 0x002044, 0x0001, BIDI_TYPE_CS }, + { 0x002045, 0x001A, BIDI_TYPE_ON }, + { 0x00205F, 0x0001, BIDI_TYPE_WS }, + { 0x002060, 0x0006, BIDI_TYPE_BN }, + { 0x002066, 0x0001, BIDI_TYPE_LRI }, + { 0x002067, 0x0001, BIDI_TYPE_RLI }, + { 0x002068, 0x0001, BIDI_TYPE_FSI }, + { 0x002069, 0x0001, BIDI_TYPE_PDI }, + { 0x00206A, 0x0006, BIDI_TYPE_BN }, + { 0x002070, 0x0001, BIDI_TYPE_EN }, + { 0x002071, 0x0003, BIDI_TYPE_LTR }, + { 0x002074, 0x0006, BIDI_TYPE_EN }, + { 0x00207A, 0x0002, BIDI_TYPE_ES }, + { 0x00207C, 0x0003, BIDI_TYPE_ON }, + { 0x00207F, 0x0001, BIDI_TYPE_LTR }, + { 0x002080, 0x000A, BIDI_TYPE_EN }, + { 0x00208A, 0x0002, BIDI_TYPE_ES }, + { 0x00208C, 0x0003, BIDI_TYPE_ON }, + { 0x00208F, 0x0011, BIDI_TYPE_LTR }, + { 0x0020A0, 0x0030, BIDI_TYPE_ET }, + { 0x0020D0, 0x0021, BIDI_TYPE_NSM }, + { 0x0020F1, 0x000F, BIDI_TYPE_LTR }, + { 0x002100, 0x0002, BIDI_TYPE_ON }, + { 0x002102, 0x0001, BIDI_TYPE_LTR }, + { 0x002103, 0x0004, BIDI_TYPE_ON }, + { 0x002107, 0x0001, BIDI_TYPE_LTR }, + { 0x002108, 0x0002, BIDI_TYPE_ON }, + { 0x00210A, 0x000A, BIDI_TYPE_LTR }, + { 0x002114, 0x0001, BIDI_TYPE_ON }, + { 0x002115, 0x0001, BIDI_TYPE_LTR }, + { 0x002116, 0x0003, BIDI_TYPE_ON }, + { 0x002119, 0x0005, BIDI_TYPE_LTR }, + { 0x00211E, 0x0006, BIDI_TYPE_ON }, + { 0x002124, 0x0001, BIDI_TYPE_LTR }, + { 0x002125, 0x0001, BIDI_TYPE_ON }, + { 0x002126, 0x0001, BIDI_TYPE_LTR }, + { 0x002127, 0x0001, BIDI_TYPE_ON }, + { 0x002128, 0x0001, BIDI_TYPE_LTR }, + { 0x002129, 0x0001, BIDI_TYPE_ON }, + { 0x00212A, 0x0004, BIDI_TYPE_LTR }, + { 0x00212E, 0x0001, BIDI_TYPE_ET }, + { 0x00212F, 0x000B, BIDI_TYPE_LTR }, + { 0x00213A, 0x0002, BIDI_TYPE_ON }, + { 0x00213C, 0x0004, BIDI_TYPE_LTR }, + { 0x002140, 0x0005, BIDI_TYPE_ON }, + { 0x002145, 0x0005, BIDI_TYPE_LTR }, + { 0x00214A, 0x0004, BIDI_TYPE_ON }, + { 0x00214E, 0x0002, BIDI_TYPE_LTR }, + { 0x002150, 0x0010, BIDI_TYPE_ON }, + { 0x002160, 0x0029, BIDI_TYPE_LTR }, + { 0x002189, 0x0003, BIDI_TYPE_ON }, + { 0x00218C, 0x0004, BIDI_TYPE_LTR }, + { 0x002190, 0x0082, BIDI_TYPE_ON }, + { 0x002212, 0x0001, BIDI_TYPE_ES }, + { 0x002213, 0x0001, BIDI_TYPE_ET }, + { 0x002214, 0x0122, BIDI_TYPE_ON }, + { 0x002336, 0x0045, BIDI_TYPE_LTR }, + { 0x00237B, 0x001A, BIDI_TYPE_ON }, + { 0x002395, 0x0001, BIDI_TYPE_LTR }, + { 0x002396, 0x0091, BIDI_TYPE_ON }, + { 0x002427, 0x0019, BIDI_TYPE_LTR }, + { 0x002440, 0x000B, BIDI_TYPE_ON }, + { 0x00244B, 0x0015, BIDI_TYPE_LTR }, + { 0x002460, 0x0028, BIDI_TYPE_ON }, + { 0x002488, 0x0014, BIDI_TYPE_EN }, + { 0x00249C, 0x004E, BIDI_TYPE_LTR }, + { 0x0024EA, 0x01C2, BIDI_TYPE_ON }, + { 0x0026AC, 0x0001, BIDI_TYPE_LTR }, + { 0x0026AD, 0x0153, BIDI_TYPE_ON }, + { 0x002800, 0x0100, BIDI_TYPE_LTR }, + { 0x002900, 0x0274, BIDI_TYPE_ON }, + { 0x002B74, 0x0002, BIDI_TYPE_LTR }, + { 0x002B76, 0x0020, BIDI_TYPE_ON }, + { 0x002B96, 0x0002, BIDI_TYPE_LTR }, + { 0x002B98, 0x0031, BIDI_TYPE_ON }, + { 0x002BC9, 0x0001, BIDI_TYPE_LTR }, + { 0x002BCA, 0x0035, BIDI_TYPE_ON }, + { 0x002BFF, 0x00E6, BIDI_TYPE_LTR }, + { 0x002CE5, 0x0006, BIDI_TYPE_ON }, + { 0x002CEB, 0x0004, BIDI_TYPE_LTR }, + { 0x002CEF, 0x0003, BIDI_TYPE_NSM }, + { 0x002CF2, 0x0007, BIDI_TYPE_LTR }, + { 0x002CF9, 0x0007, BIDI_TYPE_ON }, + { 0x002D00, 0x007F, BIDI_TYPE_LTR }, + { 0x002D7F, 0x0001, BIDI_TYPE_NSM }, + { 0x002D80, 0x0060, BIDI_TYPE_LTR }, + { 0x002DE0, 0x0020, BIDI_TYPE_NSM }, + { 0x002E00, 0x004F, BIDI_TYPE_ON }, + { 0x002E4F, 0x0031, BIDI_TYPE_LTR }, + { 0x002E80, 0x001A, BIDI_TYPE_ON }, + { 0x002E9A, 0x0001, BIDI_TYPE_LTR }, + { 0x002E9B, 0x0059, BIDI_TYPE_ON }, + { 0x002EF4, 0x000C, BIDI_TYPE_LTR }, + { 0x002F00, 0x00D6, BIDI_TYPE_ON }, + { 0x002FD6, 0x001A, BIDI_TYPE_LTR }, + { 0x002FF0, 0x000C, BIDI_TYPE_ON }, + { 0x002FFC, 0x0004, BIDI_TYPE_LTR }, + { 0x003000, 0x0001, BIDI_TYPE_WS }, + { 0x003001, 0x0004, BIDI_TYPE_ON }, + { 0x003005, 0x0003, BIDI_TYPE_LTR }, + { 0x003008, 0x0019, BIDI_TYPE_ON }, + { 0x003021, 0x0009, BIDI_TYPE_LTR }, + { 0x00302A, 0x0004, BIDI_TYPE_NSM }, + { 0x00302E, 0x0002, BIDI_TYPE_LTR }, + { 0x003030, 0x0001, BIDI_TYPE_ON }, + { 0x003031, 0x0005, BIDI_TYPE_LTR }, + { 0x003036, 0x0002, BIDI_TYPE_ON }, + { 0x003038, 0x0005, BIDI_TYPE_LTR }, + { 0x00303D, 0x0003, BIDI_TYPE_ON }, + { 0x003040, 0x0059, BIDI_TYPE_LTR }, + { 0x003099, 0x0002, BIDI_TYPE_NSM }, + { 0x00309B, 0x0002, BIDI_TYPE_ON }, + { 0x00309D, 0x0003, BIDI_TYPE_LTR }, + { 0x0030A0, 0x0001, BIDI_TYPE_ON }, + { 0x0030A1, 0x005A, BIDI_TYPE_LTR }, + { 0x0030FB, 0x0001, BIDI_TYPE_ON }, + { 0x0030FC, 0x00C4, BIDI_TYPE_LTR }, + { 0x0031C0, 0x0024, BIDI_TYPE_ON }, + { 0x0031E4, 0x0039, BIDI_TYPE_LTR }, + { 0x00321D, 0x0002, BIDI_TYPE_ON }, + { 0x00321F, 0x0031, BIDI_TYPE_LTR }, + { 0x003250, 0x0010, BIDI_TYPE_ON }, + { 0x003260, 0x001C, BIDI_TYPE_LTR }, + { 0x00327C, 0x0003, BIDI_TYPE_ON }, + { 0x00327F, 0x0032, BIDI_TYPE_LTR }, + { 0x0032B1, 0x000F, BIDI_TYPE_ON }, + { 0x0032C0, 0x000C, BIDI_TYPE_LTR }, + { 0x0032CC, 0x0004, BIDI_TYPE_ON }, + { 0x0032D0, 0x00A7, BIDI_TYPE_LTR }, + { 0x003377, 0x0004, BIDI_TYPE_ON }, + { 0x00337B, 0x0063, BIDI_TYPE_LTR }, + { 0x0033DE, 0x0002, BIDI_TYPE_ON }, + { 0x0033E0, 0x001F, BIDI_TYPE_LTR }, + { 0x0033FF, 0x0001, BIDI_TYPE_ON }, + { 0x003400, 0x19C0, BIDI_TYPE_LTR }, + { 0x004DC0, 0x0040, BIDI_TYPE_ON }, + { 0x004E00, 0x5690, BIDI_TYPE_LTR }, + { 0x00A490, 0x0037, BIDI_TYPE_ON }, + { 0x00A4C7, 0x0146, BIDI_TYPE_LTR }, + { 0x00A60D, 0x0003, BIDI_TYPE_ON }, + { 0x00A610, 0x005F, BIDI_TYPE_LTR }, + { 0x00A66F, 0x0004, BIDI_TYPE_NSM }, + { 0x00A673, 0x0001, BIDI_TYPE_ON }, + { 0x00A674, 0x000A, BIDI_TYPE_NSM }, + { 0x00A67E, 0x0002, BIDI_TYPE_ON }, + { 0x00A680, 0x001E, BIDI_TYPE_LTR }, + { 0x00A69E, 0x0002, BIDI_TYPE_NSM }, + { 0x00A6A0, 0x0050, BIDI_TYPE_LTR }, + { 0x00A6F0, 0x0002, BIDI_TYPE_NSM }, + { 0x00A6F2, 0x000E, BIDI_TYPE_LTR }, + { 0x00A700, 0x0022, BIDI_TYPE_ON }, + { 0x00A722, 0x0066, BIDI_TYPE_LTR }, + { 0x00A788, 0x0001, BIDI_TYPE_ON }, + { 0x00A789, 0x0079, BIDI_TYPE_LTR }, + { 0x00A802, 0x0001, BIDI_TYPE_NSM }, + { 0x00A803, 0x0003, BIDI_TYPE_LTR }, + { 0x00A806, 0x0001, BIDI_TYPE_NSM }, + { 0x00A807, 0x0004, BIDI_TYPE_LTR }, + { 0x00A80B, 0x0001, BIDI_TYPE_NSM }, + { 0x00A80C, 0x0019, BIDI_TYPE_LTR }, + { 0x00A825, 0x0002, BIDI_TYPE_NSM }, + { 0x00A827, 0x0001, BIDI_TYPE_LTR }, + { 0x00A828, 0x0004, BIDI_TYPE_ON }, + { 0x00A82C, 0x000C, BIDI_TYPE_LTR }, + { 0x00A838, 0x0002, BIDI_TYPE_ET }, + { 0x00A83A, 0x003A, BIDI_TYPE_LTR }, + { 0x00A874, 0x0004, BIDI_TYPE_ON }, + { 0x00A878, 0x004C, BIDI_TYPE_LTR }, + { 0x00A8C4, 0x0002, BIDI_TYPE_NSM }, + { 0x00A8C6, 0x001A, BIDI_TYPE_LTR }, + { 0x00A8E0, 0x0012, BIDI_TYPE_NSM }, + { 0x00A8F2, 0x000D, BIDI_TYPE_LTR }, + { 0x00A8FF, 0x0001, BIDI_TYPE_NSM }, + { 0x00A900, 0x0026, BIDI_TYPE_LTR }, + { 0x00A926, 0x0008, BIDI_TYPE_NSM }, + { 0x00A92E, 0x0019, BIDI_TYPE_LTR }, + { 0x00A947, 0x000B, BIDI_TYPE_NSM }, + { 0x00A952, 0x002E, BIDI_TYPE_LTR }, + { 0x00A980, 0x0003, BIDI_TYPE_NSM }, + { 0x00A983, 0x0030, BIDI_TYPE_LTR }, + { 0x00A9B3, 0x0001, BIDI_TYPE_NSM }, + { 0x00A9B4, 0x0002, BIDI_TYPE_LTR }, + { 0x00A9B6, 0x0004, BIDI_TYPE_NSM }, + { 0x00A9BA, 0x0002, BIDI_TYPE_LTR }, + { 0x00A9BC, 0x0001, BIDI_TYPE_NSM }, + { 0x00A9BD, 0x0028, BIDI_TYPE_LTR }, + { 0x00A9E5, 0x0001, BIDI_TYPE_NSM }, + { 0x00A9E6, 0x0043, BIDI_TYPE_LTR }, + { 0x00AA29, 0x0006, BIDI_TYPE_NSM }, + { 0x00AA2F, 0x0002, BIDI_TYPE_LTR }, + { 0x00AA31, 0x0002, BIDI_TYPE_NSM }, + { 0x00AA33, 0x0002, BIDI_TYPE_LTR }, + { 0x00AA35, 0x0002, BIDI_TYPE_NSM }, + { 0x00AA37, 0x000C, BIDI_TYPE_LTR }, + { 0x00AA43, 0x0001, BIDI_TYPE_NSM }, + { 0x00AA44, 0x0008, BIDI_TYPE_LTR }, + { 0x00AA4C, 0x0001, BIDI_TYPE_NSM }, + { 0x00AA4D, 0x002F, BIDI_TYPE_LTR }, + { 0x00AA7C, 0x0001, BIDI_TYPE_NSM }, + { 0x00AA7D, 0x0033, BIDI_TYPE_LTR }, + { 0x00AAB0, 0x0001, BIDI_TYPE_NSM }, + { 0x00AAB1, 0x0001, BIDI_TYPE_LTR }, + { 0x00AAB2, 0x0003, BIDI_TYPE_NSM }, + { 0x00AAB5, 0x0002, BIDI_TYPE_LTR }, + { 0x00AAB7, 0x0002, BIDI_TYPE_NSM }, + { 0x00AAB9, 0x0005, BIDI_TYPE_LTR }, + { 0x00AABE, 0x0002, BIDI_TYPE_NSM }, + { 0x00AAC0, 0x0001, BIDI_TYPE_LTR }, + { 0x00AAC1, 0x0001, BIDI_TYPE_NSM }, + { 0x00AAC2, 0x002A, BIDI_TYPE_LTR }, + { 0x00AAEC, 0x0002, BIDI_TYPE_NSM }, + { 0x00AAEE, 0x0008, BIDI_TYPE_LTR }, + { 0x00AAF6, 0x0001, BIDI_TYPE_NSM }, + { 0x00AAF7, 0x00EE, BIDI_TYPE_LTR }, + { 0x00ABE5, 0x0001, BIDI_TYPE_NSM }, + { 0x00ABE6, 0x0002, BIDI_TYPE_LTR }, + { 0x00ABE8, 0x0001, BIDI_TYPE_NSM }, + { 0x00ABE9, 0x0004, BIDI_TYPE_LTR }, + { 0x00ABED, 0x0001, BIDI_TYPE_NSM }, + { 0x00ABEE, 0x4F2F, BIDI_TYPE_LTR }, + { 0x00FB1D, 0x0001, BIDI_TYPE_RTL }, + { 0x00FB1E, 0x0001, BIDI_TYPE_NSM }, + { 0x00FB1F, 0x000A, BIDI_TYPE_RTL }, + { 0x00FB29, 0x0001, BIDI_TYPE_ES }, + { 0x00FB2A, 0x0026, BIDI_TYPE_RTL }, + { 0x00FB50, 0x01EE, BIDI_TYPE_AL }, + { 0x00FD3E, 0x0002, BIDI_TYPE_ON }, + { 0x00FD40, 0x0090, BIDI_TYPE_AL }, + { 0x00FDD0, 0x0020, BIDI_TYPE_BN }, + { 0x00FDF0, 0x000D, BIDI_TYPE_AL }, + { 0x00FDFD, 0x0001, BIDI_TYPE_ON }, + { 0x00FDFE, 0x0002, BIDI_TYPE_AL }, + { 0x00FE00, 0x0010, BIDI_TYPE_NSM }, + { 0x00FE10, 0x000A, BIDI_TYPE_ON }, + { 0x00FE1A, 0x0006, BIDI_TYPE_LTR }, + { 0x00FE20, 0x0010, BIDI_TYPE_NSM }, + { 0x00FE30, 0x0020, BIDI_TYPE_ON }, + { 0x00FE50, 0x0001, BIDI_TYPE_CS }, + { 0x00FE51, 0x0001, BIDI_TYPE_ON }, + { 0x00FE52, 0x0001, BIDI_TYPE_CS }, + { 0x00FE53, 0x0001, BIDI_TYPE_LTR }, + { 0x00FE54, 0x0001, BIDI_TYPE_ON }, + { 0x00FE55, 0x0001, BIDI_TYPE_CS }, + { 0x00FE56, 0x0009, BIDI_TYPE_ON }, + { 0x00FE5F, 0x0001, BIDI_TYPE_ET }, + { 0x00FE60, 0x0002, BIDI_TYPE_ON }, + { 0x00FE62, 0x0002, BIDI_TYPE_ES }, + { 0x00FE64, 0x0003, BIDI_TYPE_ON }, + { 0x00FE67, 0x0001, BIDI_TYPE_LTR }, + { 0x00FE68, 0x0001, BIDI_TYPE_ON }, + { 0x00FE69, 0x0002, BIDI_TYPE_ET }, + { 0x00FE6B, 0x0001, BIDI_TYPE_ON }, + { 0x00FE6C, 0x0004, BIDI_TYPE_LTR }, + { 0x00FE70, 0x008F, BIDI_TYPE_AL }, + { 0x00FEFF, 0x0001, BIDI_TYPE_BN }, + { 0x00FF00, 0x0001, BIDI_TYPE_LTR }, + { 0x00FF01, 0x0002, BIDI_TYPE_ON }, + { 0x00FF03, 0x0003, BIDI_TYPE_ET }, + { 0x00FF06, 0x0005, BIDI_TYPE_ON }, + { 0x00FF0B, 0x0001, BIDI_TYPE_ES }, + { 0x00FF0C, 0x0001, BIDI_TYPE_CS }, + { 0x00FF0D, 0x0001, BIDI_TYPE_ES }, + { 0x00FF0E, 0x0002, BIDI_TYPE_CS }, + { 0x00FF10, 0x000A, BIDI_TYPE_EN }, + { 0x00FF1A, 0x0001, BIDI_TYPE_CS }, + { 0x00FF1B, 0x0006, BIDI_TYPE_ON }, + { 0x00FF21, 0x001A, BIDI_TYPE_LTR }, + { 0x00FF3B, 0x0006, BIDI_TYPE_ON }, + { 0x00FF41, 0x001A, BIDI_TYPE_LTR }, + { 0x00FF5B, 0x000B, BIDI_TYPE_ON }, + { 0x00FF66, 0x007A, BIDI_TYPE_LTR }, + { 0x00FFE0, 0x0002, BIDI_TYPE_ET }, + { 0x00FFE2, 0x0003, BIDI_TYPE_ON }, + { 0x00FFE5, 0x0002, BIDI_TYPE_ET }, + { 0x00FFE7, 0x0001, BIDI_TYPE_LTR }, + { 0x00FFE8, 0x0007, BIDI_TYPE_ON }, + { 0x00FFEF, 0x0001, BIDI_TYPE_LTR }, + { 0x00FFF0, 0x0009, BIDI_TYPE_BN }, + { 0x00FFF9, 0x0005, BIDI_TYPE_ON }, + { 0x00FFFE, 0x0002, BIDI_TYPE_BN }, + { 0x010000, 0x0101, BIDI_TYPE_LTR }, + { 0x010101, 0x0001, BIDI_TYPE_ON }, + { 0x010102, 0x003E, BIDI_TYPE_LTR }, + { 0x010140, 0x004D, BIDI_TYPE_ON }, + { 0x01018D, 0x0003, BIDI_TYPE_LTR }, + { 0x010190, 0x000C, BIDI_TYPE_ON }, + { 0x01019C, 0x0004, BIDI_TYPE_LTR }, + { 0x0101A0, 0x0001, BIDI_TYPE_ON }, + { 0x0101A1, 0x005C, BIDI_TYPE_LTR }, + { 0x0101FD, 0x0001, BIDI_TYPE_NSM }, + { 0x0101FE, 0x00E2, BIDI_TYPE_LTR }, + { 0x0102E0, 0x0001, BIDI_TYPE_NSM }, + { 0x0102E1, 0x001B, BIDI_TYPE_EN }, + { 0x0102FC, 0x007A, BIDI_TYPE_LTR }, + { 0x010376, 0x0005, BIDI_TYPE_NSM }, + { 0x01037B, 0x0485, BIDI_TYPE_LTR }, + { 0x010800, 0x011F, BIDI_TYPE_RTL }, + { 0x01091F, 0x0001, BIDI_TYPE_ON }, + { 0x010920, 0x00E1, BIDI_TYPE_RTL }, + { 0x010A01, 0x0003, BIDI_TYPE_NSM }, + { 0x010A04, 0x0001, BIDI_TYPE_RTL }, + { 0x010A05, 0x0002, BIDI_TYPE_NSM }, + { 0x010A07, 0x0005, BIDI_TYPE_RTL }, + { 0x010A0C, 0x0004, BIDI_TYPE_NSM }, + { 0x010A10, 0x0028, BIDI_TYPE_RTL }, + { 0x010A38, 0x0003, BIDI_TYPE_NSM }, + { 0x010A3B, 0x0004, BIDI_TYPE_RTL }, + { 0x010A3F, 0x0001, BIDI_TYPE_NSM }, + { 0x010A40, 0x00A5, BIDI_TYPE_RTL }, + { 0x010AE5, 0x0002, BIDI_TYPE_NSM }, + { 0x010AE7, 0x0052, BIDI_TYPE_RTL }, + { 0x010B39, 0x0007, BIDI_TYPE_ON }, + { 0x010B40, 0x01C0, BIDI_TYPE_RTL }, + { 0x010D00, 0x0024, BIDI_TYPE_AL }, + { 0x010D24, 0x0004, BIDI_TYPE_NSM }, + { 0x010D28, 0x0008, BIDI_TYPE_AL }, + { 0x010D30, 0x000A, BIDI_TYPE_AN }, + { 0x010D3A, 0x0006, BIDI_TYPE_AL }, + { 0x010D40, 0x0120, BIDI_TYPE_RTL }, + { 0x010E60, 0x001F, BIDI_TYPE_AN }, + { 0x010E7F, 0x00B1, BIDI_TYPE_RTL }, + { 0x010F30, 0x0016, BIDI_TYPE_AL }, + { 0x010F46, 0x000B, BIDI_TYPE_NSM }, + { 0x010F51, 0x001F, BIDI_TYPE_AL }, + { 0x010F70, 0x0090, BIDI_TYPE_RTL }, + { 0x011000, 0x0001, BIDI_TYPE_LTR }, + { 0x011001, 0x0001, BIDI_TYPE_NSM }, + { 0x011002, 0x0036, BIDI_TYPE_LTR }, + { 0x011038, 0x000F, BIDI_TYPE_NSM }, + { 0x011047, 0x000B, BIDI_TYPE_LTR }, + { 0x011052, 0x0014, BIDI_TYPE_ON }, + { 0x011066, 0x0019, BIDI_TYPE_LTR }, + { 0x01107F, 0x0003, BIDI_TYPE_NSM }, + { 0x011082, 0x0031, BIDI_TYPE_LTR }, + { 0x0110B3, 0x0004, BIDI_TYPE_NSM }, + { 0x0110B7, 0x0002, BIDI_TYPE_LTR }, + { 0x0110B9, 0x0002, BIDI_TYPE_NSM }, + { 0x0110BB, 0x0045, BIDI_TYPE_LTR }, + { 0x011100, 0x0003, BIDI_TYPE_NSM }, + { 0x011103, 0x0024, BIDI_TYPE_LTR }, + { 0x011127, 0x0005, BIDI_TYPE_NSM }, + { 0x01112C, 0x0001, BIDI_TYPE_LTR }, + { 0x01112D, 0x0008, BIDI_TYPE_NSM }, + { 0x011135, 0x003E, BIDI_TYPE_LTR }, + { 0x011173, 0x0001, BIDI_TYPE_NSM }, + { 0x011174, 0x000C, BIDI_TYPE_LTR }, + { 0x011180, 0x0002, BIDI_TYPE_NSM }, + { 0x011182, 0x0034, BIDI_TYPE_LTR }, + { 0x0111B6, 0x0009, BIDI_TYPE_NSM }, + { 0x0111BF, 0x000A, BIDI_TYPE_LTR }, + { 0x0111C9, 0x0004, BIDI_TYPE_NSM }, + { 0x0111CD, 0x0062, BIDI_TYPE_LTR }, + { 0x01122F, 0x0003, BIDI_TYPE_NSM }, + { 0x011232, 0x0002, BIDI_TYPE_LTR }, + { 0x011234, 0x0001, BIDI_TYPE_NSM }, + { 0x011235, 0x0001, BIDI_TYPE_LTR }, + { 0x011236, 0x0002, BIDI_TYPE_NSM }, + { 0x011238, 0x0006, BIDI_TYPE_LTR }, + { 0x01123E, 0x0001, BIDI_TYPE_NSM }, + { 0x01123F, 0x00A0, BIDI_TYPE_LTR }, + { 0x0112DF, 0x0001, BIDI_TYPE_NSM }, + { 0x0112E0, 0x0003, BIDI_TYPE_LTR }, + { 0x0112E3, 0x0008, BIDI_TYPE_NSM }, + { 0x0112EB, 0x0015, BIDI_TYPE_LTR }, + { 0x011300, 0x0002, BIDI_TYPE_NSM }, + { 0x011302, 0x0039, BIDI_TYPE_LTR }, + { 0x01133B, 0x0002, BIDI_TYPE_NSM }, + { 0x01133D, 0x0003, BIDI_TYPE_LTR }, + { 0x011340, 0x0001, BIDI_TYPE_NSM }, + { 0x011341, 0x0025, BIDI_TYPE_LTR }, + { 0x011366, 0x0007, BIDI_TYPE_NSM }, + { 0x01136D, 0x0003, BIDI_TYPE_LTR }, + { 0x011370, 0x0005, BIDI_TYPE_NSM }, + { 0x011375, 0x00C3, BIDI_TYPE_LTR }, + { 0x011438, 0x0008, BIDI_TYPE_NSM }, + { 0x011440, 0x0002, BIDI_TYPE_LTR }, + { 0x011442, 0x0003, BIDI_TYPE_NSM }, + { 0x011445, 0x0001, BIDI_TYPE_LTR }, + { 0x011446, 0x0001, BIDI_TYPE_NSM }, + { 0x011447, 0x0017, BIDI_TYPE_LTR }, + { 0x01145E, 0x0001, BIDI_TYPE_NSM }, + { 0x01145F, 0x0054, BIDI_TYPE_LTR }, + { 0x0114B3, 0x0006, BIDI_TYPE_NSM }, + { 0x0114B9, 0x0001, BIDI_TYPE_LTR }, + { 0x0114BA, 0x0001, BIDI_TYPE_NSM }, + { 0x0114BB, 0x0004, BIDI_TYPE_LTR }, + { 0x0114BF, 0x0002, BIDI_TYPE_NSM }, + { 0x0114C1, 0x0001, BIDI_TYPE_LTR }, + { 0x0114C2, 0x0002, BIDI_TYPE_NSM }, + { 0x0114C4, 0x00EE, BIDI_TYPE_LTR }, + { 0x0115B2, 0x0004, BIDI_TYPE_NSM }, + { 0x0115B6, 0x0006, BIDI_TYPE_LTR }, + { 0x0115BC, 0x0002, BIDI_TYPE_NSM }, + { 0x0115BE, 0x0001, BIDI_TYPE_LTR }, + { 0x0115BF, 0x0002, BIDI_TYPE_NSM }, + { 0x0115C1, 0x001B, BIDI_TYPE_LTR }, + { 0x0115DC, 0x0002, BIDI_TYPE_NSM }, + { 0x0115DE, 0x0055, BIDI_TYPE_LTR }, + { 0x011633, 0x0008, BIDI_TYPE_NSM }, + { 0x01163B, 0x0002, BIDI_TYPE_LTR }, + { 0x01163D, 0x0001, BIDI_TYPE_NSM }, + { 0x01163E, 0x0001, BIDI_TYPE_LTR }, + { 0x01163F, 0x0002, BIDI_TYPE_NSM }, + { 0x011641, 0x001F, BIDI_TYPE_LTR }, + { 0x011660, 0x000D, BIDI_TYPE_ON }, + { 0x01166D, 0x003E, BIDI_TYPE_LTR }, + { 0x0116AB, 0x0001, BIDI_TYPE_NSM }, + { 0x0116AC, 0x0001, BIDI_TYPE_LTR }, + { 0x0116AD, 0x0001, BIDI_TYPE_NSM }, + { 0x0116AE, 0x0002, BIDI_TYPE_LTR }, + { 0x0116B0, 0x0006, BIDI_TYPE_NSM }, + { 0x0116B6, 0x0001, BIDI_TYPE_LTR }, + { 0x0116B7, 0x0001, BIDI_TYPE_NSM }, + { 0x0116B8, 0x0065, BIDI_TYPE_LTR }, + { 0x01171D, 0x0003, BIDI_TYPE_NSM }, + { 0x011720, 0x0002, BIDI_TYPE_LTR }, + { 0x011722, 0x0004, BIDI_TYPE_NSM }, + { 0x011726, 0x0001, BIDI_TYPE_LTR }, + { 0x011727, 0x0005, BIDI_TYPE_NSM }, + { 0x01172C, 0x0103, BIDI_TYPE_LTR }, + { 0x01182F, 0x0009, BIDI_TYPE_NSM }, + { 0x011838, 0x0001, BIDI_TYPE_LTR }, + { 0x011839, 0x0002, BIDI_TYPE_NSM }, + { 0x01183B, 0x01C6, BIDI_TYPE_LTR }, + { 0x011A01, 0x0006, BIDI_TYPE_NSM }, + { 0x011A07, 0x0002, BIDI_TYPE_LTR }, + { 0x011A09, 0x0002, BIDI_TYPE_NSM }, + { 0x011A0B, 0x0028, BIDI_TYPE_LTR }, + { 0x011A33, 0x0006, BIDI_TYPE_NSM }, + { 0x011A39, 0x0002, BIDI_TYPE_LTR }, + { 0x011A3B, 0x0004, BIDI_TYPE_NSM }, + { 0x011A3F, 0x0008, BIDI_TYPE_LTR }, + { 0x011A47, 0x0001, BIDI_TYPE_NSM }, + { 0x011A48, 0x0009, BIDI_TYPE_LTR }, + { 0x011A51, 0x0006, BIDI_TYPE_NSM }, + { 0x011A57, 0x0002, BIDI_TYPE_LTR }, + { 0x011A59, 0x0003, BIDI_TYPE_NSM }, + { 0x011A5C, 0x002E, BIDI_TYPE_LTR }, + { 0x011A8A, 0x000D, BIDI_TYPE_NSM }, + { 0x011A97, 0x0001, BIDI_TYPE_LTR }, + { 0x011A98, 0x0002, BIDI_TYPE_NSM }, + { 0x011A9A, 0x0196, BIDI_TYPE_LTR }, + { 0x011C30, 0x0007, BIDI_TYPE_NSM }, + { 0x011C37, 0x0001, BIDI_TYPE_LTR }, + { 0x011C38, 0x0006, BIDI_TYPE_NSM }, + { 0x011C3E, 0x0054, BIDI_TYPE_LTR }, + { 0x011C92, 0x0016, BIDI_TYPE_NSM }, + { 0x011CA8, 0x0002, BIDI_TYPE_LTR }, + { 0x011CAA, 0x0007, BIDI_TYPE_NSM }, + { 0x011CB1, 0x0001, BIDI_TYPE_LTR }, + { 0x011CB2, 0x0002, BIDI_TYPE_NSM }, + { 0x011CB4, 0x0001, BIDI_TYPE_LTR }, + { 0x011CB5, 0x0002, BIDI_TYPE_NSM }, + { 0x011CB7, 0x007A, BIDI_TYPE_LTR }, + { 0x011D31, 0x0006, BIDI_TYPE_NSM }, + { 0x011D37, 0x0003, BIDI_TYPE_LTR }, + { 0x011D3A, 0x0001, BIDI_TYPE_NSM }, + { 0x011D3B, 0x0001, BIDI_TYPE_LTR }, + { 0x011D3C, 0x0002, BIDI_TYPE_NSM }, + { 0x011D3E, 0x0001, BIDI_TYPE_LTR }, + { 0x011D3F, 0x0007, BIDI_TYPE_NSM }, + { 0x011D46, 0x0001, BIDI_TYPE_LTR }, + { 0x011D47, 0x0001, BIDI_TYPE_NSM }, + { 0x011D48, 0x0048, BIDI_TYPE_LTR }, + { 0x011D90, 0x0002, BIDI_TYPE_NSM }, + { 0x011D92, 0x0003, BIDI_TYPE_LTR }, + { 0x011D95, 0x0001, BIDI_TYPE_NSM }, + { 0x011D96, 0x0001, BIDI_TYPE_LTR }, + { 0x011D97, 0x0001, BIDI_TYPE_NSM }, + { 0x011D98, 0x015B, BIDI_TYPE_LTR }, + { 0x011EF3, 0x0002, BIDI_TYPE_NSM }, + { 0x011EF5, 0x4BFB, BIDI_TYPE_LTR }, + { 0x016AF0, 0x0005, BIDI_TYPE_NSM }, + { 0x016AF5, 0x003B, BIDI_TYPE_LTR }, + { 0x016B30, 0x0007, BIDI_TYPE_NSM }, + { 0x016B37, 0x0458, BIDI_TYPE_LTR }, + { 0x016F8F, 0x0004, BIDI_TYPE_NSM }, + { 0x016F93, 0x4D0A, BIDI_TYPE_LTR }, + { 0x01BC9D, 0x0002, BIDI_TYPE_NSM }, + { 0x01BC9F, 0x0001, BIDI_TYPE_LTR }, + { 0x01BCA0, 0x0004, BIDI_TYPE_BN }, + { 0x01BCA4, 0x14C3, BIDI_TYPE_LTR }, + { 0x01D167, 0x0003, BIDI_TYPE_NSM }, + { 0x01D16A, 0x0009, BIDI_TYPE_LTR }, + { 0x01D173, 0x0008, BIDI_TYPE_BN }, + { 0x01D17B, 0x0008, BIDI_TYPE_NSM }, + { 0x01D183, 0x0002, BIDI_TYPE_LTR }, + { 0x01D185, 0x0007, BIDI_TYPE_NSM }, + { 0x01D18C, 0x001E, BIDI_TYPE_LTR }, + { 0x01D1AA, 0x0004, BIDI_TYPE_NSM }, + { 0x01D1AE, 0x0052, BIDI_TYPE_LTR }, + { 0x01D200, 0x0042, BIDI_TYPE_ON }, + { 0x01D242, 0x0003, BIDI_TYPE_NSM }, + { 0x01D245, 0x0001, BIDI_TYPE_ON }, + { 0x01D246, 0x00BA, BIDI_TYPE_LTR }, + { 0x01D300, 0x0057, BIDI_TYPE_ON }, + { 0x01D357, 0x0384, BIDI_TYPE_LTR }, + { 0x01D6DB, 0x0001, BIDI_TYPE_ON }, + { 0x01D6DC, 0x0039, BIDI_TYPE_LTR }, + { 0x01D715, 0x0001, BIDI_TYPE_ON }, + { 0x01D716, 0x0039, BIDI_TYPE_LTR }, + { 0x01D74F, 0x0001, BIDI_TYPE_ON }, + { 0x01D750, 0x0039, BIDI_TYPE_LTR }, + { 0x01D789, 0x0001, BIDI_TYPE_ON }, + { 0x01D78A, 0x0039, BIDI_TYPE_LTR }, + { 0x01D7C3, 0x0001, BIDI_TYPE_ON }, + { 0x01D7C4, 0x000A, BIDI_TYPE_LTR }, + { 0x01D7CE, 0x0032, BIDI_TYPE_EN }, + { 0x01D800, 0x0200, BIDI_TYPE_LTR }, + { 0x01DA00, 0x0037, BIDI_TYPE_NSM }, + { 0x01DA37, 0x0004, BIDI_TYPE_LTR }, + { 0x01DA3B, 0x0032, BIDI_TYPE_NSM }, + { 0x01DA6D, 0x0008, BIDI_TYPE_LTR }, + { 0x01DA75, 0x0001, BIDI_TYPE_NSM }, + { 0x01DA76, 0x000E, BIDI_TYPE_LTR }, + { 0x01DA84, 0x0001, BIDI_TYPE_NSM }, + { 0x01DA85, 0x0016, BIDI_TYPE_LTR }, + { 0x01DA9B, 0x0005, BIDI_TYPE_NSM }, + { 0x01DAA0, 0x0001, BIDI_TYPE_LTR }, + { 0x01DAA1, 0x000F, BIDI_TYPE_NSM }, + { 0x01DAB0, 0x0550, BIDI_TYPE_LTR }, + { 0x01E000, 0x0007, BIDI_TYPE_NSM }, + { 0x01E007, 0x0001, BIDI_TYPE_LTR }, + { 0x01E008, 0x0011, BIDI_TYPE_NSM }, + { 0x01E019, 0x0002, BIDI_TYPE_LTR }, + { 0x01E01B, 0x0007, BIDI_TYPE_NSM }, + { 0x01E022, 0x0001, BIDI_TYPE_LTR }, + { 0x01E023, 0x0002, BIDI_TYPE_NSM }, + { 0x01E025, 0x0001, BIDI_TYPE_LTR }, + { 0x01E026, 0x0005, BIDI_TYPE_NSM }, + { 0x01E02B, 0x07D5, BIDI_TYPE_LTR }, + { 0x01E800, 0x00D0, BIDI_TYPE_RTL }, + { 0x01E8D0, 0x0007, BIDI_TYPE_NSM }, + { 0x01E8D7, 0x006D, BIDI_TYPE_RTL }, + { 0x01E944, 0x0007, BIDI_TYPE_NSM }, + { 0x01E94B, 0x0325, BIDI_TYPE_RTL }, + { 0x01EC70, 0x0050, BIDI_TYPE_AL }, + { 0x01ECC0, 0x0140, BIDI_TYPE_RTL }, + { 0x01EE00, 0x00F0, BIDI_TYPE_AL }, + { 0x01EEF0, 0x0002, BIDI_TYPE_ON }, + { 0x01EEF2, 0x000E, BIDI_TYPE_AL }, + { 0x01EF00, 0x0100, BIDI_TYPE_RTL }, + { 0x01F000, 0x002C, BIDI_TYPE_ON }, + { 0x01F02C, 0x0004, BIDI_TYPE_LTR }, + { 0x01F030, 0x0064, BIDI_TYPE_ON }, + { 0x01F094, 0x000C, BIDI_TYPE_LTR }, + { 0x01F0A0, 0x000F, BIDI_TYPE_ON }, + { 0x01F0AF, 0x0002, BIDI_TYPE_LTR }, + { 0x01F0B1, 0x000F, BIDI_TYPE_ON }, + { 0x01F0C0, 0x0001, BIDI_TYPE_LTR }, + { 0x01F0C1, 0x000F, BIDI_TYPE_ON }, + { 0x01F0D0, 0x0001, BIDI_TYPE_LTR }, + { 0x01F0D1, 0x0025, BIDI_TYPE_ON }, + { 0x01F0F6, 0x000A, BIDI_TYPE_LTR }, + { 0x01F100, 0x000B, BIDI_TYPE_EN }, + { 0x01F10B, 0x0002, BIDI_TYPE_ON }, + { 0x01F10D, 0x0022, BIDI_TYPE_LTR }, + { 0x01F12F, 0x0001, BIDI_TYPE_ON }, + { 0x01F130, 0x003A, BIDI_TYPE_LTR }, + { 0x01F16A, 0x0002, BIDI_TYPE_ON }, + { 0x01F16C, 0x00F4, BIDI_TYPE_LTR }, + { 0x01F260, 0x0006, BIDI_TYPE_ON }, + { 0x01F266, 0x009A, BIDI_TYPE_LTR }, + { 0x01F300, 0x03D5, BIDI_TYPE_ON }, + { 0x01F6D5, 0x000B, BIDI_TYPE_LTR }, + { 0x01F6E0, 0x000D, BIDI_TYPE_ON }, + { 0x01F6ED, 0x0003, BIDI_TYPE_LTR }, + { 0x01F6F0, 0x000A, BIDI_TYPE_ON }, + { 0x01F6FA, 0x0006, BIDI_TYPE_LTR }, + { 0x01F700, 0x0074, BIDI_TYPE_ON }, + { 0x01F774, 0x000C, BIDI_TYPE_LTR }, + { 0x01F780, 0x0059, BIDI_TYPE_ON }, + { 0x01F7D9, 0x0027, BIDI_TYPE_LTR }, + { 0x01F800, 0x000C, BIDI_TYPE_ON }, + { 0x01F80C, 0x0004, BIDI_TYPE_LTR }, + { 0x01F810, 0x0038, BIDI_TYPE_ON }, + { 0x01F848, 0x0008, BIDI_TYPE_LTR }, + { 0x01F850, 0x000A, BIDI_TYPE_ON }, + { 0x01F85A, 0x0006, BIDI_TYPE_LTR }, + { 0x01F860, 0x0028, BIDI_TYPE_ON }, + { 0x01F888, 0x0008, BIDI_TYPE_LTR }, + { 0x01F890, 0x001E, BIDI_TYPE_ON }, + { 0x01F8AE, 0x0052, BIDI_TYPE_LTR }, + { 0x01F900, 0x000C, BIDI_TYPE_ON }, + { 0x01F90C, 0x0004, BIDI_TYPE_LTR }, + { 0x01F910, 0x002F, BIDI_TYPE_ON }, + { 0x01F93F, 0x0001, BIDI_TYPE_LTR }, + { 0x01F940, 0x0031, BIDI_TYPE_ON }, + { 0x01F971, 0x0002, BIDI_TYPE_LTR }, + { 0x01F973, 0x0004, BIDI_TYPE_ON }, + { 0x01F977, 0x0003, BIDI_TYPE_LTR }, + { 0x01F97A, 0x0001, BIDI_TYPE_ON }, + { 0x01F97B, 0x0001, BIDI_TYPE_LTR }, + { 0x01F97C, 0x0027, BIDI_TYPE_ON }, + { 0x01F9A3, 0x000D, BIDI_TYPE_LTR }, + { 0x01F9B0, 0x000A, BIDI_TYPE_ON }, + { 0x01F9BA, 0x0006, BIDI_TYPE_LTR }, + { 0x01F9C0, 0x0003, BIDI_TYPE_ON }, + { 0x01F9C3, 0x000D, BIDI_TYPE_LTR }, + { 0x01F9D0, 0x0030, BIDI_TYPE_ON }, + { 0x01FA00, 0x0060, BIDI_TYPE_LTR }, + { 0x01FA60, 0x000E, BIDI_TYPE_ON }, + { 0x01FA6E, 0x0590, BIDI_TYPE_LTR }, + { 0x01FFFE, 0x0002, BIDI_TYPE_BN }, + { 0x020000, 0xFFFE, BIDI_TYPE_LTR }, + { 0x02FFFE, 0x0002, BIDI_TYPE_BN }, + { 0x030000, 0xFFFE, BIDI_TYPE_LTR }, + { 0x03FFFE, 0x0002, BIDI_TYPE_BN }, + { 0x040000, 0xFFFE, BIDI_TYPE_LTR }, + { 0x04FFFE, 0x0002, BIDI_TYPE_BN }, + { 0x050000, 0xFFFE, BIDI_TYPE_LTR }, + { 0x05FFFE, 0x0002, BIDI_TYPE_BN }, + { 0x060000, 0xFFFE, BIDI_TYPE_LTR }, + { 0x06FFFE, 0x0002, BIDI_TYPE_BN }, + { 0x070000, 0xFFFE, BIDI_TYPE_LTR }, + { 0x07FFFE, 0x0002, BIDI_TYPE_BN }, + { 0x080000, 0xFFFE, BIDI_TYPE_LTR }, + { 0x08FFFE, 0x0002, BIDI_TYPE_BN }, + { 0x090000, 0xFFFE, BIDI_TYPE_LTR }, + { 0x09FFFE, 0x0002, BIDI_TYPE_BN }, + { 0x0A0000, 0xFFFE, BIDI_TYPE_LTR }, + { 0x0AFFFE, 0x0002, BIDI_TYPE_BN }, + { 0x0B0000, 0xFFFE, BIDI_TYPE_LTR }, + { 0x0BFFFE, 0x0002, BIDI_TYPE_BN }, + { 0x0C0000, 0xFFFE, BIDI_TYPE_LTR }, + { 0x0CFFFE, 0x0002, BIDI_TYPE_BN }, + { 0x0D0000, 0xFFFE, BIDI_TYPE_LTR }, + { 0x0DFFFE, 0x0102, BIDI_TYPE_BN }, + { 0x0E0100, 0x00F0, BIDI_TYPE_NSM }, + { 0x0E01F0, 0x0E10, BIDI_TYPE_BN }, + { 0x0E1000, 0xEFFE, BIDI_TYPE_LTR }, + { 0x0EFFFE, 0x0002, BIDI_TYPE_BN }, + { 0x0F0000, 0xFFFE, BIDI_TYPE_LTR }, + { 0x0FFFFE, 0x0002, BIDI_TYPE_BN }, + { 0x100000, 0xFFFE, BIDI_TYPE_LTR }, }; -static const BIDICHAR_MIRROR_MAP __mg_unicode_mirror_table []= +static const BIDICHAR_BRACKET __mg_unicode_bracket_table[] = { - {0x0028, 0x0029}, - {0x003c, 0x003e}, - {0x005b, 0x005d}, - {0x007b, 0x007d}, - {0x00ab, 0x00bb}, - {0x2039, 0x203a}, - {0x2045, 0x2046}, - {0x207d, 0x207e}, - {0x208d, 0x208e}, - {0x2208, 0x220b}, - {0x2209, 0x220c}, - {0x220a, 0x220d}, - {0x2215, 0x29f5}, - {0x2768, 0x2769}, - {0x276a, 0x276b}, - {0x276c, 0x276d}, - {0x276e, 0x276f}, - {0x2770, 0x2771}, - {0x2772, 0x2773}, - {0x2774, 0x2775}, - {0x27d5, 0x27d6}, - {0x27dd, 0x27de}, - {0x27e2, 0x27e3}, - {0x27e4, 0x27e5}, - {0x27e6, 0x27e7}, - {0x27e8, 0x27e9}, - {0x27ea, 0x27eb}, - {0x3008, 0x3009}, - {0x300a, 0x300b}, - {0x300c, 0x300d}, - {0x300e, 0x300f}, - {0x3010, 0x3011}, - {0x3014, 0x3015}, - {0x3016, 0x3017}, - {0x3018, 0x3019}, - {0x301a, 0x301b}, - {0xff08, 0xff09}, - {0xff1c, 0xff1e}, - {0xff3b, 0xff3d}, - {0xff5b, 0xff5d}, - {0xff5f, 0xff60}, - {0xff62, 0xff63} + { 0x000028, BIDICHAR_BRACKET_OPEN }, + { 0x000029, BIDICHAR_BRACKET_CLOSE }, + { 0x00005B, BIDICHAR_BRACKET_OPEN }, + { 0x00005D, BIDICHAR_BRACKET_CLOSE }, + { 0x00007B, BIDICHAR_BRACKET_OPEN }, + { 0x00007D, BIDICHAR_BRACKET_CLOSE }, + { 0x000F3A, BIDICHAR_BRACKET_OPEN }, + { 0x000F3B, BIDICHAR_BRACKET_CLOSE }, + { 0x000F3C, BIDICHAR_BRACKET_OPEN }, + { 0x000F3D, BIDICHAR_BRACKET_CLOSE }, + { 0x00169B, BIDICHAR_BRACKET_OPEN }, + { 0x00169C, BIDICHAR_BRACKET_CLOSE }, + { 0x002045, BIDICHAR_BRACKET_OPEN }, + { 0x002046, BIDICHAR_BRACKET_CLOSE }, + { 0x00207D, BIDICHAR_BRACKET_OPEN }, + { 0x00207E, BIDICHAR_BRACKET_CLOSE }, + { 0x00208D, BIDICHAR_BRACKET_OPEN }, + { 0x00208E, BIDICHAR_BRACKET_CLOSE }, + { 0x002308, BIDICHAR_BRACKET_OPEN }, + { 0x002309, BIDICHAR_BRACKET_CLOSE }, + { 0x00230A, BIDICHAR_BRACKET_OPEN }, + { 0x00230B, BIDICHAR_BRACKET_CLOSE }, + { 0x002329, BIDICHAR_BRACKET_OPEN }, + { 0x00232A, BIDICHAR_BRACKET_CLOSE }, + { 0x002768, BIDICHAR_BRACKET_OPEN }, + { 0x002769, BIDICHAR_BRACKET_CLOSE }, + { 0x00276A, BIDICHAR_BRACKET_OPEN }, + { 0x00276B, BIDICHAR_BRACKET_CLOSE }, + { 0x00276C, BIDICHAR_BRACKET_OPEN }, + { 0x00276D, BIDICHAR_BRACKET_CLOSE }, + { 0x00276E, BIDICHAR_BRACKET_OPEN }, + { 0x00276F, BIDICHAR_BRACKET_CLOSE }, + { 0x002770, BIDICHAR_BRACKET_OPEN }, + { 0x002771, BIDICHAR_BRACKET_CLOSE }, + { 0x002772, BIDICHAR_BRACKET_OPEN }, + { 0x002773, BIDICHAR_BRACKET_CLOSE }, + { 0x002774, BIDICHAR_BRACKET_OPEN }, + { 0x002775, BIDICHAR_BRACKET_CLOSE }, + { 0x0027C5, BIDICHAR_BRACKET_OPEN }, + { 0x0027C6, BIDICHAR_BRACKET_CLOSE }, + { 0x0027E6, BIDICHAR_BRACKET_OPEN }, + { 0x0027E7, BIDICHAR_BRACKET_CLOSE }, + { 0x0027E8, BIDICHAR_BRACKET_OPEN }, + { 0x0027E9, BIDICHAR_BRACKET_CLOSE }, + { 0x0027EA, BIDICHAR_BRACKET_OPEN }, + { 0x0027EB, BIDICHAR_BRACKET_CLOSE }, + { 0x0027EC, BIDICHAR_BRACKET_OPEN }, + { 0x0027ED, BIDICHAR_BRACKET_CLOSE }, + { 0x0027EE, BIDICHAR_BRACKET_OPEN }, + { 0x0027EF, BIDICHAR_BRACKET_CLOSE }, + { 0x002983, BIDICHAR_BRACKET_OPEN }, + { 0x002984, BIDICHAR_BRACKET_CLOSE }, + { 0x002985, BIDICHAR_BRACKET_OPEN }, + { 0x002986, BIDICHAR_BRACKET_CLOSE }, + { 0x002987, BIDICHAR_BRACKET_OPEN }, + { 0x002988, BIDICHAR_BRACKET_CLOSE }, + { 0x002989, BIDICHAR_BRACKET_OPEN }, + { 0x00298A, BIDICHAR_BRACKET_CLOSE }, + { 0x00298B, BIDICHAR_BRACKET_OPEN }, + { 0x00298C, BIDICHAR_BRACKET_CLOSE }, + { 0x00298D, BIDICHAR_BRACKET_OPEN }, + { 0x00298E, BIDICHAR_BRACKET_CLOSE }, + { 0x00298F, BIDICHAR_BRACKET_OPEN }, + { 0x002990, BIDICHAR_BRACKET_CLOSE }, + { 0x002991, BIDICHAR_BRACKET_OPEN }, + { 0x002992, BIDICHAR_BRACKET_CLOSE }, + { 0x002993, BIDICHAR_BRACKET_OPEN }, + { 0x002994, BIDICHAR_BRACKET_CLOSE }, + { 0x002995, BIDICHAR_BRACKET_OPEN }, + { 0x002996, BIDICHAR_BRACKET_CLOSE }, + { 0x002997, BIDICHAR_BRACKET_OPEN }, + { 0x002998, BIDICHAR_BRACKET_CLOSE }, + { 0x0029D8, BIDICHAR_BRACKET_OPEN }, + { 0x0029D9, BIDICHAR_BRACKET_CLOSE }, + { 0x0029DA, BIDICHAR_BRACKET_OPEN }, + { 0x0029DB, BIDICHAR_BRACKET_CLOSE }, + { 0x0029FC, BIDICHAR_BRACKET_OPEN }, + { 0x0029FD, BIDICHAR_BRACKET_CLOSE }, + { 0x002E22, BIDICHAR_BRACKET_OPEN }, + { 0x002E23, BIDICHAR_BRACKET_CLOSE }, + { 0x002E24, BIDICHAR_BRACKET_OPEN }, + { 0x002E25, BIDICHAR_BRACKET_CLOSE }, + { 0x002E26, BIDICHAR_BRACKET_OPEN }, + { 0x002E27, BIDICHAR_BRACKET_CLOSE }, + { 0x002E28, BIDICHAR_BRACKET_OPEN }, + { 0x002E29, BIDICHAR_BRACKET_CLOSE }, + { 0x003008, BIDICHAR_BRACKET_OPEN }, + { 0x003009, BIDICHAR_BRACKET_CLOSE }, + { 0x00300A, BIDICHAR_BRACKET_OPEN }, + { 0x00300B, BIDICHAR_BRACKET_CLOSE }, + { 0x00300C, BIDICHAR_BRACKET_OPEN }, + { 0x00300D, BIDICHAR_BRACKET_CLOSE }, + { 0x00300E, BIDICHAR_BRACKET_OPEN }, + { 0x00300F, BIDICHAR_BRACKET_CLOSE }, + { 0x003010, BIDICHAR_BRACKET_OPEN }, + { 0x003011, BIDICHAR_BRACKET_CLOSE }, + { 0x003014, BIDICHAR_BRACKET_OPEN }, + { 0x003015, BIDICHAR_BRACKET_CLOSE }, + { 0x003016, BIDICHAR_BRACKET_OPEN }, + { 0x003017, BIDICHAR_BRACKET_CLOSE }, + { 0x003018, BIDICHAR_BRACKET_OPEN }, + { 0x003019, BIDICHAR_BRACKET_CLOSE }, + { 0x00301A, BIDICHAR_BRACKET_OPEN }, + { 0x00301B, BIDICHAR_BRACKET_CLOSE }, + { 0x00FE59, BIDICHAR_BRACKET_OPEN }, + { 0x00FE5A, BIDICHAR_BRACKET_CLOSE }, + { 0x00FE5B, BIDICHAR_BRACKET_OPEN }, + { 0x00FE5C, BIDICHAR_BRACKET_CLOSE }, + { 0x00FE5D, BIDICHAR_BRACKET_OPEN }, + { 0x00FE5E, BIDICHAR_BRACKET_CLOSE }, + { 0x00FF08, BIDICHAR_BRACKET_OPEN }, + { 0x00FF09, BIDICHAR_BRACKET_CLOSE }, + { 0x00FF3B, BIDICHAR_BRACKET_OPEN }, + { 0x00FF3D, BIDICHAR_BRACKET_CLOSE }, + { 0x00FF5B, BIDICHAR_BRACKET_OPEN }, + { 0x00FF5D, BIDICHAR_BRACKET_CLOSE }, + { 0x00FF5F, BIDICHAR_BRACKET_OPEN }, + { 0x00FF60, BIDICHAR_BRACKET_CLOSE }, + { 0x00FF62, BIDICHAR_BRACKET_OPEN }, + { 0x00FF63, BIDICHAR_BRACKET_CLOSE }, +}; + +static const BIDICHAR_MIRROR_MAP __mg_unicode_mirror_table[] = +{ + { 0x000028, 0x000029 }, + { 0x000029, 0x000028 }, + { 0x00003C, 0x00003E }, + { 0x00003E, 0x00003C }, + { 0x00005B, 0x00005D }, + { 0x00005D, 0x00005B }, + { 0x00007B, 0x00007D }, + { 0x00007D, 0x00007B }, + { 0x0000AB, 0x0000BB }, + { 0x0000BB, 0x0000AB }, + { 0x000F3A, 0x000F3B }, + { 0x000F3B, 0x000F3A }, + { 0x000F3C, 0x000F3D }, + { 0x000F3D, 0x000F3C }, + { 0x00169B, 0x00169C }, + { 0x00169C, 0x00169B }, + { 0x002039, 0x00203A }, + { 0x00203A, 0x002039 }, + { 0x002045, 0x002046 }, + { 0x002046, 0x002045 }, + { 0x00207D, 0x00207E }, + { 0x00207E, 0x00207D }, + { 0x00208D, 0x00208E }, + { 0x00208E, 0x00208D }, + { 0x002208, 0x00220B }, + { 0x002209, 0x00220C }, + { 0x00220A, 0x00220D }, + { 0x00220B, 0x002208 }, + { 0x00220C, 0x002209 }, + { 0x00220D, 0x00220A }, + { 0x002215, 0x0029F5 }, + { 0x00221F, 0x002BFE }, + { 0x002220, 0x0029A3 }, + { 0x002221, 0x00299B }, + { 0x002222, 0x0029A0 }, + { 0x002224, 0x002AEE }, + { 0x00223C, 0x00223D }, + { 0x00223D, 0x00223C }, + { 0x002243, 0x0022CD }, + { 0x002245, 0x00224C }, + { 0x00224C, 0x002245 }, + { 0x002252, 0x002253 }, + { 0x002253, 0x002252 }, + { 0x002254, 0x002255 }, + { 0x002255, 0x002254 }, + { 0x002264, 0x002265 }, + { 0x002265, 0x002264 }, + { 0x002266, 0x002267 }, + { 0x002267, 0x002266 }, + { 0x002268, 0x002269 }, + { 0x002269, 0x002268 }, + { 0x00226A, 0x00226B }, + { 0x00226B, 0x00226A }, + { 0x00226E, 0x00226F }, + { 0x00226F, 0x00226E }, + { 0x002270, 0x002271 }, + { 0x002271, 0x002270 }, + { 0x002272, 0x002273 }, + { 0x002273, 0x002272 }, + { 0x002274, 0x002275 }, + { 0x002275, 0x002274 }, + { 0x002276, 0x002277 }, + { 0x002277, 0x002276 }, + { 0x002278, 0x002279 }, + { 0x002279, 0x002278 }, + { 0x00227A, 0x00227B }, + { 0x00227B, 0x00227A }, + { 0x00227C, 0x00227D }, + { 0x00227D, 0x00227C }, + { 0x00227E, 0x00227F }, + { 0x00227F, 0x00227E }, + { 0x002280, 0x002281 }, + { 0x002281, 0x002280 }, + { 0x002282, 0x002283 }, + { 0x002283, 0x002282 }, + { 0x002284, 0x002285 }, + { 0x002285, 0x002284 }, + { 0x002286, 0x002287 }, + { 0x002287, 0x002286 }, + { 0x002288, 0x002289 }, + { 0x002289, 0x002288 }, + { 0x00228A, 0x00228B }, + { 0x00228B, 0x00228A }, + { 0x00228F, 0x002290 }, + { 0x002290, 0x00228F }, + { 0x002291, 0x002292 }, + { 0x002292, 0x002291 }, + { 0x002298, 0x0029B8 }, + { 0x0022A2, 0x0022A3 }, + { 0x0022A3, 0x0022A2 }, + { 0x0022A6, 0x002ADE }, + { 0x0022A8, 0x002AE4 }, + { 0x0022A9, 0x002AE3 }, + { 0x0022AB, 0x002AE5 }, + { 0x0022B0, 0x0022B1 }, + { 0x0022B1, 0x0022B0 }, + { 0x0022B2, 0x0022B3 }, + { 0x0022B3, 0x0022B2 }, + { 0x0022B4, 0x0022B5 }, + { 0x0022B5, 0x0022B4 }, + { 0x0022B6, 0x0022B7 }, + { 0x0022B7, 0x0022B6 }, + { 0x0022B8, 0x0027DC }, + { 0x0022C9, 0x0022CA }, + { 0x0022CA, 0x0022C9 }, + { 0x0022CB, 0x0022CC }, + { 0x0022CC, 0x0022CB }, + { 0x0022CD, 0x002243 }, + { 0x0022D0, 0x0022D1 }, + { 0x0022D1, 0x0022D0 }, + { 0x0022D6, 0x0022D7 }, + { 0x0022D7, 0x0022D6 }, + { 0x0022D8, 0x0022D9 }, + { 0x0022D9, 0x0022D8 }, + { 0x0022DA, 0x0022DB }, + { 0x0022DB, 0x0022DA }, + { 0x0022DC, 0x0022DD }, + { 0x0022DD, 0x0022DC }, + { 0x0022DE, 0x0022DF }, + { 0x0022DF, 0x0022DE }, + { 0x0022E0, 0x0022E1 }, + { 0x0022E1, 0x0022E0 }, + { 0x0022E2, 0x0022E3 }, + { 0x0022E3, 0x0022E2 }, + { 0x0022E4, 0x0022E5 }, + { 0x0022E5, 0x0022E4 }, + { 0x0022E6, 0x0022E7 }, + { 0x0022E7, 0x0022E6 }, + { 0x0022E8, 0x0022E9 }, + { 0x0022E9, 0x0022E8 }, + { 0x0022EA, 0x0022EB }, + { 0x0022EB, 0x0022EA }, + { 0x0022EC, 0x0022ED }, + { 0x0022ED, 0x0022EC }, + { 0x0022F0, 0x0022F1 }, + { 0x0022F1, 0x0022F0 }, + { 0x0022F2, 0x0022FA }, + { 0x0022F3, 0x0022FB }, + { 0x0022F4, 0x0022FC }, + { 0x0022F6, 0x0022FD }, + { 0x0022F7, 0x0022FE }, + { 0x0022FA, 0x0022F2 }, + { 0x0022FB, 0x0022F3 }, + { 0x0022FC, 0x0022F4 }, + { 0x0022FD, 0x0022F6 }, + { 0x0022FE, 0x0022F7 }, + { 0x002308, 0x002309 }, + { 0x002309, 0x002308 }, + { 0x00230A, 0x00230B }, + { 0x00230B, 0x00230A }, + { 0x002329, 0x00232A }, + { 0x00232A, 0x002329 }, + { 0x002768, 0x002769 }, + { 0x002769, 0x002768 }, + { 0x00276A, 0x00276B }, + { 0x00276B, 0x00276A }, + { 0x00276C, 0x00276D }, + { 0x00276D, 0x00276C }, + { 0x00276E, 0x00276F }, + { 0x00276F, 0x00276E }, + { 0x002770, 0x002771 }, + { 0x002771, 0x002770 }, + { 0x002772, 0x002773 }, + { 0x002773, 0x002772 }, + { 0x002774, 0x002775 }, + { 0x002775, 0x002774 }, + { 0x0027C3, 0x0027C4 }, + { 0x0027C4, 0x0027C3 }, + { 0x0027C5, 0x0027C6 }, + { 0x0027C6, 0x0027C5 }, + { 0x0027C8, 0x0027C9 }, + { 0x0027C9, 0x0027C8 }, + { 0x0027CB, 0x0027CD }, + { 0x0027CD, 0x0027CB }, + { 0x0027D5, 0x0027D6 }, + { 0x0027D6, 0x0027D5 }, + { 0x0027DC, 0x0022B8 }, + { 0x0027DD, 0x0027DE }, + { 0x0027DE, 0x0027DD }, + { 0x0027E2, 0x0027E3 }, + { 0x0027E3, 0x0027E2 }, + { 0x0027E4, 0x0027E5 }, + { 0x0027E5, 0x0027E4 }, + { 0x0027E6, 0x0027E7 }, + { 0x0027E7, 0x0027E6 }, + { 0x0027E8, 0x0027E9 }, + { 0x0027E9, 0x0027E8 }, + { 0x0027EA, 0x0027EB }, + { 0x0027EB, 0x0027EA }, + { 0x0027EC, 0x0027ED }, + { 0x0027ED, 0x0027EC }, + { 0x0027EE, 0x0027EF }, + { 0x0027EF, 0x0027EE }, + { 0x002983, 0x002984 }, + { 0x002984, 0x002983 }, + { 0x002985, 0x002986 }, + { 0x002986, 0x002985 }, + { 0x002987, 0x002988 }, + { 0x002988, 0x002987 }, + { 0x002989, 0x00298A }, + { 0x00298A, 0x002989 }, + { 0x00298B, 0x00298C }, + { 0x00298C, 0x00298B }, + { 0x00298D, 0x002990 }, + { 0x00298E, 0x00298F }, + { 0x00298F, 0x00298E }, + { 0x002990, 0x00298D }, + { 0x002991, 0x002992 }, + { 0x002992, 0x002991 }, + { 0x002993, 0x002994 }, + { 0x002994, 0x002993 }, + { 0x002995, 0x002996 }, + { 0x002996, 0x002995 }, + { 0x002997, 0x002998 }, + { 0x002998, 0x002997 }, + { 0x00299B, 0x002221 }, + { 0x0029A0, 0x002222 }, + { 0x0029A3, 0x002220 }, + { 0x0029A4, 0x0029A5 }, + { 0x0029A5, 0x0029A4 }, + { 0x0029A8, 0x0029A9 }, + { 0x0029A9, 0x0029A8 }, + { 0x0029AA, 0x0029AB }, + { 0x0029AB, 0x0029AA }, + { 0x0029AC, 0x0029AD }, + { 0x0029AD, 0x0029AC }, + { 0x0029AE, 0x0029AF }, + { 0x0029AF, 0x0029AE }, + { 0x0029B8, 0x002298 }, + { 0x0029C0, 0x0029C1 }, + { 0x0029C1, 0x0029C0 }, + { 0x0029C4, 0x0029C5 }, + { 0x0029C5, 0x0029C4 }, + { 0x0029CF, 0x0029D0 }, + { 0x0029D0, 0x0029CF }, + { 0x0029D1, 0x0029D2 }, + { 0x0029D2, 0x0029D1 }, + { 0x0029D4, 0x0029D5 }, + { 0x0029D5, 0x0029D4 }, + { 0x0029D8, 0x0029D9 }, + { 0x0029D9, 0x0029D8 }, + { 0x0029DA, 0x0029DB }, + { 0x0029DB, 0x0029DA }, + { 0x0029E8, 0x0029E9 }, + { 0x0029E9, 0x0029E8 }, + { 0x0029F5, 0x002215 }, + { 0x0029F8, 0x0029F9 }, + { 0x0029F9, 0x0029F8 }, + { 0x0029FC, 0x0029FD }, + { 0x0029FD, 0x0029FC }, + { 0x002A2B, 0x002A2C }, + { 0x002A2C, 0x002A2B }, + { 0x002A2D, 0x002A2E }, + { 0x002A2E, 0x002A2D }, + { 0x002A34, 0x002A35 }, + { 0x002A35, 0x002A34 }, + { 0x002A3C, 0x002A3D }, + { 0x002A3D, 0x002A3C }, + { 0x002A64, 0x002A65 }, + { 0x002A65, 0x002A64 }, + { 0x002A79, 0x002A7A }, + { 0x002A7A, 0x002A79 }, + { 0x002A7B, 0x002A7C }, + { 0x002A7C, 0x002A7B }, + { 0x002A7D, 0x002A7E }, + { 0x002A7E, 0x002A7D }, + { 0x002A7F, 0x002A80 }, + { 0x002A80, 0x002A7F }, + { 0x002A81, 0x002A82 }, + { 0x002A82, 0x002A81 }, + { 0x002A83, 0x002A84 }, + { 0x002A84, 0x002A83 }, + { 0x002A85, 0x002A86 }, + { 0x002A86, 0x002A85 }, + { 0x002A87, 0x002A88 }, + { 0x002A88, 0x002A87 }, + { 0x002A89, 0x002A8A }, + { 0x002A8A, 0x002A89 }, + { 0x002A8B, 0x002A8C }, + { 0x002A8C, 0x002A8B }, + { 0x002A8D, 0x002A8E }, + { 0x002A8E, 0x002A8D }, + { 0x002A8F, 0x002A90 }, + { 0x002A90, 0x002A8F }, + { 0x002A91, 0x002A92 }, + { 0x002A92, 0x002A91 }, + { 0x002A93, 0x002A94 }, + { 0x002A94, 0x002A93 }, + { 0x002A95, 0x002A96 }, + { 0x002A96, 0x002A95 }, + { 0x002A97, 0x002A98 }, + { 0x002A98, 0x002A97 }, + { 0x002A99, 0x002A9A }, + { 0x002A9A, 0x002A99 }, + { 0x002A9B, 0x002A9C }, + { 0x002A9C, 0x002A9B }, + { 0x002A9D, 0x002A9E }, + { 0x002A9E, 0x002A9D }, + { 0x002A9F, 0x002AA0 }, + { 0x002AA0, 0x002A9F }, + { 0x002AA1, 0x002AA2 }, + { 0x002AA2, 0x002AA1 }, + { 0x002AA6, 0x002AA7 }, + { 0x002AA7, 0x002AA6 }, + { 0x002AA8, 0x002AA9 }, + { 0x002AA9, 0x002AA8 }, + { 0x002AAA, 0x002AAB }, + { 0x002AAB, 0x002AAA }, + { 0x002AAC, 0x002AAD }, + { 0x002AAD, 0x002AAC }, + { 0x002AAF, 0x002AB0 }, + { 0x002AB0, 0x002AAF }, + { 0x002AB1, 0x002AB2 }, + { 0x002AB2, 0x002AB1 }, + { 0x002AB3, 0x002AB4 }, + { 0x002AB4, 0x002AB3 }, + { 0x002AB5, 0x002AB6 }, + { 0x002AB6, 0x002AB5 }, + { 0x002AB7, 0x002AB8 }, + { 0x002AB8, 0x002AB7 }, + { 0x002AB9, 0x002ABA }, + { 0x002ABA, 0x002AB9 }, + { 0x002ABB, 0x002ABC }, + { 0x002ABC, 0x002ABB }, + { 0x002ABD, 0x002ABE }, + { 0x002ABE, 0x002ABD }, + { 0x002ABF, 0x002AC0 }, + { 0x002AC0, 0x002ABF }, + { 0x002AC1, 0x002AC2 }, + { 0x002AC2, 0x002AC1 }, + { 0x002AC3, 0x002AC4 }, + { 0x002AC4, 0x002AC3 }, + { 0x002AC5, 0x002AC6 }, + { 0x002AC6, 0x002AC5 }, + { 0x002AC7, 0x002AC8 }, + { 0x002AC8, 0x002AC7 }, + { 0x002AC9, 0x002ACA }, + { 0x002ACA, 0x002AC9 }, + { 0x002ACB, 0x002ACC }, + { 0x002ACC, 0x002ACB }, + { 0x002ACD, 0x002ACE }, + { 0x002ACE, 0x002ACD }, + { 0x002ACF, 0x002AD0 }, + { 0x002AD0, 0x002ACF }, + { 0x002AD1, 0x002AD2 }, + { 0x002AD2, 0x002AD1 }, + { 0x002AD3, 0x002AD4 }, + { 0x002AD4, 0x002AD3 }, + { 0x002AD5, 0x002AD6 }, + { 0x002AD6, 0x002AD5 }, + { 0x002ADE, 0x0022A6 }, + { 0x002AE3, 0x0022A9 }, + { 0x002AE4, 0x0022A8 }, + { 0x002AE5, 0x0022AB }, + { 0x002AEC, 0x002AED }, + { 0x002AED, 0x002AEC }, + { 0x002AEE, 0x002224 }, + { 0x002AF7, 0x002AF8 }, + { 0x002AF8, 0x002AF7 }, + { 0x002AF9, 0x002AFA }, + { 0x002AFA, 0x002AF9 }, + { 0x002BFE, 0x00221F }, + { 0x002E02, 0x002E03 }, + { 0x002E03, 0x002E02 }, + { 0x002E04, 0x002E05 }, + { 0x002E05, 0x002E04 }, + { 0x002E09, 0x002E0A }, + { 0x002E0A, 0x002E09 }, + { 0x002E0C, 0x002E0D }, + { 0x002E0D, 0x002E0C }, + { 0x002E1C, 0x002E1D }, + { 0x002E1D, 0x002E1C }, + { 0x002E20, 0x002E21 }, + { 0x002E21, 0x002E20 }, + { 0x002E22, 0x002E23 }, + { 0x002E23, 0x002E22 }, + { 0x002E24, 0x002E25 }, + { 0x002E25, 0x002E24 }, + { 0x002E26, 0x002E27 }, + { 0x002E27, 0x002E26 }, + { 0x002E28, 0x002E29 }, + { 0x002E29, 0x002E28 }, + { 0x003008, 0x003009 }, + { 0x003009, 0x003008 }, + { 0x00300A, 0x00300B }, + { 0x00300B, 0x00300A }, + { 0x00300C, 0x00300D }, + { 0x00300D, 0x00300C }, + { 0x00300E, 0x00300F }, + { 0x00300F, 0x00300E }, + { 0x003010, 0x003011 }, + { 0x003011, 0x003010 }, + { 0x003014, 0x003015 }, + { 0x003015, 0x003014 }, + { 0x003016, 0x003017 }, + { 0x003017, 0x003016 }, + { 0x003018, 0x003019 }, + { 0x003019, 0x003018 }, + { 0x00301A, 0x00301B }, + { 0x00301B, 0x00301A }, + { 0x00FE59, 0x00FE5A }, + { 0x00FE5A, 0x00FE59 }, + { 0x00FE5B, 0x00FE5C }, + { 0x00FE5C, 0x00FE5B }, + { 0x00FE5D, 0x00FE5E }, + { 0x00FE5E, 0x00FE5D }, + { 0x00FE64, 0x00FE65 }, + { 0x00FE65, 0x00FE64 }, + { 0x00FF08, 0x00FF09 }, + { 0x00FF09, 0x00FF08 }, + { 0x00FF1C, 0x00FF1E }, + { 0x00FF1E, 0x00FF1C }, + { 0x00FF3B, 0x00FF3D }, + { 0x00FF3D, 0x00FF3B }, + { 0x00FF5B, 0x00FF5D }, + { 0x00FF5D, 0x00FF5B }, + { 0x00FF5F, 0x00FF60 }, + { 0x00FF60, 0x00FF5F }, + { 0x00FF62, 0x00FF63 }, + { 0x00FF63, 0x00FF62 }, }; #endif /* !_UNICODE_BIDI_TABLES_H */ +/* == End of generated table == */ diff --git a/src/font/utils/fetch-ucd.sh b/src/font/utils/fetch-ucd.sh index 3ce8214a..da376bb1 100755 --- a/src/font/utils/fetch-ucd.sh +++ b/src/font/utils/fetch-ucd.sh @@ -1,7 +1,7 @@ #!/bin/bash url='https://www.unicode.org/Public/11.0.0/ucd/' -files='Scripts.txt UnicodeData.txt LineBreak.txt SpecialCasing.txt CaseFolding.txt CompositionExclusions.txt IndicPositionalCategory.txt IndicSyllabicCategory.txt ArabicShaping.txt BidiBrackets.txt BidiMirroring.txt Blocks.txt extracted/DerivedEastAsianWidth.txt' +files='Scripts.txt UnicodeData.txt LineBreak.txt SpecialCasing.txt CaseFolding.txt CompositionExclusions.txt IndicPositionalCategory.txt IndicSyllabicCategory.txt ArabicShaping.txt BidiBrackets.txt BidiMirroring.txt Blocks.txt extracted/DerivedEastAsianWidth.txt extracted/DerivedBidiClass.txt' if test ! -d ucd/extracted; then mkdir -p ucd/extracted diff --git a/src/font/utils/gen-bidi-tables.py b/src/font/utils/gen-bidi-tables.py new file mode 100755 index 00000000..204c9581 --- /dev/null +++ b/src/font/utils/gen-bidi-tables.py @@ -0,0 +1,267 @@ +#!/usr/bin/env python + +# Wrotten by Vincent Wei for MiniGUI 3.4 +# Create on 2019-03-07 + +from __future__ import print_function, division, absolute_import + +import io, sys + +NR_UNICODE_CHARS = 0x10FFFF + 1 + +#if len (sys.argv) != 4: +# print ("usage: ./gen-bidi-tables.py", file=sys.stderr) +# sys.exit (1) + +filenames = ['ucd/extracted/DerivedBidiClass.txt', 'ucd/BidiBrackets.txt', 'ucd/BidiMirroring.txt'] + +files = [io.open (x, encoding='utf-8') for x in filenames] + +headers = [[f.readline () for i in range (2)] for f in files] +headers.insert (0, ["UnicodeData.txt does not have a header."]) + +# Read fileds[] in UnicodeData.txt to data + +data = [{} for f in files] +values = [{} for f in files] +for i, f in enumerate (files): + for line in f: + + j = line.find ('#') + if j >= 0: + line = line[:j] + + fields = [x.strip () for x in line.split (';')] + if len (fields) == 1: + continue + + uu = fields[0].split ('..') + start = int (uu[0], 16) + if len (uu) == 1: + end = start + else: + end = int (uu[1], 16) + + if i == 1: + t = fields[2] + else: + t = fields[1] + + for u in range (start, end + 1): + data[i][u] = t + values[i][t] = values[i].get (t, 0) + end - start + 1 + +# The unassigned code points that default to AL are in the ranges: +# [\u0600-\u07BF \u0860-\u086F \u08A0-\u08FF \uFB50-\uFDCF \uFDF0-\uFDFF \uFE70-\uFEFF +# \U00010D00-\U00010D3F \U00010F30-\U00010F6F \U0001EC70-\U0001ECBF \U0001EE00-\U0001EEFF] +# +# This includes code points in the Arabic, Syriac, and Thaana blocks, among others. +# +# The unassigned code points that default to R are in the ranges: +# [\u0590-\u05FF \u07C0-\u085F \u0870-\u089F \uFB1D-\uFB4F \U00010800-\U00010CFF \U00010D40-\U00010F2F +# \U00010F70-\U00010FFF \U0001E800-\U0001EC6F \U0001ECC0-\U0001EDFF \U0001EF00-\U0001EFFF] +# +# This includes code points in the Hebrew, NKo, and Phoenician blocks, among others. +# +# The unassigned code points that default to ET are in the range: +# [\u20A0-\u20CF] +# +# This consists of code points in the Currency Symbols block. +# +# The unassigned code points that default to BN have one of the following properties: +# Default_Ignorable_Code_Point +# Noncharacter_Code_Point +# +# For all other cases: +# All code points not explicitly listed for Bidi_Class +# have the value Left_To_Right (L). +# @missing: 0000..10FFFF; Left_To_Right + +# Initialize bidi_types list with the default Bidi class + +bidi_types = ["BIDI_TYPE_LTR" for i in range(NR_UNICODE_CHARS)] + +for i in range(0x0590, 0x0600): + bidi_types[i] = "BIDI_TYPE_RTL" + +for i in range(0x07C0, 0x0900): + bidi_types[i] = "BIDI_TYPE_RTL" + +for i in range(0xFB1D, 0xFB50): + bidi_types[i] = "BIDI_TYPE_RTL" + +for i in range(0x0600, 0x07C0): + bidi_types[i] = "BIDI_TYPE_AL" + +for i in range(0xFB50, 0xFDD0): + bidi_types[i] = "BIDI_TYPE_AL" + +for i in range(0xFDF0, 0xFE00): + bidi_types[i] = "BIDI_TYPE_AL" + +for i in range(0xFE70, 0xFF00): + bidi_types[i] = "BIDI_TYPE_AL" + +for i in range(0x2060, 0x2070): + bidi_types[i] = "BIDI_TYPE_BN" + +for i in range(0x20A0, 0x20D0): + bidi_types[i] = "BIDI_TYPE_ET" + +for i in range(0xFDD0, 0xFDF0): + bidi_types[i] = "BIDI_TYPE_BN" + +for i in range(0xFFF0, 0xFFF9): + bidi_types[i] = "BIDI_TYPE_BN" + +for i in range(0xFFFF, NR_UNICODE_CHARS, 0x10000): + bidi_types[i - 1] = bidi_types[i] = "BIDI_TYPE_BN" + +for i in range(0x10800, 0x10D00): + bidi_types[i] = "BIDI_TYPE_RTL" + +for i in range(0x10D40, 0x10F30): + bidi_types[i] = "BIDI_TYPE_RTL" + +for i in range(0x10F70, 0x11000): + bidi_types[i] = "BIDI_TYPE_RTL" + +for i in range(0x1E800, 0x1EC70): + bidi_types[i] = "BIDI_TYPE_RTL" + +for i in range(0x1ECC0, 0x1EE00): + bidi_types[i] = "BIDI_TYPE_RTL" + +for i in range(0x1EF00, 0x1F000): + bidi_types[i] = "BIDI_TYPE_RTL" + +for i in range(0xE0000, 0xE1000): + bidi_types[i] = "BIDI_TYPE_BN" + +# Fill bidi_types +d = data[0] +for u, v in d.items(): + v = v.strip() + if cmp(v, 'L') == 0: + bidi_types[u] = 'BIDI_TYPE_LTR' + elif cmp(v, 'R') == 0: + bidi_types[u] = 'BIDI_TYPE_RTL' + elif cmp(v, 'EN') == 0: + bidi_types[u] = 'BIDI_TYPE_EN' + elif cmp(v, 'ES') == 0: + bidi_types[u] = 'BIDI_TYPE_ES' + elif cmp(v, 'ET') == 0: + bidi_types[u] = 'BIDI_TYPE_ET' + elif cmp(v, 'AN') == 0: + bidi_types[u] = 'BIDI_TYPE_AN' + elif cmp(v, 'CS') == 0: + bidi_types[u] = 'BIDI_TYPE_CS' + elif cmp(v, 'B') == 0: + bidi_types[u] = 'BIDI_TYPE_BS' + elif cmp(v, 'S') == 0: + bidi_types[u] = 'BIDI_TYPE_SS' + elif cmp(v, 'WS') == 0: + bidi_types[u] = 'BIDI_TYPE_WS' + elif cmp(v, 'ON') == 0: + bidi_types[u] = 'BIDI_TYPE_ON' + elif cmp(v, 'BN') == 0: + bidi_types[u] = 'BIDI_TYPE_BN' + elif cmp(v, 'NSM') == 0: + bidi_types[u] = 'BIDI_TYPE_NSM' + elif cmp(v, 'AL') == 0: + bidi_types[u] = 'BIDI_TYPE_AL' + elif cmp(v, 'LRO') == 0: + bidi_types[u] = 'BIDI_TYPE_LRO' + elif cmp(v, 'RLO') == 0: + bidi_types[u] = 'BIDI_TYPE_RLO' + elif cmp(v, 'LRE') == 0: + bidi_types[u] = 'BIDI_TYPE_LRE' + elif cmp(v, 'RLE') == 0: + bidi_types[u] = 'BIDI_TYPE_RLE' + elif cmp(v, 'PDF') == 0: + bidi_types[u] = 'BIDI_TYPE_PDF' + elif cmp(v, 'LRI') == 0: + bidi_types[u] = 'BIDI_TYPE_LRI' + elif cmp(v, 'RLI') == 0: + bidi_types[u] = 'BIDI_TYPE_RLI' + elif cmp(v, 'FSI') == 0: + bidi_types[u] = 'BIDI_TYPE_FSI' + elif cmp(v, 'PDI') == 0: + bidi_types[u] = 'BIDI_TYPE_PDI' + else: + print ("Unknown BIDI type: %s" % v) + +print ("/* == Start of generated table == */") +print ("/*") +print (" * The following table is generated by running:") +print (" *") +print (" * ./gen-bidi-tables.py") +print (" *") +print (" * on ucd/extracted/DerivedBidiClass.txt, ucd/BidiBrackets.txt, and ucd/BidiMirroring.txt files with these headers:") +print (" *") +for h in headers: + for l in h: + print (" * %s" % (l.strip())) +print (" */") +print () + +print ("#ifndef _UNICODE_BIDI_TABLES_H") +print ("#define _UNICODE_BIDI_TABLES_H") +print ("") +print ("static const BIDICHAR_TYPE_MAP __mg_unicode_bidi_char_type_map[] =") +print ("{") + +cur_chv = 0 +cur_count = 1 +cur_type = bidi_types[0] +for i in range(1, NR_UNICODE_CHARS): + if bidi_types[i] is not cur_type: + if cur_count == 0: + cur_count = 1 + print (" { 0x%06X, 0x%04X, %s }," % (cur_chv, cur_count, cur_type, )) + cur_chv = i + cur_count = 1 + cur_type = bidi_types[i] + else: + cur_count += 1 + +print ("};") +print ("") +print ("static const BIDICHAR_BRACKET __mg_unicode_bracket_table[] =") +print ("{") + +d = data[1] +uu = sorted (d.keys()) +for u in uu: + v = d[u] + v = v.strip() + if cmp(v, 'o') == 0: + bracket_type = "BIDICHAR_BRACKET_OPEN" + elif cmp(v, 'c') == 0: + bracket_type = "BIDICHAR_BRACKET_CLOSE" + else: + bracket_type = "BIDICHAR_BRACKET_NONE" + + print (" { 0x%06X, %s }," % (u, bracket_type, )) + +print ("};") +print ("") + +print ("static const BIDICHAR_MIRROR_MAP __mg_unicode_mirror_table[] =") +print ("{") + +d = data[2] +uu = sorted (d.keys()) +for u in uu: + v = d[u] + mirrored = int (v, 16) + print (" { 0x%06X, 0x%06X }," % (u, mirrored, )) + +print ("};") + +print () +print ("#endif /* !_UNICODE_BIDI_TABLES_H */") + +print () +print ("/* == End of generated table == */") + diff --git a/src/include/bidi.h b/src/include/bidi.h index 71bca556..727537dd 100644 --- a/src/include/bidi.h +++ b/src/include/bidi.h @@ -59,11 +59,28 @@ extern "C" { #define DBGLOG4(s, t1, t2, t3) #endif +typedef struct _BIDICHAR_TYPE_MAP { + Uchar32 chv; // Starting code point of Unicode character + Uint16 count; // Total number of Unicode characters of same type starting from chv + Uint16 type; // Type of Unicode characters +} BIDICHAR_TYPE_MAP; + typedef struct _TYPERUN TYPERUN; +#define BIDICHAR_BRACKET_NONE 0 +#define BIDICHAR_BRACKET_OPEN 1 +#define BIDICHAR_BRACKET_CLOSE 2 + +// NOTE: It is enough to use Uint16 for Unicode bracket table +typedef struct _BIDICHAR_BRACKET { + Uint16 chv; + Uint8 type; +} BIDICHAR_BRACKET; + +// NOTE: It is enough to use Uint16 for Unicode mirror map typedef struct _BIDICHAR_MIRROR_MAP { - Achar32 chv; - Achar32 mirrored; + Uint16 chv; + Uint16 mirrored; } BIDICHAR_MIRROR_MAP; Achar32* __mg_charset_bidi_achars_reorder (const CHARSETOPS* charset_ops,