Grcov report - indic.rs

1

//! Implementation of font shaping for Indic scripts

2

3

use log::debug;

4

use unicode_general_category::GeneralCategory;

5

6

use crate::error::{ComplexScriptError, ParseError, ShapingError};

7

use crate::gsub::{self, Feature, FeatureMask, GlyphData, GlyphOrigin, RawGlyph, RawGlyphFlags};

8

use crate::layout::{FeatureTableSubstitution, GDEFTable, LangSys, LayoutCache, LayoutTable, GSUB};

9

use crate::scripts::syllable::*;

10

use crate::tinyvec::tiny_vec;

11

use crate::unicode::mcc::sort_by_modified_combining_class;

12

use crate::{tag, DOTTED_CIRCLE};

13

14

#[derive(Copy, Clone, Debug, PartialEq)]

15

enum Script {

16

    Devanagari,

17

    Bengali,

18

    Gurmukhi,

19

    Gujarati,

20

    Oriya,

21

    Tamil,

22

    Telugu,

23

    Kannada,

24

    Malayalam,

25

    Sinhala,

26

27

28

#[derive(Copy, Clone, Debug)]

29

enum BasePos {

30

    // First,

31

    Last,

32

    LastSinhala,

33

34

35

#[derive(Copy, Clone, Debug)]

36

enum RephMode {

37

    Explicit,

38

    Implicit,

39

    LogicalRepha,

40

    // VisualRepha,

41

42

43

#[derive(Copy, Clone, Debug, PartialEq)]

44

enum BlwfMode {

45

    PostOnly,

46

    PreAndPost,

47

48

49

impl Script {

50

    fn base_consonant_pos(self) -> BasePos {

51

        match self {

52

            Script::Devanagari => BasePos::Last,

53

            Script::Bengali => BasePos::Last,

54

            Script::Gurmukhi => BasePos::Last,

55

            Script::Gujarati => BasePos::Last,

56

            Script::Oriya => BasePos::Last,

57

            Script::Tamil => BasePos::Last,

58

            Script::Telugu => BasePos::Last,

59

            Script::Kannada => BasePos::Last,

60

            Script::Malayalam => BasePos::Last,

61

            Script::Sinhala => BasePos::LastSinhala,

62

63

64

65

    fn reph_position(self) -> Pos {

66

        match self {

67

            Script::Devanagari => Pos::BeforePost,

68

            Script::Bengali => Pos::AfterSubjoined,

69

            Script::Gurmukhi => Pos::BeforeSubjoined,

70

            Script::Gujarati => Pos::BeforePost,

71

            Script::Oriya => Pos::AfterMain,

72

            Script::Tamil => Pos::AfterPost,

73

            Script::Telugu => Pos::AfterPost,

74

            Script::Kannada => Pos::AfterPost,

75

            Script::Malayalam => Pos::AfterMain,

76

            Script::Sinhala => Pos::AfterMain,

77

78

79

80

    fn reph_mode(self) -> RephMode {

81

        match self {

82

            Script::Devanagari => RephMode::Implicit,

83

            Script::Bengali => RephMode::Implicit,

84

            Script::Gurmukhi => RephMode::Implicit,

85

            Script::Gujarati => RephMode::Implicit,

86

            Script::Oriya => RephMode::Implicit,

87

            Script::Tamil => RephMode::Implicit,

88

            Script::Telugu => RephMode::Explicit,

89

            Script::Kannada => RephMode::Implicit,

90

            Script::Malayalam => RephMode::LogicalRepha,

91

            Script::Sinhala => RephMode::Explicit,

92

93

94

95

    fn blwf_mode(self) -> BlwfMode {

96

        match self {

97

            Script::Devanagari => BlwfMode::PreAndPost,

98

            Script::Bengali => BlwfMode::PreAndPost,

99

            Script::Gurmukhi => BlwfMode::PreAndPost,

100

            Script::Gujarati => BlwfMode::PreAndPost,

101

            Script::Oriya => BlwfMode::PreAndPost,

102

            Script::Tamil => BlwfMode::PreAndPost,

103

            Script::Telugu => BlwfMode::PostOnly,

104

            Script::Kannada => BlwfMode::PostOnly,

105

            Script::Malayalam => BlwfMode::PreAndPost,

106

            Script::Sinhala => BlwfMode::PreAndPost,

107

108

109

110

    fn abovebase_matra_pos(self) -> Option<Pos> {

111

        match self {

112

            Script::Devanagari => Some(Pos::AfterSubjoined),

113

            Script::Bengali => None,

114

            Script::Gurmukhi => Some(Pos::AfterPost),

115

            Script::Gujarati => Some(Pos::AfterSubjoined),

116

            Script::Oriya => Some(Pos::AfterMain),

117

            Script::Tamil => Some(Pos::AfterSubjoined),

118

            Script::Telugu => Some(Pos::BeforeSubjoined),

119

            Script::Kannada => Some(Pos::BeforeSubjoined),

120

            Script::Malayalam => None,

121

            Script::Sinhala => Some(Pos::AfterSubjoined),

122

123

124

125

    fn rightside_matra_pos(self, ch: char) -> Option<Pos> {

126

        match self {

127

            Script::Devanagari => Some(Pos::AfterSubjoined),

128

            Script::Bengali => Some(Pos::AfterPost),

129

            Script::Gurmukhi => Some(Pos::AfterPost),

130

            Script::Gujarati => Some(Pos::AfterPost),

131

            Script::Oriya => Some(Pos::AfterPost),

132

            Script::Tamil => Some(Pos::AfterPost),

133

            Script::Telugu => match ch {

134

                '\u{0C41}' => Some(Pos::BeforeSubjoined),

135

                '\u{0C42}' => Some(Pos::BeforeSubjoined),

136

                '\u{0C43}' => Some(Pos::AfterSubjoined),

137

                '\u{0C44}' => Some(Pos::AfterSubjoined),

138

                _ => None,

139

},

140

            Script::Kannada => match ch {

141

                '\u{0CBE}' => Some(Pos::BeforeSubjoined),

142

                '\u{0CC0}' => Some(Pos::BeforeSubjoined),

143

                '\u{0CC1}' => Some(Pos::BeforeSubjoined),

144

                '\u{0CC2}' => Some(Pos::BeforeSubjoined),

145

                '\u{0CC3}' => Some(Pos::AfterSubjoined),

146

                '\u{0CC4}' => Some(Pos::AfterSubjoined),

147

                '\u{0CD5}' => Some(Pos::AfterSubjoined),

148

                '\u{0CD6}' => Some(Pos::AfterSubjoined),

149

                _ => None,

150

},

151

            Script::Malayalam => Some(Pos::AfterPost),

152

            Script::Sinhala => Some(Pos::AfterSubjoined),

153

154

155

156

    fn belowbase_matra_pos(self) -> Pos {

157

        match self {

158

            Script::Devanagari => Pos::AfterSubjoined,

159

            Script::Bengali => Pos::AfterSubjoined,

160

            Script::Gurmukhi => Pos::AfterPost,

161

            Script::Gujarati => Pos::AfterPost,

162

            Script::Oriya => Pos::AfterSubjoined,

163

            Script::Tamil => Pos::AfterPost,

164

            Script::Telugu => Pos::BeforeSubjoined,

165

            Script::Kannada => Pos::BeforeSubjoined,

166

            Script::Malayalam => Pos::AfterPost,

167

            Script::Sinhala => Pos::AfterSubjoined,

168

169

170

171

172

#[derive(Copy, Clone, Debug, PartialEq)]

173

enum ShapingModel {

174

    Indic1,

175

    Indic2,

176

177

178

#[derive(Copy, Clone, Debug, PartialEq)]

179

enum BasicFeature {

180

    Locl,

181

    Nukt,

182

    Akhn,

183

    Rphf,

184

    Rkrf,

185

    Pref,

186

    Blwf,

187

    Abvf,

188

    Half,

189

    Pstf,

190

    Vatu,

191

    Cjct,

192

    Cfar,

193

194

195

impl BasicFeature {

196

    const ALL: &'static [BasicFeature] = &[

197

        BasicFeature::Locl,

198

        BasicFeature::Nukt,

199

        BasicFeature::Akhn,

200

        BasicFeature::Rphf,

201

        BasicFeature::Rkrf,

202

        BasicFeature::Pref,

203

        BasicFeature::Blwf,

204

        BasicFeature::Abvf,

205

        BasicFeature::Half,

206

        BasicFeature::Pstf,

207

        BasicFeature::Vatu,

208

        BasicFeature::Cjct,

209

        BasicFeature::Cfar,

210

];

211

212

    fn tag(self) -> u32 {

213

        match self {

214

            BasicFeature::Locl => tag::LOCL,

215

            BasicFeature::Nukt => tag::NUKT,

216

            BasicFeature::Akhn => tag::AKHN,

217

            BasicFeature::Rphf => tag::RPHF,

218

            BasicFeature::Rkrf => tag::RKRF,

219

            BasicFeature::Pref => tag::PREF,

220

            BasicFeature::Blwf => tag::BLWF,

221

            BasicFeature::Abvf => tag::ABVF,

222

            BasicFeature::Half => tag::HALF,

223

            BasicFeature::Pstf => tag::PSTF,

224

            BasicFeature::Vatu => tag::VATU,

225

            BasicFeature::Cjct => tag::CJCT,

226

            BasicFeature::Cfar => tag::CFAR,

227

228

229

230

    fn feature(self) -> Feature {

231

        match self {

232

            BasicFeature::Locl => Feature::LOCL,

233

            BasicFeature::Nukt => Feature::NUKT,

234

            BasicFeature::Akhn => Feature::AKHN,

235

            BasicFeature::Rphf => Feature::RPHF,

236

            BasicFeature::Rkrf => Feature::RKRF,

237

            BasicFeature::Pref => Feature::PREF,

238

            BasicFeature::Blwf => Feature::BLWF,

239

            BasicFeature::Abvf => Feature::ABVF,

240

            BasicFeature::Half => Feature::HALF,

241

            BasicFeature::Pstf => Feature::PSTF,

242

            BasicFeature::Vatu => Feature::VATU,

243

            BasicFeature::Cjct => Feature::CJCT,

244

            BasicFeature::Cfar => Feature::CFAR,

245

246

247

248

    // Returns `true` if feature applies to the entire glyph buffer.

249

    fn is_global(self) -> bool {

250

        match self {

251

            BasicFeature::Locl => true,

252

            BasicFeature::Nukt => true,

253

            BasicFeature::Akhn => true,

254

            BasicFeature::Rphf => false,

255

            BasicFeature::Rkrf => true,

256

            BasicFeature::Pref => false,

257

            BasicFeature::Blwf => false,

258

            BasicFeature::Abvf => true,

259

            BasicFeature::Half => false,

260

            BasicFeature::Pstf => false,

261

            BasicFeature::Vatu => true,

262

            BasicFeature::Cjct => true,

263

            BasicFeature::Cfar => true,

264

265

266

267

268

#[derive(Copy, Clone, Debug, PartialEq)]

269

enum ShapingClass {

270

    Bindu,

271

    Visarga,

272

    Avagraha,

273

    Nukta,

274

    Virama,

275

    Cantillation,

276

    GeminationMark,

277

    PureKiller,

278

    SyllableModifier,

279

    Consonant,

280

    VowelIndependent,

281

    VowelDependent,

282

    ConsonantDead,

283

    ConsonantMedial,

284

    ConsonantPlaceholder,

285

    ConsonantWithStacker,

286

    ConsonantPreRepha,

287

    ModifyingLetter,

288

    Placeholder,

289

    Number,

290

    Symbol,

291

    Joiner,

292

    NonJoiner,

293

    DottedCircle,

294

295

296

#[derive(Copy, Clone, Debug)]

297

enum MarkPlacementSubclass {

298

    TopPosition,

299

    RightPosition,

300

    BottomPosition,

301

    LeftPosition,

302

    LeftAndRightPosition,

303

    TopAndRightPosition,

304

    TopAndLeftPosition,

305

    TopLeftAndRightPosition,

306

    TopAndBottomPosition,

307

    Overstruck,

308

309

310

#[derive(Copy, Clone, Debug, PartialEq, PartialOrd, Eq, Ord)]

311

enum Pos {

312

    RaToBecomeReph,

313

    PrebaseMatra,

314

    PrebaseConsonant,

315

    SyllableBase,

316

    AfterMain,

317

    _AbovebaseConsonant,

318

    BeforeSubjoined,

319

    BelowbaseConsonant,

320

    AfterSubjoined,

321

    BeforePost,

322

    PostbaseConsonant,

323

    AfterPost,

324

    _FinalConsonant,

325

    SMVD,

326

327

328

/////////////////////////////////////////////////////////////////////////////

329

// Syllable state machine

330

/////////////////////////////////////////////////////////////////////////////

331

332

#[derive(Copy, Clone, Debug)]

333

enum Syllable {

334

    Consonant,

335

    Vowel,

336

    Standalone,

337

    Symbol,

338

    Broken,

339

340

341

fn shaping_class(ch: char) -> Option<ShapingClass> {

342

    let (shaping, _) = indic_character(ch);

343

    shaping

344

345

346

fn consonant(ch: char) -> bool {

347

    match shaping_class(ch) {

348

        Some(ShapingClass::Consonant) => !ra(ch),

349

        Some(ShapingClass::ConsonantDead) => true,

350

        _ => false,

351

352

353

354

fn vowel(ch: char) -> bool {

355

    matches!(shaping_class(ch), Some(ShapingClass::VowelIndependent))

356

357

358

fn nukta(ch: char) -> bool {

359

    matches!(shaping_class(ch), Some(ShapingClass::Nukta))

360

361

362

fn halant(ch: char) -> bool {

363

    matches!(shaping_class(ch), Some(ShapingClass::Virama))

364

365

366

fn zwj(ch: char) -> bool {

367

    matches!(shaping_class(ch), Some(ShapingClass::Joiner))

368

369

370

fn zwnj(ch: char) -> bool {

371

    matches!(shaping_class(ch), Some(ShapingClass::NonJoiner))

372

373

374

fn joiner(ch: char) -> bool {

375

    zwj(ch) || zwnj(ch)

376

377

378

fn ra(ch: char) -> bool {

379

    match ch {

380

        '\u{0930}' => true, // Devanagari

381

        '\u{09B0}' => true, // Bengali

382

        '\u{09F0}' => true, // Bengali, Assamese

383

        '\u{0A30}' => true, // Gurmukhi

384

        '\u{0AB0}' => true, // Gujarati

385

        '\u{0B30}' => true, // Oriya

386

        '\u{0BB0}' => true, // Tamil

387

        '\u{0C30}' => true, // Telugu

388

        '\u{0CB0}' => true, // Kannada

389

        '\u{0D30}' => true, // Malayalam

390

        '\u{0DBB}' => true, // Sinhala

391

        _ => false,

392

393

394

395

fn matra(ch: char) -> bool {

396

    match shaping_class(ch) {

397

        Some(ShapingClass::VowelDependent) => true,

398

        Some(ShapingClass::PureKiller) => true,

399

        _ => false,

400

401

402

403

fn syllable_modifier(ch: char) -> bool {

404

    match shaping_class(ch) {

405

        Some(ShapingClass::SyllableModifier) => true,

406

        Some(ShapingClass::Bindu) => true,

407

        Some(ShapingClass::Visarga) => true,

408

        Some(ShapingClass::GeminationMark) => true,

409

        _ => false,

410

411

412

413

fn vedic_sign(ch: char) -> bool {

414

    matches!(shaping_class(ch), Some(ShapingClass::Cantillation))

415

416

417

fn placeholder(ch: char) -> bool {

418

    match shaping_class(ch) {

419

        Some(ShapingClass::Number) => true,

420

        Some(ShapingClass::Placeholder) => true,

421

        Some(ShapingClass::ConsonantPlaceholder) => true,

422

        _ => false,

423

424

425

426

fn dotted_circle(ch: char) -> bool {

427

    matches!(shaping_class(ch), Some(ShapingClass::DottedCircle))

428

429

430

fn repha(ch: char) -> bool {

431

    matches!(shaping_class(ch), Some(ShapingClass::ConsonantPreRepha))

432

433

434

fn consonant_medial(ch: char) -> bool {

435

    matches!(shaping_class(ch), Some(ShapingClass::ConsonantMedial))

436

437

438

fn symbol(ch: char) -> bool {

439

    match shaping_class(ch) {

440

        Some(ShapingClass::Symbol) => true,

441

        Some(ShapingClass::Avagraha) => true,

442

        _ => false,

443

444

445

446

fn consonant_with_stacker(ch: char) -> bool {

447

    matches!(shaping_class(ch), Some(ShapingClass::ConsonantWithStacker))

448

449

450

#[allow(dead_code)]

451

fn other(ch: char) -> bool {

452

    matches!(shaping_class(ch), Some(ShapingClass::ModifyingLetter))

453

454

455

fn match_c<T: SyllableChar>(cs: &[T]) -> Option<usize> {

456

    match_either(match_one(consonant), match_one(ra))(cs)

457

458

459

fn match_z<T: SyllableChar>(cs: &[T]) -> Option<usize> {

460

    match_one(joiner)(cs)

461

462

463

fn match_reph<T: SyllableChar>(cs: &[T]) -> Option<usize> {

464

    match_either(

465

        match_seq(match_one(ra), match_one(halant)),

466

        match_one(repha),

467

    )(cs)

468

469

470

fn match_cn<T: SyllableChar>(cs: &[T]) -> Option<usize> {

471

    match_seq(

472

        match_c,

473

        match_optional_seq(match_one(zwj), match_optional(match_one(nukta))),

474

    )(cs)

475

476

477

fn match_forced_rakar<T: SyllableChar>(cs: &[T]) -> Option<usize> {

478

    match_seq(

479

        match_one(zwj),

480

        match_seq(match_one(halant), match_seq(match_one(zwj), match_one(ra))),

481

    )(cs)

482

483

484

fn match_s<T: SyllableChar>(cs: &[T]) -> Option<usize> {

485

    match_seq(match_one(symbol), match_optional(match_one(nukta)))(cs)

486

487

488

fn match_matra_group<T: SyllableChar>(cs: &[T]) -> Option<usize> {

489

    match_repeat_upto(

490

3,

491

        match_z,

492

        match_seq(

493

            match_one(matra),

494

            match_optional_seq(

495

                match_one(nukta),

496

                match_optional(match_either(match_one(halant), match_forced_rakar)),

497

),

498

),

499

    )(cs)

500

501

502

fn match_syllable_tail<T: SyllableChar>(cs: &[T]) -> Option<usize> {

503

    match_optional_seq(

504

        match_optional_seq(

505

            match_z,

506

            match_seq(

507

                match_one(syllable_modifier),

508

                match_optional_seq(

509

                    match_one(syllable_modifier),

510

                    match_optional(match_one(zwnj)),

511

),

512

),

513

),

514

        match_repeat_upto(3, match_one(vedic_sign), match_unit()),

515

    )(cs)

516

517

518

fn match_halant_group<T: SyllableChar>(cs: &[T]) -> Option<usize> {

519

    match_optional_seq(

520

        match_z,

521

        match_seq(

522

            match_one(halant),

523

            match_optional(match_seq(match_one(zwj), match_optional(match_one(nukta)))),

524

),

525

    )(cs)

526

527

528

// This is not used as we expand it inline

529

/*

530

fn match_final_halant_group<T: SyllableChar>(cs: &[T]) -> Option<usize> {

531

    match_either(

532

        match_halant_group,

533

        match_seq(match_one(halant), match_one(zwnj)),

534

    )(cs)

535

536

*/

537

538

fn match_medial_group<T: SyllableChar>(cs: &[T]) -> Option<usize> {

539

    match_optional(match_one(consonant_medial))(cs)

540

541

542

fn match_halant_or_matra_group<T: SyllableChar>(cs: &[T]) -> Option<usize> {

543

    // this can match a short sequence so we expand and reorder it

544

    match_either(

545

        match_seq(match_one(halant), match_one(zwnj)),

546

        // Currently deviates from spec. See:

547

        // https://github.com/n8willis/opentype-shaping-documents/issues/72

548

        match_either(

549

            match_repeat_upto(4, match_matra_group, match_unit()),

550

            match_halant_group,

551

),

552

    )(cs)

553

554

555

fn match_consonant_syllable<T: SyllableChar>(cs: &[T]) -> Option<usize> {

556

    match_optional_seq(

557

        match_either(match_one(repha), match_one(consonant_with_stacker)),

558

        match_repeat_upto(

559

4,

560

            match_seq(match_cn, match_halant_group),

561

            match_seq(

562

                match_cn,

563

                match_seq(

564

                    match_medial_group,

565

                    match_seq(match_halant_or_matra_group, match_syllable_tail),

566

),

567

),

568

),

569

    )(cs)

570

571

572

fn match_vowel_syllable<T: SyllableChar>(cs: &[T]) -> Option<usize> {

573

    match_optional_seq(

574

        match_reph,

575

        match_seq(

576

            match_one(vowel),

577

            match_optional_seq(

578

                match_one(nukta),

579

                match_either(

580

                    match_one(zwj),

581

                    match_repeat_upto(

582

4,

583

                        match_seq(match_halant_group, match_cn),

584

                        match_seq(

585

                            match_medial_group,

586

                            match_seq(match_halant_or_matra_group, match_syllable_tail),

587

),

588

),

589

),

590

),

591

),

592

    )(cs)

593

594

595

fn match_standalone_syllable<T: SyllableChar>(cs: &[T]) -> Option<usize> {

596

    match_either_seq(

597

        match_optional_seq(

598

            match_either(match_one(repha), match_one(consonant_with_stacker)),

599

            match_one(placeholder),

600

),

601

        match_seq(match_optional(match_reph), match_one(dotted_circle)),

602

        match_optional_seq(

603

            match_one(nukta),

604

            match_repeat_upto(

605

4,

606

                match_seq(match_halant_group, match_cn),

607

                match_seq(

608

                    match_medial_group,

609

                    match_seq(match_halant_or_matra_group, match_syllable_tail),

610

),

611

),

612

),

613

    )(cs)

614

615

616

fn match_symbol_syllable<T: SyllableChar>(cs: &[T]) -> Option<usize> {

617

    match_seq(match_s, match_syllable_tail)(cs)

618

619

620

fn match_broken_syllable<T: SyllableChar>(cs: &[T]) -> Option<usize> {

621

    match_nonempty(match_optional_seq(

622

        match_reph,

623

        match_optional_seq(

624

            match_one(nukta),

625

            match_repeat_upto(

626

4,

627

                match_seq(match_halant_group, match_cn),

628

                match_seq(

629

                    match_medial_group,

630

                    match_seq(match_halant_or_matra_group, match_syllable_tail),

631

),

632

),

633

),

634

    ))(cs)

635

636

637

fn match_syllable<T: SyllableChar>(cs: &[T]) -> Option<(usize, Syllable)> {

638

    let consonant = (match_consonant_syllable(cs), Syllable::Consonant);

639

    let vowel = (match_vowel_syllable(cs), Syllable::Vowel);

640

    let standalone = (match_standalone_syllable(cs), Syllable::Standalone);

641

    let symbol = (match_symbol_syllable(cs), Syllable::Symbol);

642

    let broken = (match_broken_syllable(cs), Syllable::Broken);

643

644

    // To prevent incorrect splitting (and mis-categorisation) of a syllable,

645

    // greediest syllable match, wins. In the event of a tie, precedence is

646

    // consonant > vowel > standalone > symbol > broken

647

    let syllables = &mut [consonant, vowel, standalone, symbol, broken];

648

    syllables.sort_by(|(len1, _), (len2, _)| len2.cmp(len1));

649

650

    match syllables[0] {

651

        (Some(len), syllable_type) => Some((len, syllable_type)),

652

        (None, _) => None,

653

654

655

656

/////////////////////////////////////////////////////////////////////////////

657

// Preprocessing

658

/////////////////////////////////////////////////////////////////////////////

659

660

/// Preprocess Indic character sequences. This function should be called

661

/// prior to mapping Indic characters to their corresponding glyphs.

662

pub(super) fn preprocess_indic(cs: &mut Vec<char>, script_tag: u32) {

663

    let script = script(script_tag);

664

665

    constrain_vowel(cs);

666

    decompose_matra(cs);

667

    sort_by_modified_combining_class(cs);

668

    if script == Script::Bengali {

669

        recompose_bengali_ya_nukta(cs);

670

    } else if script == Script::Kannada {

671

        reorder_kannada_ra_halant_zwj(cs);

672

673

674

675

/// Denotes if/where a constraining character should be inserted.

676

enum InsertConstraint {

677

    /// Insert a constraining character between a pair of characters.

678

    Between,

679

    /// Insert a constraining character after a pair of characters if

680

    /// the `char` immediately after the pair equals the `char` contained

681

    /// in `MaybeAfter`.

682

    MaybeAfter(char),

683

    /// Do not insert a constraining character.

684

    None,

685

686

687

/// Prohibit vowel combinations that look like other vowels by inserting

688

/// a constraining character in between these combinations.

689

///

690

/// E.g. Bengali Letter A + Bengali Sign Aa looks like Bengali Letter Aa.

691

fn constrain_vowel(cs: &mut Vec<char>) {

692

    let mut i = 0;

693

    while i + 1 < cs.len() {

694

        i += match vowel_constraint(cs[i], cs[i + 1]) {

695

            InsertConstraint::Between => {

696

                cs.insert(i + 1, DOTTED_CIRCLE);

697

698

699

            InsertConstraint::MaybeAfter(c3) => {

700

                if i + 2 < cs.len() && cs[i + 2] == c3 {

701

                    cs.insert(i + 2, DOTTED_CIRCLE);

702

703

                } else {

704

705

706

707

            InsertConstraint::None => 1,

708

709

710

711

712

/// See the following link for the full list of prohibited vowel combinations:

713

///

714

/// <https://docs.microsoft.com/en-us/typography/script-development/use#independent-vowel-iv-plus-dependent-vowel-constraints-dv>

715

fn vowel_constraint(c1: char, c2: char) -> InsertConstraint {

716

    match (c1, c2) {

717

        // Devanagari

718

        ('\u{0905}', '\u{0946}') => InsertConstraint::Between,

719

        ('\u{0905}', '\u{093E}') => InsertConstraint::Between,

720

        ('\u{0909}', '\u{0941}') => InsertConstraint::Between,

721

        ('\u{090F}', '\u{0945}') => InsertConstraint::Between,

722

        ('\u{090F}', '\u{0946}') => InsertConstraint::Between,

723

        ('\u{090F}', '\u{0947}') => InsertConstraint::Between,

724

        ('\u{0905}', '\u{0949}') => InsertConstraint::Between,

725

        ('\u{0906}', '\u{0945}') => InsertConstraint::Between,

726

        ('\u{0905}', '\u{094A}') => InsertConstraint::Between,

727

        ('\u{0906}', '\u{0946}') => InsertConstraint::Between,

728

        ('\u{0905}', '\u{094B}') => InsertConstraint::Between,

729

        ('\u{0906}', '\u{0947}') => InsertConstraint::Between,

730

        ('\u{0905}', '\u{094C}') => InsertConstraint::Between,

731

        ('\u{0906}', '\u{0948}') => InsertConstraint::Between,

732

        ('\u{0905}', '\u{0945}') => InsertConstraint::Between,

733

        ('\u{0905}', '\u{093A}') => InsertConstraint::Between,

734

        ('\u{0905}', '\u{093B}') => InsertConstraint::Between,

735

        ('\u{0906}', '\u{093A}') => InsertConstraint::Between,

736

        ('\u{0905}', '\u{094F}') => InsertConstraint::Between,

737

        ('\u{0905}', '\u{0956}') => InsertConstraint::Between,

738

        ('\u{0905}', '\u{0957}') => InsertConstraint::Between,

739

        // Devanagari "Reph, Letter I"

740

        ('\u{0930}', '\u{094D}') => InsertConstraint::MaybeAfter('\u{0907}'),

741

        // Bengali

742

        ('\u{0985}', '\u{09BE}') => InsertConstraint::Between,

743

        ('\u{098B}', '\u{09C3}') => InsertConstraint::Between,

744

        ('\u{098C}', '\u{09E2}') => InsertConstraint::Between,

745

        // Gurmukhi

746

        ('\u{0A05}', '\u{0A3E}') => InsertConstraint::Between,

747

        ('\u{0A72}', '\u{0A3F}') => InsertConstraint::Between,

748

        ('\u{0A72}', '\u{0A40}') => InsertConstraint::Between,

749

        ('\u{0A73}', '\u{0A41}') => InsertConstraint::Between,

750

        ('\u{0A73}', '\u{0A42}') => InsertConstraint::Between,

751

        ('\u{0A72}', '\u{0A47}') => InsertConstraint::Between,

752

        ('\u{0A05}', '\u{0A48}') => InsertConstraint::Between,

753

        ('\u{0A73}', '\u{0A4B}') => InsertConstraint::Between,

754

        ('\u{0A05}', '\u{0A4C}') => InsertConstraint::Between,

755

        // Gujarati

756

        ('\u{0A85}', '\u{0ABE}') => InsertConstraint::Between,

757

        ('\u{0A85}', '\u{0AC5}') => InsertConstraint::Between,

758

        ('\u{0A85}', '\u{0AC7}') => InsertConstraint::Between,

759

        ('\u{0A85}', '\u{0AC8}') => InsertConstraint::Between,

760

        ('\u{0A85}', '\u{0AC9}') => InsertConstraint::Between,

761

        ('\u{0A85}', '\u{0ACB}') => InsertConstraint::Between,

762

        ('\u{0A85}', '\u{0ACC}') => InsertConstraint::Between,

763

        ('\u{0AC5}', '\u{0ABE}') => InsertConstraint::Between,

764

        // For the Gujarati triplets:

765

        //   * ('\u{0A85}', '\u{0ABE}', '\u{0AC5}')

766

        //   * ('\u{0A85}', '\u{0ABE}', '\u{0AC8}')

767

        // the constraining character is inserted between the

768

        // first two characters, and are therefore covered by

769

        // the ('\u{0A85}', '\u{0ABE}') arm

770

        // Oriya

771

        ('\u{0B05}', '\u{0B3E}') => InsertConstraint::Between,

772

        ('\u{0B0F}', '\u{0B57}') => InsertConstraint::Between,

773

        ('\u{0B13}', '\u{0B57}') => InsertConstraint::Between,

774

        // Telugu

775

        ('\u{0C12}', '\u{0C55}') => InsertConstraint::Between,

776

        ('\u{0C12}', '\u{0C4C}') => InsertConstraint::Between,

777

        ('\u{0C3F}', '\u{0C55}') => InsertConstraint::Between,

778

        ('\u{0C46}', '\u{0C55}') => InsertConstraint::Between,

779

        ('\u{0C4A}', '\u{0C55}') => InsertConstraint::Between,

780

        // Kannada

781

        ('\u{0C89}', '\u{0CBE}') => InsertConstraint::Between,

782

        ('\u{0C92}', '\u{0CCC}') => InsertConstraint::Between,

783

        ('\u{0C8B}', '\u{0CBE}') => InsertConstraint::Between,

784

        // Malayalam

785

        ('\u{0D07}', '\u{0D57}') => InsertConstraint::Between,

786

        ('\u{0D09}', '\u{0D57}') => InsertConstraint::Between,

787

        ('\u{0D0E}', '\u{0D46}') => InsertConstraint::Between,

788

        ('\u{0D12}', '\u{0D3E}') => InsertConstraint::Between,

789

        ('\u{0D12}', '\u{0D57}') => InsertConstraint::Between,

790

        // Sinhala

791

        ('\u{0D85}', '\u{0DCF}') => InsertConstraint::Between,

792

        ('\u{0D85}', '\u{0DD0}') => InsertConstraint::Between,

793

        ('\u{0D85}', '\u{0DD1}') => InsertConstraint::Between,

794

        ('\u{0D8B}', '\u{0DDF}') => InsertConstraint::Between,

795

        ('\u{0D8D}', '\u{0DD8}') => InsertConstraint::Between,

796

        ('\u{0D8F}', '\u{0DDF}') => InsertConstraint::Between,

797

        ('\u{0D91}', '\u{0DCA}') => InsertConstraint::Between,

798

        ('\u{0D91}', '\u{0DD9}') => InsertConstraint::Between,

799

        ('\u{0D91}', '\u{0DDA}') => InsertConstraint::Between,

800

        ('\u{0D91}', '\u{0DDC}') => InsertConstraint::Between,

801

        ('\u{0D91}', '\u{0DDD}') => InsertConstraint::Between,

802

        ('\u{0D94}', '\u{0DDF}') => InsertConstraint::Between,

803

        // Brahmi

804

        // Takri

805

        // Khudawadi

806

        // Tirhuta

807

        // Modi

808

        _ => InsertConstraint::None,

809

810

811

812

/// A multi-part matra's constituent parts.

813

enum MatraSplit {

814

    /// Not a multi-part matra.

815

    None,

816

    /// Two-part matra.

817

    Two(char, char),

818

    /// Three-part matra.

819

    Three(char, char, char),

820

821

822

/// Decompose two- or three-part matras, as certain parts may be placed

823

/// in different positions relative to the base.

824

///

825

/// E.g. Bengali "Ka, Sign O" decomposes into "Ka, Sign E, Sign Aa", then

826

/// gets reordered to "Sign E, Ka, Sign Aa".

827

fn decompose_matra(cs: &mut Vec<char>) {

828

    let mut i = 0;

829

    while i < cs.len() {

830

        i += match split_matra(cs[i]) {

831

            MatraSplit::None => 1,

832

            MatraSplit::Two(c1, c2) => {

833

                cs[i] = c1;

834

                cs.insert(i + 1, c2);

835

836

837

            MatraSplit::Three(c1, c2, c3) => {

838

                cs[i] = c1;

839

                cs.insert(i + 1, c2);

840

                cs.insert(i + 2, c3);

841

842

843

844

845

846

847

fn split_matra(ch: char) -> MatraSplit {

848

    match ch {

849

        // Devanagari

850

        // Bengali

851

        '\u{09CB}' => MatraSplit::Two('\u{09C7}', '\u{09BE}'),

852

        '\u{09CC}' => MatraSplit::Two('\u{09C7}', '\u{09D7}'),

853

        // Gurmukhi

854

        // Gujarati

855

        // Oriya

856

        '\u{0B48}' => MatraSplit::Two('\u{0B47}', '\u{0B56}'),

857

        '\u{0B4B}' => MatraSplit::Two('\u{0B47}', '\u{0B3E}'),

858

        '\u{0B4C}' => MatraSplit::Two('\u{0B47}', '\u{0B57}'),

859

        // Tamil

860

        '\u{0BCA}' => MatraSplit::Two('\u{0BC6}', '\u{0BBE}'),

861

        '\u{0BCB}' => MatraSplit::Two('\u{0BC7}', '\u{0BBE}'),

862

        '\u{0BCC}' => MatraSplit::Two('\u{0BC6}', '\u{0BD7}'),

863

        // Telugu

864

        '\u{0C48}' => MatraSplit::Two('\u{0C46}', '\u{0C56}'),

865

        // Kannada

866

        '\u{0CC0}' => MatraSplit::Two('\u{0CBF}', '\u{0CD5}'),

867

        '\u{0CC7}' => MatraSplit::Two('\u{0CC6}', '\u{0CD5}'),

868

        '\u{0CC8}' => MatraSplit::Two('\u{0CC6}', '\u{0CD6}'),

869

        '\u{0CCA}' => MatraSplit::Two('\u{0CC6}', '\u{0CC2}'),

870

        '\u{0CCB}' => MatraSplit::Three('\u{0CC6}', '\u{0CC2}', '\u{0CD5}'),

871

        // Malayalam

872

        '\u{0D4A}' => MatraSplit::Two('\u{0D46}', '\u{0D3E}'),

873

        '\u{0D4B}' => MatraSplit::Two('\u{0D47}', '\u{0D3E}'),

874

        '\u{0D4C}' => MatraSplit::Two('\u{0D46}', '\u{0D57}'),

875

        // Sinhala

876

        '\u{0DDA}' => MatraSplit::Two('\u{0DD9}', '\u{0DCA}'),

877

        '\u{0DDC}' => MatraSplit::Two('\u{0DD9}', '\u{0DCF}'),

878

        '\u{0DDD}' => MatraSplit::Three('\u{0DD9}', '\u{0DCF}', '\u{0DCA}'),

879

        '\u{0DDE}' => MatraSplit::Two('\u{0DD9}', '\u{0DDF}'),

880

        _ => MatraSplit::None,

881

882

883

884

/// Recompose Bengali "Ya, Nukta" sequences to "Yya".

885

///

886

/// HarfBuzz does this; we follow.

887

///

888

/// <https://github.com/n8willis/opentype-shaping-documents/issues/74>

889

fn recompose_bengali_ya_nukta(cs: &mut Vec<char>) {

890

    let mut i = 0;

891

    while i + 1 < cs.len() {

892

        if cs[i] == '\u{09AF}' && cs[i + 1] == '\u{09BC}' {

893

            cs[i] = '\u{09DF}';

894

            cs.remove(i + 1);

895

896

        i += 1;

897

898

899

900

/// For compatibility with legacy Kannada sequences, "Ra, Halant, ZWJ" must

901

/// behave like "Ra, ZWJ, Halant" such that if a consonant follows the "ZWJ"

902

/// (i.e. "Ra, Halant, ZWJ, Consonant"), it should take on a subjoined form.

903

///

904

/// <https://github.com/n8willis/opentype-shaping-documents/issues/61>

905

/// <https://github.com/harfbuzz/harfbuzz/issues/435>

906

fn reorder_kannada_ra_halant_zwj(cs: &mut [char]) {

907

    if cs.starts_with(&['\u{0CB0}', '\u{0CCD}', '\u{200D}']) {

908

        cs.swap(1, 2);

909

910

911

912

/////////////////////////////////////////////////////////////////////////////

913

// Shaping

914

/////////////////////////////////////////////////////////////////////////////

915

916

#[derive(Clone)]

917

struct IndicData {

918

    pos: Option<Pos>,

919

    mask: FeatureMask,

920

921

922

impl GlyphData for IndicData {

923

    /// Merge semantics for IndicData. The values that get used in the merged

924

    /// glyph are the values belonging to the glyph with the higher merge

925

    /// precedence.

926

///

927

    /// Merge precedence:

928

    ///   1. SyllableBase

929

    ///   2. PrebaseConsonant

930

    ///   3. PostbaseConsonant (in practice, there should never be a situation

931

    ///      where a PostbaseConsonant glyph is merged into a PrebaseConsonant glyph)

932

    ///   4. !None

933

    ///   5. None (shouldn't happen - all glyphs should be tagged by this point)

934

    fn merge(data1: IndicData, data2: IndicData) -> IndicData {

935

        match (data1.pos, data2.pos) {

936

            (Some(Pos::SyllableBase), _) => data1,

937

            (_, Some(Pos::SyllableBase)) => data2,

938

            (Some(Pos::PrebaseConsonant), _) => data1,

939

            (_, Some(Pos::PrebaseConsonant)) => data2,

940

            (Some(Pos::PostbaseConsonant), _) => data1,

941

            (_, Some(Pos::PostbaseConsonant)) => data2,

942

            (_, None) => data1,

943

            (None, _) => data2,

944

            _ => data1, // Default

945

946

947

948

949

type RawGlyphIndic = RawGlyph<IndicData>;

950

951

impl RawGlyphIndic {

952

    fn is(&self, pred: impl FnOnce(char) -> bool) -> bool {

953

        match self.glyph_origin {

954

            GlyphOrigin::Char(c) => pred(c),

955

            GlyphOrigin::Direct => false,

956

957

958

959

    fn has_pos(&self, pos: Pos) -> bool {

960

        match self.extra_data.pos {

961

            Some(p) => p == pos,

962

            None => false,

963

964

965

966

    fn set_pos(&mut self, pos: Option<Pos>) {

967

        self.extra_data.pos = pos

968

969

970

    fn replace_none_pos(&mut self, pos: Option<Pos>) {

971

        assert_eq!(self.extra_data.pos, None);

972

        self.set_pos(pos)

973

974

975

    fn pos(&self) -> Option<Pos> {

976

        self.extra_data.pos

977

978

979

    fn has_mask(&self, mask: FeatureMask) -> bool {

980

        self.extra_data.mask.contains(mask)

981

982

983

    fn add_mask(&mut self, mask: FeatureMask) {

984

        self.extra_data.mask.insert(mask)

985

986

987

    fn remove_mask(&mut self, mask: FeatureMask) {

988

        self.extra_data.mask.remove(mask)

989

990

991

992

struct IndicShapingData<'tables> {

993

    gsub_cache: &'tables LayoutCache<GSUB>,

994

    gsub_table: &'tables LayoutTable<GSUB>,

995

    gdef_table: Option<&'tables GDEFTable>,

996

    langsys: &'tables LangSys,

997

    script_tag: u32,

998

    lang_tag: Option<u32>,

999

    script: Script,

1000

    shaping_model: ShapingModel,

1001

    feature_variations: Option<&'tables FeatureTableSubstitution<'tables>>,

1002

1003

1004

impl IndicShapingData<'_> {

1005

    fn feature_would_apply(

1006

        &self,

1007

        feature_tag: u32,

1008

        glyphs: &[RawGlyphIndic],

1009

        start_index: usize,

1010

    ) -> Result<bool, ParseError> {

1011

        gsub::gsub_feature_would_apply(

1012

            self.gsub_cache,

1013

            self.gsub_table,

1014

            self.gdef_table,

1015

            self.langsys,

1016

            self.feature_variations,

1017

            feature_tag,

1018

            glyphs,

1019

            start_index,

1020

1021

1022

1023

    fn get_lookups_cache_index(&self, mask: FeatureMask) -> Result<usize, ParseError> {

1024

        gsub::get_lookups_cache_index(

1025

            self.gsub_cache,

1026

            self.script_tag,

1027

            self.lang_tag,

1028

            self.feature_variations,

1029

            mask,

1030

1031

1032

1033

    fn apply_lookup(

1034

        &self,

1035

        lookup_index: usize,

1036

        feature_tag: u32,

1037

        glyphs: &mut Vec<RawGlyphIndic>,

1038

        max_glyphs: usize,

1039

        pred: impl Fn(&RawGlyphIndic) -> bool,

1040

    ) -> Result<(), ParseError> {

1041

        gsub::gsub_apply_lookup(

1042

            self.gsub_cache,

1043

            self.gsub_table,

1044

            self.gdef_table,

1045

            lookup_index,

1046

            feature_tag,

1047

            None,

1048

            glyphs,

1049

            max_glyphs,

1050

0,

1051

            glyphs.len(),

1052

            pred,

1053

)?;

1054

        Ok(())

1055

1056

1057

1058

/// Does the following:

1059

///   * Splits syllables

1060

///   * Inserts dotted circles into broken syllables

1061

///   * Initial reordering

1062

///   * Applies basic features

1063

///   * Final reordering

1064

///   * Applies presentation features

1065

pub fn gsub_apply_indic<'a>(

1066

    dotted_circle_index: u16,

1067

    gsub_cache: &'a LayoutCache<GSUB>,

1068

    gsub_table: &'a LayoutTable<GSUB>,

1069

    gdef_table: Option<&'a GDEFTable>,

1070

    indic1_tag: u32,

1071

    lang_tag: Option<u32>,

1072

    feature_variations: Option<&'a FeatureTableSubstitution<'a>>,

1073

    extra_features: FeatureMask,

1074

    glyphs: &mut Vec<RawGlyph<()>>,

1075

) -> Result<(), ShapingError> {

1076

    if glyphs.is_empty() {

1077

        return Err(ComplexScriptError::EmptyBuffer.into());

1078

1079

1080

    // Currently, the script tag that gets passed from Mercury is the Indic1 tag.

1081

    // Map this to the Indic2 tag, as we want to check if a font supports it

1082

    let indic2_tag = indic2_tag(indic1_tag);

1083

1084

    // Priority: Indic2 > Indic1 > Default

1085

    let (script_tag, shaping_model, script_table) = match gsub_table.find_script(indic2_tag)? {

1086

        Some(script_table) => (indic2_tag, ShapingModel::Indic2, script_table),

1087

        None => match gsub_table.find_script_or_default(indic1_tag)? {

1088

            Some(script_table) => (indic1_tag, ShapingModel::Indic1, script_table),

1089

            None => return Ok(()),

1090

},

1091

};

1092

1093

    let langsys = match script_table.find_langsys_or_default(lang_tag)? {

1094

        Some(langsys) => langsys,

1095

        None => return Ok(()),

1096

};

1097

1098

    let mut syllables = to_indic_syllables(glyphs);

1099

    let script = script(indic1_tag);

1100

    let shaping_data = IndicShapingData {

1101

        gsub_cache,

1102

        gsub_table,

1103

        gdef_table,

1104

        langsys,

1105

        script_tag,

1106

        lang_tag,

1107

        script,

1108

        shaping_model,

1109

        feature_variations,

1110

};

1111

1112

    for i in 0..syllables.len() {

1113

        // For application of INIT. If a left matra is not word-initial,

1114

        // HarfBuzz applies INIT iff the preceding character falls outside

1115

        // a range of GeneralCategory classes. We follow suit.

1116

        let is_first_syllable = if i == 0 {

1117

            true

1118

        } else if let Some(prev_glyph) = syllables[i - 1].0.iter().last() {

1119

            match prev_glyph.glyph_origin {

1120

                GlyphOrigin::Char(c) => {

1121

                    let gc = unicode_general_category::get_general_category(c);

1122

                    !(gc == GeneralCategory::Format

1123

                        || gc == GeneralCategory::Unassigned

1124

                        || gc == GeneralCategory::PrivateUse

1125

                        || gc == GeneralCategory::Surrogate

1126

                        || gc == GeneralCategory::LowercaseLetter

1127

                        || gc == GeneralCategory::ModifierLetter

1128

                        || gc == GeneralCategory::OtherLetter

1129

                        || gc == GeneralCategory::TitlecaseLetter

1130

                        || gc == GeneralCategory::UppercaseLetter

1131

                        || gc == GeneralCategory::SpacingMark

1132

                        || gc == GeneralCategory::EnclosingMark

1133

                        || gc == GeneralCategory::NonspacingMark)

1134

1135

                GlyphOrigin::Direct => false,

1136

1137

        } else {

1138

            true

1139

};

1140

1141

        let (syllable, syllable_type) = &mut syllables[i];

1142

        if let Err(err) = shape_syllable(

1143

            dotted_circle_index,

1144

            &shaping_data,

1145

            syllable,

1146

            syllable_type,

1147

            is_first_syllable,

1148

            extra_features,

1149

) {

1150

            debug!("gsub apply indic: {}", err);

1151

1152

1153

1154

    *glyphs = syllables

1155

        .into_iter()

1156

        .flat_map(|(s, _)| s.into_iter())

1157

        .map(from_raw_glyph_indic)

1158

        .collect();

1159

1160

    Ok(())

1161

1162

1163

fn shape_syllable(

1164

    dotted_circle_index: u16,

1165

    shaping_data: &IndicShapingData<'_>,

1166

    syllable: &mut Vec<RawGlyphIndic>,

1167

    syllable_type: &Option<Syllable>,

1168

    is_first_syllable: bool,

1169

    extra_features: FeatureMask,

1170

) -> Result<(), ShapingError> {

1171

    let max_glyphs = syllable.len().saturating_mul(gsub::MAX_GLYPHS_FACTOR);

1172

1173

    // Add a dotted circle to broken syllables so they can be treated

1174

    // like standalone syllables

1175

    // https://github.com/n8willis/opentype-shaping-documents/issues/45

1176

    if let Some(Syllable::Broken) = syllable_type {

1177

        insert_dotted_circle(dotted_circle_index, shaping_data.script, syllable)?;

1178

1179

1180

    match syllable_type {

1181

        // HarfBuzz treats vowel and standalone syllables like consonant

1182

        // syllables. We follow suit

1183

        // https://github.com/n8willis/opentype-shaping-documents/issues/45

1184

        Some(Syllable::Consonant)

1185

        | Some(Syllable::Vowel)

1186

        | Some(Syllable::Standalone)

1187

        | Some(Syllable::Broken) => {

1188

            initial_reorder_consonant_syllable(shaping_data, syllable)?;

1189

            apply_basic_features(shaping_data, syllable, max_glyphs)?;

1190

            final_reorder_consonant_syllable(shaping_data, syllable);

1191

            apply_presentation_features(

1192

                shaping_data,

1193

                is_first_syllable,

1194

                extra_features,

1195

                syllable,

1196

                max_glyphs,

1197

)?;

1198

1199

        Some(Syllable::Symbol) | None => {}

1200

1201

1202

    Ok(())

1203

1204

1205

// https://github.com/n8willis/opentype-shaping-documents/issues/45

1206

fn insert_dotted_circle(

1207

    dotted_circle_index: u16,

1208

    script: Script,

1209

    glyphs: &mut Vec<RawGlyphIndic>,

1210

) -> Result<(), ComplexScriptError> {

1211

    if dotted_circle_index == 0 {

1212

        return Err(ComplexScriptError::MissingDottedCircle);

1213

1214

1215

    let dotted_circle = RawGlyphIndic {

1216

        unicodes: tiny_vec![[char; 1] => DOTTED_CIRCLE],

1217

        glyph_index: dotted_circle_index,

1218

        liga_component_pos: 0,

1219

        glyph_origin: GlyphOrigin::Char(DOTTED_CIRCLE),

1220

        flags: RawGlyphFlags::empty(),

1221

        variation: None,

1222

        extra_data: IndicData {

1223

            pos: None,

1224

            mask: FeatureMask::empty(),

1225

},

1226

};

1227

1228

    let mut pos = 0;

1229

    if let (Script::Malayalam, Some(glyph)) = (script, glyphs.first()) {

1230

        // Insert dotted circle after possible "Repha"

1231

        if glyph.is(repha) {

1232

            pos = 1;

1233

1234

1235

    glyphs.insert(pos, dotted_circle);

1236

1237

    Ok(())

1238

1239

1240

/// Maps an Indic1 script tag to its corresponding `Script` variant.

1241

fn script(indic1_tag: u32) -> Script {

1242

    match indic1_tag {

1243

        tag::DEVA => Script::Devanagari,

1244

        tag::BENG => Script::Bengali,

1245

        tag::GURU => Script::Gurmukhi,

1246

        tag::GUJR => Script::Gujarati,

1247

        tag::ORYA => Script::Oriya,

1248

        tag::TAML => Script::Tamil,

1249

        tag::TELU => Script::Telugu,

1250

        tag::KNDA => Script::Kannada,

1251

        tag::MLYM => Script::Malayalam,

1252

        tag::SINH => Script::Sinhala,

1253

        _ => panic!("Expected an Indic1 script tag"),

1254

1255

1256

1257

/// Maps an Indic1 script tag to its corresponding Indic2 script tag.

1258

pub fn indic2_tag(indic1_tag: u32) -> u32 {

1259

    match indic1_tag {

1260

        tag::DEVA => tag::DEV2,

1261

        tag::BENG => tag::BNG2,

1262

        tag::GURU => tag::GUR2,

1263

        tag::GUJR => tag::GJR2,

1264

        tag::ORYA => tag::ORY2,

1265

        tag::TAML => tag::TML2,

1266

        tag::TELU => tag::TEL2,

1267

        tag::KNDA => tag::KND2,

1268

        tag::MLYM => tag::MLM2,

1269

        tag::SINH => tag::SINH, // For simplicity, just return the Indic1 Sinhala tag

1270

        _ => panic!("Expected an Indic1 script tag"),

1271

1272

1273

1274

/// Splits the input glyph buffer and collects it into a vector of Indic syllables.

1275

fn to_indic_syllables(mut glyphs: &[RawGlyph<()>]) -> Vec<(Vec<RawGlyphIndic>, Option<Syllable>)> {

1276

    let mut syllables: Vec<(Vec<RawGlyphIndic>, Option<Syllable>)> = Vec::new();

1277

1278

    while !glyphs.is_empty() {

1279

        let len = match match_syllable(glyphs) {

1280

            Some((len, syllable_type)) => {

1281

                assert_ne!(len, 0);

1282

1283

                let syllable = glyphs[..len].iter().map(to_raw_glyph_indic).collect();

1284

                syllables.push((syllable, Some(syllable_type)));

1285

1286

len

1287

1288

            None => {

1289

                let invalid_glyph = to_raw_glyph_indic(&glyphs[0]);

1290

                match syllables.last_mut() {

1291

                    // If the last syllable in `syllables` is invalid, just append

1292

                    // this invalid glyph to that syllable

1293

                    Some((invalid_syllable, None)) => invalid_syllable.push(invalid_glyph),

1294

                    // Collect invalid glyphs

1295

                    _ => syllables.push((vec![invalid_glyph], None)),

1296

1297

1298

1299

1300

};

1301

1302

        glyphs = &glyphs[len..];

1303

1304

1305

    syllables

1306

1307

1308

/////////////////////////////////////////////////////////////////////////////

1309

// Initial reordering

1310

/////////////////////////////////////////////////////////////////////////////

1311

1312

fn initial_reorder_consonant_syllable(

1313

    shaping_data: &IndicShapingData<'_>,

1314

    glyphs: &mut [RawGlyphIndic],

1315

) -> Result<(), ShapingError> {

1316

    // 2.1 Base consonant

1317

    if let Some(base_index) = tag_consonants(shaping_data, glyphs)? {

1318

        initial_reorder_consonant_syllable_with_base(shaping_data, base_index, glyphs)

1319

    } else {

1320

        initial_reorder_consonant_syllable_without_base(glyphs)

1321

1322

1323

1324

fn initial_reorder_consonant_syllable_with_base(

1325

    shaping_data: &IndicShapingData<'_>,

1326

    base_index: usize,

1327

    glyphs: &mut [RawGlyphIndic],

1328

) -> Result<(), ShapingError> {

1329

    // 2.2 Matra decomposition

1330

    // IMPLEMENTATION: Handled in the text preprocessing stage.

1331

1332

    // 2.3 Tag decomposed matras

1333

    let glyphs_without_pos = glyphs.iter_mut().filter(|g| g.pos().is_none());

1334

    for glyph in glyphs_without_pos {

1335

        if let GlyphOrigin::Char(c) = glyph.glyph_origin {

1336

            let pos = matra_pos(c, shaping_data.script);

1337

            glyph.replace_none_pos(pos);

1338

1339

1340

1341

    // 2.4 Adjacent marks

1342

    // IMPLEMENTATION: Handled in the text preprocessing stage.

1343

1344

    // 2.5 Pre-base consonants

1345

    // 2.6 Reph

1346

    // 2.7 Post-base consonants

1347

    // IMPLEMENTATION: Handled in 2.1

1348

1349

    // 2.8 Mark tagging

1350

    fn smvd_mark(c: char) -> bool {

1351

        match shaping_class(c) {

1352

            Some(ShapingClass::Bindu)

1353

            | Some(ShapingClass::Visarga)

1354

            | Some(ShapingClass::Avagraha)

1355

            | Some(ShapingClass::Cantillation)

1356

            | Some(ShapingClass::SyllableModifier)

1357

            | Some(ShapingClass::GeminationMark)

1358

            | Some(ShapingClass::Symbol) => true,

1359

            _ => false,

1360

1361

1362

1363

    fn remaining_mark(c: char) -> bool {

1364

        match shaping_class(c) {

1365

            Some(ShapingClass::Nukta)

1366

            | Some(ShapingClass::Virama)

1367

            | Some(ShapingClass::PureKiller)

1368

            | Some(ShapingClass::Joiner)

1369

            | Some(ShapingClass::NonJoiner) => true,

1370

            _ => false,

1371

1372

1373

1374

    // 2.8.1 Marks in the BINDU, VISARGA, AVAGRAHA, CANTILLATION, SYLLABLE_MODIFIER,

1375

    // GEMINATION_MARK, and SYMBOL categories should be tagged with POS_SMVD.

1376

    let glyphs_smvd = glyphs.iter_mut().filter(|g| g.is(smvd_mark));

1377

    for glyph in glyphs_smvd {

1378

        let pos = match glyph.glyph_origin {

1379

            // Oriya's "Candrabindu" must be tagged with POS_BEFORE_SUBJOINED

1380

            GlyphOrigin::Char('\u{0B01}') => Pos::BeforeSubjoined,

1381

            _ => Pos::SMVD,

1382

};

1383

        glyph.replace_none_pos(Some(pos));

1384

1385

1386

    // 2.8.2 All remaining marks must be tagged with the same positioning tag as the

1387

    // closest non-mark character the mark has affinity with, so that they move

1388

    // together during the sorting step.

1389

//

1390

    // NOTE: In this step, joiner and non-joiner characters must also be tagged

1391

    // according to the same rules given for marks, even though these characters

1392

    // are not categorized as marks in Unicode.

1393

    let mut prev_pos = None;

1394

    for i in 0..glyphs.len() {

1395

        if glyphs[i].is(remaining_mark) && prev_pos.is_some() {

1396

            // HarfBuzz and Uniscribe do not move a "Halant" if it follows

1397

            // a pre-base matra

1398

//

1399

            // https://github.com/n8willis/opentype-shaping-documents/issues/63

1400

            if glyphs[i].is(halant) && prev_pos == Some(Pos::PrebaseMatra) {

1401

                let first_non_matra_pos = glyphs[..i]

1402

                    .iter()

1403

                    .rev()

1404

                    .filter_map(RawGlyphIndic::pos)

1405

                    .find(|pos| *pos != Pos::PrebaseMatra);

1406

1407

                if first_non_matra_pos.is_some() {

1408

                    glyphs[i].replace_none_pos(first_non_matra_pos);

1409

1410

            } else {

1411

                glyphs[i].replace_none_pos(prev_pos);

1412

1413

        } else if !glyphs[i].is(smvd_mark) {

1414

            assert_ne!(glyphs[i].pos(), None);

1415

            prev_pos = glyphs[i].pos();

1416

1417

1418

1419

    // 2.8.3 For all marks preceding the base consonant, the mark must be tagged

1420

    // with the same positioning tag as the closest preceding non-mark consonant.

1421

//

1422

    // IMPLEMENTATION: Already tagged in 2.8.2

1423

1424

    // 2.8.4 For all marks occurring after the base consonant, the mark must be tagged

1425

    // with the same positioning tag as the closest subsequent consonant.

1426

//

1427

    // NOTE: In this step, joiner and non-joiner characters must also be tagged

1428

    // according to the same rules given for marks, even though these characters

1429

    // are not categorized as marks in Unicode.

1430

    let mut next_pos = None;

1431

    for glyph in glyphs[(base_index + 1)..].iter_mut().rev() {

1432

        if glyph.is(remaining_mark) && next_pos.is_some() {

1433

            // No assertion, as some marks may have already been tagged

1434

            // in 2.8.2. Overwrite instead

1435

            glyph.set_pos(next_pos);

1436

        } else if glyph.is(effectively_consonant) {

1437

            assert_ne!(glyph.pos(), None); // Consonant should be tagged by now

1438

            next_pos = glyph.pos();

1439

1440

1441

1442

    // Check that no glyphs have been left untagged, then reorder glyphs

1443

    // to canonical order

1444

    if glyphs.iter().any(|g| g.pos().is_none()) {

1445

        return Err(ComplexScriptError::MissingTags.into());

1446

    } else {

1447

        glyphs.sort_by_key(|g| g.pos());

1448

1449

1450

    // Get base consonant position again, after reorder

1451

    let base_index = glyphs

1452

        .iter()

1453

        .position(|g| g.has_pos(Pos::SyllableBase))

1454

        .ok_or_else::<ShapingError, _>(|| ComplexScriptError::MissingBaseConsonant.into())?;

1455

1456

    // Handle Indic1 script tags. Move the first post-base "Halant" after the last

1457

    // post-base consonant

1458

    if shaping_data.shaping_model == ShapingModel::Indic1 {

1459

        let glyphs_post_base = &mut glyphs[(base_index + 1)..];

1460

        let first_halant = glyphs_post_base.iter().position(|g| g.is(halant));

1461

        let last_consonant = glyphs_post_base

1462

            .iter()

1463

            .rposition(|g| g.is(effectively_consonant));

1464

1465

        if let (Some(first_halant), Some(last_consonant)) = (first_halant, last_consonant) {

1466

            // The comments in HarfBuzz state that for _some_ scripts, Uniscribe

1467

            // does not move the "Halant" if a "Halant" already follows the last

1468

            // post-base consonant. Kannada is one such script

1469

//

1470

            // https://github.com/n8willis/opentype-shaping-documents/issues/64

1471

            if shaping_data.script == Script::Kannada {

1472

                let has_halant_after_last_consonant = glyphs_post_base[(last_consonant + 1)..]

1473

                    .iter()

1474

                    .rev()

1475

                    .any(|g| g.is(halant));

1476

1477

                if !has_halant_after_last_consonant {

1478

                    move_element(glyphs_post_base, first_halant, last_consonant);

1479

1480

            } else {

1481

                move_element(glyphs_post_base, first_halant, last_consonant);

1482

1483

1484

1485

1486

    // Set the appropriate feature masks

1487

    for glyph in glyphs.iter_mut() {

1488

        let mask: FeatureMask = match glyph.pos() {

1489

            Some(Pos::RaToBecomeReph) => BasicFeature::Rphf.feature().mask(),

1490

            Some(Pos::PrebaseConsonant) => {

1491

                if shaping_data.shaping_model != ShapingModel::Indic1

1492

                    && shaping_data.script.blwf_mode() == BlwfMode::PreAndPost

1493

1494

                    BasicFeature::Half.feature() | BasicFeature::Blwf.feature()

1495

                } else {

1496

                    BasicFeature::Half.feature().mask()

1497

1498

1499

            Some(Pos::BelowbaseConsonant) => BasicFeature::Blwf.feature().mask(),

1500

            Some(Pos::PostbaseConsonant) => BasicFeature::Pstf.feature().mask(),

1501

            _ => FeatureMask::empty(),

1502

};

1503

1504

        glyph.add_mask(mask);

1505

1506

1507

    // Remove BLWF mask from pre-base sequences that end with "Halant, ZWJ"

1508

    // There is reason to believe that Uniscribe does this.

1509

//

1510

    // Example, using Noto Sans/Serif Bengali:

1511

    //   [Ka, Halant, Ba, Halant, Ba, Halant, Ka (Base)]

1512

    //     * [Ka, Halant] takes on half form

1513

    //     * [Ba, Halant]s take on subjoined form

1514

    //   [Ka, Halant, Ba, Halant, Ba, Halant, ZWJ, Ka (Base)]

1515

    //     * [Ka, Halant] takes on half form

1516

    //     * [Ba, Halant]s take on half form in Uniscribe

1517

    let last_explicit_half_form_index = glyphs[..base_index]

1518

        .windows(2)

1519

        .rposition(|gs| gs[0].is(halant) && gs[1].is(zwj))

1520

        .map(|i| i + 1); // ZWJ index

1521

1522

    if let Some(last_explicit_half_form_index) = last_explicit_half_form_index {

1523

        glyphs[..=last_explicit_half_form_index]

1524

            .iter_mut()

1525

            .for_each(|g| g.remove_mask(BasicFeature::Blwf.feature().mask()));

1526

1527

1528

    // ...except non-initial, pre-base "Ra, Halant" sequences in Devanagari

1529

    // This is to allow the application of the VATU feature

1530

//

1531

    // https://github.com/n8willis/opentype-shaping-documents/issues/65

1532

    if shaping_data.shaping_model == ShapingModel::Indic1

1533

        && shaping_data.script == Script::Devanagari

1534

1535

        // Collect all pre-base "Ra" indices

1536

//

1537

        // IMPLEMENTATION: Includes possible "Reph", but because

1538

        // RPHF is applied before BLWF, it shouldn't matter

1539

        let mut ra_indices = Vec::new();

1540

        let mut iter = glyphs[..(base_index + 1)].windows(3).enumerate();

1541

        while let Some((i, [g0, g1, g2])) = iter.next() {

1542

            if g0.is(ra) && g1.is(halant) && !g2.is(zwj) {

1543

                ra_indices.push(i)

1544

1545

1546

1547

        let mask: FeatureMask = BasicFeature::Blwf.feature().mask();

1548

        for i in ra_indices {

1549

            glyphs[i].add_mask(mask);

1550

            glyphs[i + 1].add_mask(mask);

1551

1552

1553

1554

    // Add PREF mask to pre-base-reordering "Ra" sequences in Malayalam/Telugu

1555

    if shaping_data.script == Script::Malayalam || shaping_data.script == Script::Telugu {

1556

        let glyphs_post_base = &mut glyphs[(base_index + 1)..];

1557

1558

        // Find the first occurrence of pre-base-reordering "Ra".

1559

        // Only one can exist per syllable

1560

        let prebase_reordering_ra_index = match shaping_data.shaping_model {

1561

            ShapingModel::Indic1 => glyphs_post_base

1562

                .windows(2)

1563

                .position(|gs| gs[0].is(ra) && gs[1].is(halant)),

1564

            ShapingModel::Indic2 => glyphs_post_base

1565

                .windows(2)

1566

                .position(|gs| gs[0].is(halant) && gs[1].is(ra)),

1567

};

1568

1569

        if let Some(prebase_reordering_ra_index) = prebase_reordering_ra_index {

1570

            if shaping_data.feature_would_apply(

1571

                BasicFeature::Pref.tag(),

1572

                glyphs_post_base,

1573

                prebase_reordering_ra_index,

1574

            )? {

1575

                let mask: FeatureMask = BasicFeature::Pref.feature().mask();

1576

                glyphs_post_base[prebase_reordering_ra_index].add_mask(mask);

1577

                glyphs_post_base[prebase_reordering_ra_index + 1].add_mask(mask);

1578

1579

1580

1581

1582

    Ok(())

1583

1584

1585

/// Handle consonant glyphs that lack a base consonant. Mimics Uniscribe's

1586

/// behaviour.

1587

///

1588

/// Some examples to illustrate how Uniscribe's behaviour differs from HarfBuzz's:

1589

///

1590

/// ```text

1591

///            Font: Noto Sans Bengali

1592

///                  (or any Indic2 font with a Reph, subjoined, and half forms).

1593

///

1594

///

1595

/// Test sequence 1: [Ka, Halant, Ba, Halant, ZWJ]

1596

///

1597

///        HarfBuzz: [Ka, Halant, Ba+Halant (BLWF), ZWJ]

1598

///                  HB terminates the base consonant search on [Halant, ZWJ]. No

1599

///                  base is found, and by default HB considers all consonants

1600

///                  pre-base. `bng2` has the `BLWF_MODE_PRE_AND_POST` characteristic,

1601

///                  therefore pre-base [Ba, Halant] takes on a subjoined form.

1602

///

1603

///       Uniscribe: [Ka+Halant (HALF), Ba+Halant+ZWJ (HALF)]

1604

///                  Uniscribe appears to terminate the base consonant search

1605

///                  too, but only applies the HALF feature to the syllable.

1606

///

1607

///

1608

/// Test sequence 2: [Ra, Halant, Ba, Halant, ZWJ]

1609

///

1610

///        HarfBuzz: [Ra+Halant+Ba (BLWF+(CJCT|PRES)), Halant, ZWJ]

1611

///                  On encountering a possible Reph, HB marks the Ra as a

1612

///                  possible base (in the event that Ra is the only consonant).

1613

///                  Base consonant search terminates on [Halant, ZWJ]. Ra

1614

///                  remains the base; therefore post-base [Halant, Ba] takes

1615

///                  on a subjoined form.

1616

///

1617

///       Uniscribe: [Ra+Halant (RPHF), Ba+Halant+ZWJ (HALF)]

1618

///                  Uniscribe chooses to shape the Reph, and positions it

1619

///                  on the Ba half form.

1620

/// ```

1621

fn initial_reorder_consonant_syllable_without_base(

1622

    glyphs: &mut [RawGlyphIndic],

1623

) -> Result<(), ShapingError> {

1624

    // IMPLEMENTATION: Considering the analysis above:

1625

//

1626

    // No reordering is necessary, therefore the only glyph that requires

1627

    // a `Pos` tag is the syllable-initial Ra iff it is to form a Reph.

1628

    // This is taken care of in `tag_consonants`.

1629

//

1630

    // NOTE: Our GSUB implementation is such that the remaining glyphs

1631

    // that constitute the Reph do not need to be tagged or masked.

1632

    for glyph in glyphs.iter_mut() {

1633

        let mask: FeatureMask = match glyph.pos() {

1634

            Some(Pos::RaToBecomeReph) => BasicFeature::Rphf.feature().mask(),

1635

            _ => BasicFeature::Half.feature().mask(),

1636

};

1637

1638

        glyph.add_mask(mask);

1639

1640

1641

    Ok(())

1642

1643

1644

/// Assign `Pos` tags to consonants in a syllable. Return the index of the base consonant, or `None`

1645

/// if base consonant does not exist.

1646

fn tag_consonants(

1647

    shaping_data: &IndicShapingData<'_>,

1648

    glyphs: &mut [RawGlyphIndic],

1649

) -> Result<Option<usize>, ShapingError> {

1650

    let has_reph = has_reph(shaping_data, glyphs)?;

1651

    let start_prebase_index;

1652

    if has_reph {

1653

        start_prebase_index = match shaping_data.script.reph_mode() {

1654

            RephMode::Implicit => 2,

1655

            RephMode::Explicit => 3,

1656

            RephMode::LogicalRepha => 1,

1657

};

1658

        glyphs[0].replace_none_pos(Some(Pos::RaToBecomeReph));

1659

    } else {

1660

        start_prebase_index = 0;

1661

};

1662

1663

    let base_index = match shaping_data.script.base_consonant_pos() {

1664

        BasePos::Last => {

1665

            tag_postbase_consonants(shaping_data, start_prebase_index, has_reph, glyphs)

1666

1667

        BasePos::LastSinhala => tag_postbase_consonants_sinhala(start_prebase_index, glyphs),

1668

}?;

1669

1670

    if shaping_data.script == Script::Gurmukhi {

1671

        tag_consonant_medials(glyphs);

1672

1673

1674

    // Tag base and pre-base consonants.

1675

    if let Some(base_index) = base_index {

1676

        // No untagged assertion, as this potentially replaces `Pos::RaToBecomeReph`.

1677

        glyphs[base_index].set_pos(Some(Pos::SyllableBase));

1678

        if start_prebase_index < base_index {

1679

            glyphs[start_prebase_index..base_index]

1680

                .iter_mut()

1681

                .filter(|g| g.is(effectively_consonant))

1682

                .for_each(|g| g.replace_none_pos(Some(Pos::PrebaseConsonant)));

1683

1684

1685

1686

    Ok(base_index)

1687

1688

1689

/// Assign `Pos` tags to post-base consonants (non-Sinhala scripts). Return the index of the base

1690

/// consonant, or `None` if base consonant does not exist.

1691

fn tag_postbase_consonants(

1692

    shaping_data: &IndicShapingData<'_>,

1693

    start_prebase_index: usize,

1694

    has_reph: bool,

1695

    glyphs: &mut [RawGlyphIndic],

1696

) -> Result<Option<usize>, ShapingError> {

1697

    let mut base_index = if has_reph {

1698

        match shaping_data.script.reph_mode() {

1699

            // "Ra" is still a base candidate if it is the only consonant in the syllable.

1700

            RephMode::Implicit => Some(0),

1701

            // "Ra" is never a base candidate, as "Reph" is always formed. (HarfBuzz, Uniscribe and

1702

            // CoreText take this approach with Sinhala. Not sure about Telugu.)

1703

            // https://github.com/n8willis/opentype-shaping-documents/issues/81.

1704

            RephMode::Explicit => None,

1705

            // "Repha" is not a consonant.

1706

            RephMode::LogicalRepha => None,

1707

1708

    } else {

1709

        None

1710

};

1711

    let mut i = glyphs.len() - 1;

1712

    let mut seen_belowbase = false;

1713

1714

    while i >= start_prebase_index {

1715

        if i == start_prebase_index {

1716

            if glyphs[i].is(effectively_consonant) {

1717

                base_index = Some(i);

1718

1719

            break;

1720

1721

1722

        let j = i - 1;

1723

        if glyphs[i].is(effectively_consonant) {

1724

            if !glyphs[j].is(halant) {

1725

                base_index = Some(i);

1726

                break;

1727

1728

1729

            // HACK: Reorder "Halant, Consonant" to "Consonant, Halant" for Indic1 compatibility.

1730

            if shaping_data.shaping_model == ShapingModel::Indic1 {

1731

                glyphs.swap(i, j);

1732

1733

1734

            let pos = postbase_tag(shaping_data, seen_belowbase, glyphs, j)?;

1735

1736

            // HACK: Undo the reorder.

1737

            if shaping_data.shaping_model == ShapingModel::Indic1 {

1738

                glyphs.swap(i, j);

1739

1740

1741

            // A consonant cannot be base if it has a {below, post, pre}-base reordering form.

1742

            if let Some(pos) = pos {

1743

                glyphs[i].replace_none_pos(Some(pos));

1744

                if pos == Pos::BelowbaseConsonant {

1745

                    seen_belowbase = true;

1746

1747

                i -= 2;

1748

            } else {

1749

                base_index = Some(i);

1750

                break;

1751

1752

        } else if glyphs[i].is(zwj) && glyphs[j].is(halant) {

1753

            // Terminate base search on "Halant, ZWJ". Mimics HarfBuzz (and possibly Uniscribe).

1754

            base_index = None;

1755

            break;

1756

        } else {

1757

            i -= 1;

1758

1759

1760

1761

    Ok(base_index)

1762

1763

1764

/// Assign `Pos` tags to post-base consonants (Sinhala). Return the index of the base consonant, or

1765

/// `None` if base consonant does not exist.

1766

fn tag_postbase_consonants_sinhala(

1767

    start_prebase_index: usize,

1768

    glyphs: &mut [RawGlyphIndic],

1769

) -> Result<Option<usize>, ShapingError> {

1770

    let mut base_index = None; // Sinhala is `RephMode:: Explicit`, so this is always `None`.

1771

    let mut i = glyphs.len() - 1;

1772

1773

    while i >= start_prebase_index {

1774

        if i == start_prebase_index {

1775

            if glyphs[i].is(effectively_consonant) {

1776

                base_index = Some(i);

1777

1778

            break;

1779

1780

1781

        let j = i - 1;

1782

        if glyphs[i].is(effectively_consonant) {

1783

            // A consonant cannot be base if it is preceded by a "ZWJ". (In Sinhala text, this

1784

            // sequence is used to specify the subjoined form of said consonant.)

1785

            if glyphs[j].is(zwj) {

1786

                glyphs[i].replace_none_pos(Some(Pos::BelowbaseConsonant));

1787

            } else {

1788

                base_index = Some(i);

1789

                break;

1790

1791

1792

1793

        i -= 1;

1794

1795

1796

    Ok(base_index)

1797

1798

1799

/// Return a `Pos` tag for a (possible) postbase consonant.

1800

///

1801

/// <https://github.com/n8willis/opentype-shaping-documents/issues/66>

1802

fn postbase_tag(

1803

    shaping_data: &IndicShapingData<'_>,

1804

    seen_belowbase: bool,

1805

    glyphs: &[RawGlyphIndic],

1806

    start_index: usize,

1807

) -> Result<Option<Pos>, ShapingError> {

1808

    const FEATURE_POS_PAIRS: &[(BasicFeature, Pos)] = &[

1809

        (BasicFeature::Blwf, Pos::BelowbaseConsonant),

1810

        (BasicFeature::Pstf, Pos::PostbaseConsonant),

1811

        (BasicFeature::Pref, Pos::PostbaseConsonant),

1812

];

1813

1814

    let applicable_feature_pos_pairs = if seen_belowbase {

1815

        // Post-base and pre-base-reordering forms must follow below-base forms

1816

        &FEATURE_POS_PAIRS[..1]

1817

    } else {

1818

        // Pre-base reordering forms only occur in Malayalam and Telugu scripts

1819

        match shaping_data.script {

1820

            Script::Malayalam | Script::Telugu => FEATURE_POS_PAIRS,

1821

            _ => &FEATURE_POS_PAIRS[..2],

1822

1823

};

1824

1825

    for (basic_feature, pos) in applicable_feature_pos_pairs {

1826

        if shaping_data.feature_would_apply(basic_feature.tag(), glyphs, start_index)? {

1827

            return Ok(Some(*pos));

1828

1829

1830

1831

    Ok(None)

1832

1833

1834

/// Tag the only Indic consonant medial, Gurmukhi Yakash U+0A75, with

1835

/// `Pos::BelowbaseConsonant`.

1836

///

1837

/// <https://github.com/n8willis/opentype-shaping-documents/issues/67>

1838

fn tag_consonant_medials(glyphs: &mut [RawGlyphIndic]) {

1839

    glyphs

1840

        .iter_mut()

1841

        .filter(|g| g.is(consonant_medial))

1842

        .for_each(|g| g.replace_none_pos(Some(Pos::BelowbaseConsonant)))

1843

1844

1845

/// For `RephMode::Implicit` and `RephMode::Explicit` scripts, check if the RPHF feature would

1846

/// apply. For `RephMode::LogicalRepha` scripts, check for the existence of a syllable-initial

1847

/// "Repha" code point.

1848

fn has_reph(

1849

    shaping_data: &IndicShapingData<'_>,

1850

    glyphs: &[RawGlyphIndic],

1851

) -> Result<bool, ShapingError> {

1852

    match shaping_data.script.reph_mode() {

1853

        RephMode::Implicit => match glyphs.get(..3) {

1854

            // A "ZWJ" (or "ZWNJ") after a syllable-initial "Ra, Halant" inhibits "Reph" formation.

1855

            Some([g0, g1, g2]) if g0.is(ra) && g1.is(halant) && !g2.is(joiner) => shaping_data

1856

                .feature_would_apply(BasicFeature::Rphf.tag(), glyphs, 0)

1857

                .map_err(|e| e.into()),

1858

            Some(_) | None => Ok(false),

1859

},

1860

        RephMode::Explicit => match glyphs.get(..3) {

1861

            Some([g0, g1, g2]) if g0.is(ra) && g1.is(halant) && g2.is(zwj) => shaping_data

1862

                .feature_would_apply(BasicFeature::Rphf.tag(), glyphs, 0)

1863

                .map_err(|e| e.into()),

1864

            Some(_) | None => Ok(false),

1865

},

1866

        RephMode::LogicalRepha => glyphs

1867

            .first()

1868

            .map(|g| g.is(repha))

1869

            .ok_or_else(|| ComplexScriptError::EmptyBuffer.into()),

1870

1871

1872

1873

/// Return the final sort-order position of a matra.

1874

///

1875

/// Return `None` if the input character:

1876

///   * is not a matra.

1877

///   * is a non-decomposable, multi-part matra (unless specially handled).

1878

fn matra_pos(c: char, script: Script) -> Option<Pos> {

1879

    // Handle multi-part matras that lack a canonical Unicode decomposition

1880

    // https://github.com/n8willis/opentype-shaping-documents/issues/62

1881

    match c {

1882

        '\u{0AC9}' => return Some(Pos::AfterPost), // Gujarati "Sign Candra O"

1883

        '\u{0B57}' => return Some(Pos::AfterPost), // Oriya "Au Length Mark"

1884

        _ => {}

1885

1886

1887

    match indic_character(c) {

1888

        (Some(ShapingClass::VowelDependent), Some(mark_placement)) => match mark_placement {

1889

            MarkPlacementSubclass::TopPosition => script.abovebase_matra_pos(),

1890

            MarkPlacementSubclass::RightPosition => script.rightside_matra_pos(c),

1891

            MarkPlacementSubclass::BottomPosition => Some(script.belowbase_matra_pos()),

1892

            MarkPlacementSubclass::LeftPosition => Some(Pos::PrebaseMatra),

1893

            _ => None,

1894

},

1895

        _ => None,

1896

1897

1898

1899

/////////////////////////////////////////////////////////////////////////////

1900

// Basic substitution features

1901

/////////////////////////////////////////////////////////////////////////////

1902

1903

/// Applies Indic basic features in their required order

1904

fn apply_basic_features(

1905

    shaping_data: &IndicShapingData<'_>,

1906

    glyphs: &mut Vec<RawGlyphIndic>,

1907

    max_glyphs: usize,

1908

) -> Result<(), ParseError> {

1909

    for feature in BasicFeature::ALL {

1910

        let index = shaping_data.get_lookups_cache_index(feature.feature().mask())?;

1911

        let lookups = &shaping_data.gsub_cache.cached_lookups.lock().unwrap()[index];

1912

1913

        for &(lookup_index, feature_tag) in lookups {

1914

            shaping_data.apply_lookup(lookup_index, feature_tag, glyphs, max_glyphs, |g| {

1915

                feature.is_global() || g.has_mask(feature.feature().mask())

1916

            })?;

1917

1918

1919

1920

    Ok(())

1921

1922

1923

/////////////////////////////////////////////////////////////////////////////

1924

// Final reordering

1925

/////////////////////////////////////////////////////////////////////////////

1926

1927

fn final_reorder_consonant_syllable(

1928

    shaping_data: &IndicShapingData<'_>,

1929

    glyphs: &mut [RawGlyphIndic],

1930

) {

1931

    // 4.1 Base consonant

1932

    let mut opt_base_index = glyphs.iter().position(|g| g.has_pos(Pos::SyllableBase));

1933

1934

    // Finding the base consonant in Malayalam appears to require special treatment.

1935

    // If there exists below-base consonants after the original base consonant that

1936

    // haven't taken on subjoined form, the last of these below-base consonants is

1937

    // the new base.

1938

//

1939

    // Example, using the Nirmala font:

1940

    //                 Syllable: [Ka, Halant, Tta, Halant, Na, Sign E]

1941

//

1942

    //    After initial reorder: [Sign E, Ka, Halant, Tta, Halant, Na]

1943

    //                           Ka is base, [Halant, Tta] and [Halant, Na] are marked below-base,

1944

    //                           but both do not take on subjoined form.

1945

//

1946

    //   HarfBuzz and Uniscribe: [Ka, Halant, Tta, Halant, Sign E, Na]

1947

    //                           The Sign E matra is moved to before the Na, as it is the new base.

1948

//

1949

    // IMPLEMENTATION: If a new base is found, the new `base_index` and the glyph

1950

    // marked `Pos::SyllableBase` will be misaligned, but at this stage it shouldn't

1951

    // matter.

1952

    if let (Script::Malayalam, Some(base_index)) = (shaping_data.script, opt_base_index) {

1953

        let start = base_index + 1;

1954

        opt_base_index = glyphs[start..]

1955

            .iter()

1956

            .rposition(|g| g.is(effectively_consonant) && g.has_pos(Pos::BelowbaseConsonant))

1957

            .map(|i| i + start)

1958

            .or(opt_base_index);

1959

1960

1961

    // 4.2 Pre-base matras

1962

    if let Some(base_index) = opt_base_index {

1963

        // Find the start index of a contiguous sequence of `Pos::PrebaseMatra` glyphs

1964

        let first_prebase_matra_index = glyphs[..base_index]

1965

            .iter()

1966

            .position(|g| g.has_pos(Pos::PrebaseMatra));

1967

1968

        // Find the end index of a contiguous sequence of `Pos::PrebaseMatra` glyphs

1969

        let last_prebase_matra_index = glyphs[..base_index]

1970

            .iter()

1971

            .rposition(|g| g.has_pos(Pos::PrebaseMatra));

1972

1973

        if let (Some(first_prebase_matra_index), Some(last_prebase_matra_index)) =

1974

            (first_prebase_matra_index, last_prebase_matra_index)

1975

1976

            // Find the new start index for this sequence

1977

            if let Some(final_prebase_matra_index) = final_pre_base_matra_index(

1978

                shaping_data.script,

1979

                last_prebase_matra_index,

1980

                base_index,

1981

                glyphs,

1982

) {

1983

                // Move the sequence

1984

                glyphs[first_prebase_matra_index..=final_prebase_matra_index]

1985

                    .rotate_left(last_prebase_matra_index - first_prebase_matra_index + 1);

1986

1987

1988

1989

1990

    // 4.3 Reph

1991

    if let Some(final_reph_index) = final_reph_index(shaping_data.script, opt_base_index, glyphs) {

1992

        move_element(glyphs, 0, final_reph_index);

1993

1994

        // Get new base index if Reph moves after the base

1995

        opt_base_index = opt_base_index.map(|b| if b <= final_reph_index { b - 1 } else { b });

1996

1997

1998

    // 4.4 Pre-base-reordering consonants

1999

    if let (Script::Malayalam, Some(base_index)) | (Script::Telugu, Some(base_index)) =

2000

        (shaping_data.script, opt_base_index)

2001

2002

        let mut pref_glyphs = glyphs

2003

            .iter()

2004

            .enumerate()

2005

            .filter(|(_, g)| g.has_mask(BasicFeature::Pref.feature().mask()));

2006

        let pref_glyphs_count = pref_glyphs.clone().count();

2007

2008

        // Check that only one glyph has the PREF feature

2009

        if let (Some((reordering_ra_index, _)), 1) = (pref_glyphs.next(), pref_glyphs_count) {

2010

            let final_reordering_ra_index =

2011

                final_pre_base_reordering_consonant_index(shaping_data.script, base_index, glyphs);

2012

2013

            move_element(glyphs, reordering_ra_index, final_reordering_ra_index);

2014

2015

2016

2017

    // 4.5 Initial matras

2018

    // IMPLEMENTATION: Handled in `apply_presentation_features`

2019

2020

2021

fn final_pre_base_matra_index(

2022

    script: Script,

2023

    last_prebase_matra_index: usize,

2024

    base_index: usize,

2025

    glyphs: &[RawGlyphIndic],

2026

) -> Option<usize> {

2027

    // Malayalam and Tamil do not have HALF forms or explicit "Halant" forms.

2028

    // Malayalam typically uses the HALF feature for chillu substitutions, and it

2029

    // appears that Tamil can use the HALF feature for forming _ligated_ explicit

2030

    // "Halant" forms (the TAMu_Kalyani font does this).

2031

//

2032

    // The pre-base matra should be positioned after these glyphs

2033

2034

    // https://github.com/n8willis/opentype-shaping-documents/issues/68

2035

    if script == Script::Malayalam || script == Script::Tamil {

2036

        return Some(base_index - 1);

2037

2038

2039

    // (1) The pre-base matra's final position is defined as: after the

2040

    // last standalone "Halant" glyph that comes after the matra's starting

2041

    // position and also comes before the main consonant

2042

//

2043

    // (2) If a ZWJ or a ZWNJ follows this last standalone "Halant", the

2044

    // final matra position is moved to after the joiner or non-joiner

2045

//

2046

    // We don't follow (2). Instead, if a ZWJ follows this last standalone

2047

    // "Halant", the final matra position should _not_ be after said "Halant"

2048

    // https://github.com/n8willis/opentype-shaping-documents/issues/73

2049

//

2050

    // IMPLEMENTATION: ZWNJ is taken care of by the syllable state machine.

2051

    // "Halant, ZWNJ" is a terminating sequence for a consonant syllable; any

2052

    // pre-base matras occurring after it belong to the subsequent syllable

2053

    let start = last_prebase_matra_index + 1;

2054

    glyphs[start..=base_index]

2055

        .windows(2)

2056

        .rposition(|gs| gs[0].is(halant) && !gs[1].is(zwj))

2057

        .map(|i| i + start)

2058

2059

2060

// Variant of `final_pre_base_matra_index`. Differences:

2061

//   * doesn't special-case Tamil, as the script has no pre-base-reordering consonants

2062

//   * positions the pre-base-reordering consonant after a "Halant, ZWJ"

2063

//     https://github.com/n8willis/opentype-shaping-documents/issues/73

2064

//   * has a default position immediately before the base consonant

2065

fn final_pre_base_reordering_consonant_index(

2066

    script: Script,

2067

    base_index: usize,

2068

    glyphs: &[RawGlyphIndic],

2069

) -> usize {

2070

    if script == Script::Malayalam {

2071

        return base_index;

2072

2073

2074

    let mut iter = glyphs[..=base_index].windows(2).enumerate().rev();

2075

    while let Some((i, [g0, g1])) = iter.next() {

2076

        if g0.is(halant) {

2077

            if g1.is(zwj) {

2078

                return i + 2;

2079

2080

            return i + 1;

2081

2082

2083

2084

    base_index

2085

2086

2087

// At this stage, this step has become such a mish-mash of:

2088

//   * the OpenType spec

2089

//   * HarfBuzz's interpretation of the OpenType spec

2090

//   * our spec

2091

//   * comparison against CoreText's output

2092

// that it really deserves to be called "Final Reph Pos As Decided by Adrian"

2093

// https://github.com/n8willis/opentype-shaping-documents/issues/48

2094

fn final_reph_index(

2095

    script: Script,

2096

    base_index: Option<usize>,

2097

    glyphs: &[RawGlyphIndic],

2098

) -> Option<usize> {

2099

    // No "Reph", no problems

2100

    if glyphs.len() < 2 || !glyphs[0].has_pos(Pos::RaToBecomeReph) {

2101

        return None;

2102

2103

2104

    let reph_characteristic = script.reph_position();

2105

2106

    // This is "Reorder Reph" step 2/b in OpenType, which HarfBuzz implements

2107

    // (and CoreText too, from empirical testing), but our spec doesn't.

2108

//

2109

    // "If the "Reph" repositioning class is not after post-base: target position is after

2110

    // the first explicit "Halant" glyph between the first post-reph consonant and last main

2111

    // consonant. If "ZWJ" or "ZWNJ" are following this "Halant", position is moved after it.

2112

    // If such position is found, this is the target position." ***

2113

    // https://docs.microsoft.com/en-us/typography/script-development/devanagari#reorder-characters

2114

//

2115

    // TEST: "Ra, Halant, Ra, Halant, Ya" using Noto Sans/Serif Devanagari.

2116

    // Without this step, the "Reph" is positioned after the "Ya", when this step dictates that

2117

    // it should move after the first explicit "Halant" between the "Reph" and base consonant

2118

//

2119

    // *** There is evidence to believe that Uniscribe may still do this for the after post-base

2120

    //     repositioning class, and HarfBuzz _definitely_ does it

2121

    if let Some(base_index) = base_index {

2122

        let start = 1;

2123

        let mut iter = glyphs[start..=base_index].windows(2).enumerate();

2124

        while let Some((i, [g0, g1])) = iter.next() {

2125

            if g0.is(halant) {

2126

                if g1.is(joiner) {

2127

                    return Some(i + 1 + start);

2128

2129

                return Some(i + start);

2130

2131

2132

2133

2134

    // This is where things start getting even more fantastic.

2135

//

2136

    // For scripts that have the REPH_POS_BEFORE_POST characteristic, OpenType "Reorder Reph" step 4/d

2137

    // states:

2138

//

2139

    // "If "Reph" should be positioned before post-base consonant, find first post-base classified

2140

    // consonant not ligated with main. If no consonant is found, the target position should be

2141

    // before the first matra, syllable modifier sign or vedic sign."

2142

//

2143

    // Our spec imitates OpenType. However, it looks like HarfBuzz and CoreText don't, and instead

2144

    // jump straight to step 5/e:

2145

//

2146

    // "If no consonant is found in 3/c or 4/d, move "Reph" to a position immediately before

2147

    // the first post-base matra, syllable modifier sign or vedic sign ***that has a reordering

2148

    // class after the intended "Reph" position***. For example, if the reordering position for

2149

    // "Reph" is post-main, it will skip above-base matras that also have a post-main position."

2150

//

2151

    // TEST: "Ra, Halant, Ka, Sign Aa" using Noto Sans/Serif Devanagari.

2152

    // HarfBuzz and CoreText have the "Reph" positioned after the "Sign Aa" (which is marked

2153

    // Pos::AfterSubjoined). If we followed our spec/OpenType, it gets positioned after the "Ka"

2154

2155

    // HarfBuzz **does** implement their interpretation of 4/d, but for whatever reason only applies

2156

    // it to scripts that have the REPH_POS_AFTER_SUBJOINED characteristic.

2157

//

2158

    // There is no explicit handling of REPH_POS_BEFORE_SUBJOINED in HarfBuzz

2159

2160

    // Biting the bullet and making this change so as to be consistent with HarfBuzz and

2161

    // Uniscribe's (Gujarati) output. Sorry CoreText!

2162

//

2163

    // For scripts with the REPH_POS_BEFORE_POST characteristic, position the "Reph" after

2164

    // ALL post-base matras

2165

    let reordering_class = match reph_characteristic {

2166

        Pos::BeforePost => Some(Pos::AfterPost),

2167

        _ => Some(reph_characteristic),

2168

};

2169

2170

    let new_index = glyphs

2171

        .iter()

2172

        .rposition(|g| g.pos() <= reordering_class)

2173

        .unwrap_or(glyphs.len() - 1); // Fallback index == end of syllable

2174

2175

    // This step doesn't appear to be covered in OpenType, but is implemented in HarfBuzz and

2176

    // appears to be implemented in CoreText. From our spec:

2177

//

2178

    // "Finally, if the final position of "Reph" occurs after a "matra, Halant" subsequence, then

2179

    // "Reph" must be repositioned to the left of "Halant", to allow for potential matching with

2180

    // abvs or psts substitutions from GSUB."

2181

//

2182

    // Our spec applies this to all "Reph" characteristics except REPH_POS_BEFORE_POST.

2183

    // TEST: "Ra, Halant, Ka, O, Halant" in Noto Sans/Serif Devanagari (Devanagari incorporates

2184

    // the REPH_POS_BEFORE_POST characteristic)

2185

    match (glyphs.get(new_index - 1), glyphs.get(new_index)) {

2186

        (Some(g0), Some(g1)) if g0.is(matra) && g1.is(halant) => Some(new_index - 1),

2187

        _ => Some(new_index),

2188

2189

2190

2191

/////////////////////////////////////////////////////////////////////////////

2192

// Remaining substitution features

2193

/////////////////////////////////////////////////////////////////////////////

2194

2195

/// Apply remaining substitution features after final reordering.

2196

///

2197

/// If the syllable is the first in a word, applies the INIT feature.

2198

///

2199

/// The order in which the remaining features are applied should be in

2200

/// the order in which they appear in the GSUB table.

2201

fn apply_presentation_features(

2202

    shaping_data: &IndicShapingData<'_>,

2203

    is_first_syllable: bool,

2204

    extra_features: FeatureMask,

2205

    glyphs: &mut Vec<RawGlyphIndic>,

2206

    max_glyphs: usize,

2207

) -> Result<(), ParseError> {

2208

    let mut features = Feature::PRES

2209

        | Feature::ABVS

2210

        | Feature::BLWS

2211

        | Feature::PSTS

2212

        | Feature::HALN

2213

        | Feature::CALT

2214

        | extra_features;

2215

2216

    if let Some(glyph) = glyphs.first_mut() {

2217

        if is_first_syllable && glyph.has_pos(Pos::PrebaseMatra) {

2218

            glyph.add_mask(Feature::INIT.mask());

2219

            features |= Feature::INIT;

2220

2221

2222

    let index = shaping_data.get_lookups_cache_index(features)?;

2223

    let lookups = &shaping_data.gsub_cache.cached_lookups.lock().unwrap()[index];

2224

2225

    for &(lookup_index, feature_tag) in lookups {

2226

        shaping_data.apply_lookup(lookup_index, feature_tag, glyphs, max_glyphs, |g| {

2227

            feature_tag != tag::INIT || g.has_mask(Feature::INIT.mask())

2228

        })?;

2229

2230

2231

    Ok(())

2232

2233

2234

/////////////////////////////////////////////////////////////////////////////

2235

// Helper functions

2236

/////////////////////////////////////////////////////////////////////////////

2237

2238

fn to_raw_glyph_indic(glyph: &RawGlyph<()>) -> RawGlyphIndic {

2239

    RawGlyphIndic {

2240

        unicodes: glyph.unicodes.clone(),

2241

        glyph_index: glyph.glyph_index,

2242

        liga_component_pos: glyph.liga_component_pos,

2243

        glyph_origin: glyph.glyph_origin,

2244

        flags: glyph.flags,

2245

        variation: glyph.variation,

2246

        extra_data: IndicData {

2247

            pos: None,

2248

            mask: FeatureMask::empty(),

2249

},

2250

2251

2252

2253

fn from_raw_glyph_indic(glyph: RawGlyphIndic) -> RawGlyph<()> {

2254

    RawGlyph {

2255

        unicodes: glyph.unicodes,

2256

        glyph_index: glyph.glyph_index,

2257

        liga_component_pos: glyph.liga_component_pos,

2258

        glyph_origin: glyph.glyph_origin,

2259

        flags: glyph.flags,

2260

        variation: glyph.variation,

2261

        extra_data: (),

2262

2263

2264

2265

/// Checks if a character is effectively an Indic consonant.

2266

///

2267

/// Gurmukhi's two `ConsonantPlaceholder` characters "Iri" and "Ura" are

2268

/// considered consonants.

2269

///

2270

/// Kannada's two `ConsonantWithStacker` characters "Jihvamuliya" and

2271

/// "Upadhmaniya" are considered consonants.

2272

///

2273

/// Also, HarfBuzz treats dotted circles, placeholders, and independent

2274

/// vowels as consonants. We follow suit.

2275

fn effectively_consonant(c: char) -> bool {

2276

    match shaping_class(c) {

2277

        Some(ShapingClass::Consonant)

2278

        | Some(ShapingClass::ConsonantDead)

2279

        | Some(ShapingClass::ConsonantPlaceholder)

2280

        | Some(ShapingClass::ConsonantWithStacker)

2281

        | Some(ShapingClass::DottedCircle)

2282

        | Some(ShapingClass::Number)

2283

        | Some(ShapingClass::Placeholder)

2284

        | Some(ShapingClass::VowelIndependent) => true,

2285

        _ => false,

2286

2287

2288

2289

fn move_element<T>(slice: &mut [T], from: usize, to: usize) {

2290

    if from < to {

2291

        slice[from..=to].rotate_left(1);

2292

    } else {

2293

        slice[to..=from].rotate_right(1);

2294

2295

2296

2297

/////////////////////////////////////////////////////////////////////////////

2298

// Indic character tables

2299

/////////////////////////////////////////////////////////////////////////////

2300

2301

#[rustfmt::skip]

2302

fn indic_character(ch: char) -> (Option<ShapingClass>, Option<MarkPlacementSubclass>) {

2303

    use MarkPlacementSubclass::*;

2304

    use ShapingClass::*;

2305

2306

    match ch as u32 {

2307

        // Devanagari character table

2308

        0x0900 => (Some(Bindu), Some(TopPosition)),             // Inverted Candrabindu

2309

        0x0901 => (Some(Bindu), Some(TopPosition)),             // Candrabindu

2310

        0x0902 => (Some(Bindu), Some(TopPosition)),             // Anusvara

2311

        0x0903 => (Some(Visarga), Some(RightPosition)),         // Visarga

2312

        0x0904 => (Some(VowelIndependent), None),               // Short A

2313

        0x0905 => (Some(VowelIndependent), None),               // A

2314

        0x0906 => (Some(VowelIndependent), None),               // Aa

2315

        0x0907 => (Some(VowelIndependent), None),               // I

2316

        0x0908 => (Some(VowelIndependent), None),               // Ii

2317

        0x0909 => (Some(VowelIndependent), None),               // U

2318

        0x090A => (Some(VowelIndependent), None),               // Uu

2319

        0x090B => (Some(VowelIndependent), None),               // Vocalic R

2320

        0x090C => (Some(VowelIndependent), None),               // Vocalic L

2321

        0x090D => (Some(VowelIndependent), None),               // Candra E

2322

        0x090E => (Some(VowelIndependent), None),               // Short E

2323

        0x090F => (Some(VowelIndependent), None),               // E

2324

        0x0910 => (Some(VowelIndependent), None),               // Ai

2325

        0x0911 => (Some(VowelIndependent), None),               // Candra O

2326

        0x0912 => (Some(VowelIndependent), None),               // Short O

2327

        0x0913 => (Some(VowelIndependent), None),               // O

2328

        0x0914 => (Some(VowelIndependent), None),               // Au

2329

        0x0915 => (Some(Consonant), None),                      // Ka

2330

        0x0916 => (Some(Consonant), None),                      // Kha

2331

        0x0917 => (Some(Consonant), None),                      // Ga

2332

        0x0918 => (Some(Consonant), None),                      // Gha

2333

        0x0919 => (Some(Consonant), None),                      // Nga

2334

        0x091A => (Some(Consonant), None),                      // Ca

2335

        0x091B => (Some(Consonant), None),                      // Cha

2336

        0x091C => (Some(Consonant), None),                      // Ja

2337

        0x091D => (Some(Consonant), None),                      // Jha

2338

        0x091E => (Some(Consonant), None),                      // Nya

2339

        0x091F => (Some(Consonant), None),                      // Tta

2340

        0x0920 => (Some(Consonant), None),                      // Ttha

2341

        0x0921 => (Some(Consonant), None),                      // Dda

2342

        0x0922 => (Some(Consonant), None),                      // Ddha

2343

        0x0923 => (Some(Consonant), None),                      // Nna

2344

        0x0924 => (Some(Consonant), None),                      // Ta

2345

        0x0925 => (Some(Consonant), None),                      // Tha

2346

        0x0926 => (Some(Consonant), None),                      // Da

2347

        0x0927 => (Some(Consonant), None),                      // Dha

2348

        0x0928 => (Some(Consonant), None),                      // Na

2349

        0x0929 => (Some(Consonant), None),                      // Nnna

2350

        0x092A => (Some(Consonant), None),                      // Pa

2351

        0x092B => (Some(Consonant), None),                      // Pha

2352

        0x092C => (Some(Consonant), None),                      // Ba

2353

        0x092D => (Some(Consonant), None),                      // Bha

2354

        0x092E => (Some(Consonant), None),                      // Ma

2355

        0x092F => (Some(Consonant), None),                      // Ya

2356

        0x0930 => (Some(Consonant), None),                      // Ra

2357

        0x0931 => (Some(Consonant), None),                      // Rra

2358

        0x0932 => (Some(Consonant), None),                      // La

2359

        0x0933 => (Some(Consonant), None),                      // Lla

2360

        0x0934 => (Some(Consonant), None),                      // Llla

2361

        0x0935 => (Some(Consonant), None),                      // Va

2362

        0x0936 => (Some(Consonant), None),                      // Sha

2363

        0x0937 => (Some(Consonant), None),                      // Ssa

2364

        0x0938 => (Some(Consonant), None),                      // Sa

2365

        0x0939 => (Some(Consonant), None),                      // Ha

2366

        0x093A => (Some(VowelDependent), Some(TopPosition)),    // Sign Oe

2367

        0x093B => (Some(VowelDependent), Some(RightPosition)),  // Sign Ooe

2368

        0x093C => (Some(Nukta), Some(BottomPosition)),          // Nukta

2369

        0x093D => (Some(Avagraha), None),                       // Avagraha

2370

        0x093E => (Some(VowelDependent), Some(RightPosition)),  // Sign Aa

2371

        0x093F => (Some(VowelDependent), Some(LeftPosition)),   // Sign I

2372

        0x0940 => (Some(VowelDependent), Some(RightPosition)),  // Sign Ii

2373

        0x0941 => (Some(VowelDependent), Some(BottomPosition)), // Sign U

2374

        0x0942 => (Some(VowelDependent), Some(BottomPosition)), // Sign Uu

2375

        0x0943 => (Some(VowelDependent), Some(BottomPosition)), // Sign Vocalic R

2376

        0x0944 => (Some(VowelDependent), Some(BottomPosition)), // Sign Vocalic Rr

2377

        0x0945 => (Some(VowelDependent), Some(TopPosition)),    // Sign Candra E

2378

        0x0946 => (Some(VowelDependent), Some(TopPosition)),    // Sign Short E

2379

        0x0947 => (Some(VowelDependent), Some(TopPosition)),    // Sign E

2380

        0x0948 => (Some(VowelDependent), Some(TopPosition)),    // Sign Ai

2381

        0x0949 => (Some(VowelDependent), Some(RightPosition)),  // Sign Candra O

2382

        0x094A => (Some(VowelDependent), Some(RightPosition)),  // Sign Short O

2383

        0x094B => (Some(VowelDependent), Some(RightPosition)),  // Sign O

2384

        0x094C => (Some(VowelDependent), Some(RightPosition)),  // Sign Au

2385

        0x094D => (Some(Virama), Some(BottomPosition)),         // Virama

2386

        0x094E => (Some(VowelDependent), Some(LeftPosition)),   // Sign Prishthamatra E

2387

        0x094F => (Some(VowelDependent), Some(RightPosition)),  // Sign Aw

2388

        0x0950 => (None, None),                                 // Om

2389

        0x0951 => (Some(Cantillation), Some(TopPosition)),      // Udatta

2390

        0x0952 => (Some(Cantillation), Some(BottomPosition)),   // Anudatta

2391

        0x0953 => (None, Some(TopPosition)),                    // Grave accent

2392

        0x0954 => (None, Some(TopPosition)),                    // Acute accent

2393

        0x0955 => (Some(VowelDependent), Some(TopPosition)),    // Sign Candra Long E

2394

        0x0956 => (Some(VowelDependent), Some(BottomPosition)), // Sign Ue

2395

        0x0957 => (Some(VowelDependent), Some(BottomPosition)), // Sign Uue

2396

        0x0958 => (Some(Consonant), None),                      // Qa

2397

        0x0959 => (Some(Consonant), None),                      // Khha

2398

        0x095A => (Some(Consonant), None),                      // Ghha

2399

        0x095B => (Some(Consonant), None),                      // Za

2400

        0x095C => (Some(Consonant), None),                      // Dddha

2401

        0x095D => (Some(Consonant), None),                      // Rha

2402

        0x095E => (Some(Consonant), None),                      // Fa

2403

        0x095F => (Some(Consonant), None),                      // Yya

2404

        0x0960 => (Some(VowelIndependent), None),               // Vocalic Rr

2405

        0x0961 => (Some(VowelIndependent), None),               // Vocalic Ll

2406

        0x0962 => (Some(VowelDependent), Some(BottomPosition)), // Sign Vocalic L

2407

        0x0963 => (Some(VowelDependent), Some(BottomPosition)), // Sign Vocalic Ll

2408

        0x0964 => (None, None),                                 // Danda

2409

        0x0965 => (None, None),                                 // Double Danda

2410

        0x0966 => (Some(Number), None),                         // Digit Zero

2411

        0x0967 => (Some(Number), None),                         // Digit One

2412

        0x0968 => (Some(Number), None),                         // Digit Two

2413

        0x0969 => (Some(Number), None),                         // Digit Three

2414

        0x096A => (Some(Number), None),                         // Digit Four

2415

        0x096B => (Some(Number), None),                         // Digit Five

2416

        0x096C => (Some(Number), None),                         // Digit Six

2417

        0x096D => (Some(Number), None),                         // Digit Seven

2418

        0x096E => (Some(Number), None),                         // Digit Eight

2419

        0x096F => (Some(Number), None),                         // Digit Nine

2420

        0x0970 => (None, None),                                 // Abbreviation Sign

2421

        0x0971 => (None, None),                                 // Sign High Spacing Dot

2422

        0x0972 => (Some(VowelIndependent), None),               // Candra Aa

2423

        0x0973 => (Some(VowelIndependent), None),               // Oe

2424

        0x0974 => (Some(VowelIndependent), None),               // Ooe

2425

        0x0975 => (Some(VowelIndependent), None),               // Aw

2426

        0x0976 => (Some(VowelIndependent), None),               // Ue

2427

        0x0977 => (Some(VowelIndependent), None),               // Uue

2428

        0x0978 => (Some(Consonant), None),                      // Marwari Dda

2429

        0x0979 => (Some(Consonant), None),                      // Zha

2430

        0x097A => (Some(Consonant), None),                      // Heavy Ya

2431

        0x097B => (Some(Consonant), None),                      // Gga

2432

        0x097C => (Some(Consonant), None),                      // Jja

2433

        0x097D => (Some(Consonant), None),                      // Glottal Stop

2434

        0x097E => (Some(Consonant), None),                      // Ddda

2435

        0x097F => (Some(Consonant), None),                      // Bba

2436

2437

        // Bengali character table

2438

        0x0980 => (Some(ConsonantPlaceholder), None),                 // Anji

2439

        0x0981 => (Some(Bindu), Some(TopPosition)),                   // Candrabindu

2440

        0x0982 => (Some(Bindu), Some(RightPosition)),                 // Anusvara

2441

        0x0983 => (Some(Visarga), Some(RightPosition)),               // Visarga

2442

        0x0984 => (None, None),                                       // unassigned

2443

        0x0985 => (Some(VowelIndependent), None),                     // A

2444

        0x0986 => (Some(VowelIndependent), None),                     // Aa

2445

        0x0987 => (Some(VowelIndependent), None),                     // I

2446

        0x0988 => (Some(VowelIndependent), None),                     // Ii

2447

        0x0989 => (Some(VowelIndependent), None),                     // U

2448

        0x098A => (Some(VowelIndependent), None),                     // Uu

2449

        0x098B => (Some(VowelIndependent), None),                     // Vocalic R

2450

        0x098C => (Some(VowelIndependent), None),                     // Vocalic L

2451

        0x098D => (None, None),                                       // unassigned

2452

        0x098E => (None, None),                                       // unassigned

2453

        0x098F => (Some(VowelIndependent), None),                     // E

2454

        0x0990 => (Some(VowelIndependent), None),                     // Ai

2455

        0x0991 => (None, None),                                       // unassigned

2456

        0x0992 => (None, None),                                       // unassigned

2457

        0x0993 => (Some(VowelIndependent), None),                     // O

2458

        0x0994 => (Some(VowelIndependent), None),                     // Au

2459

        0x0995 => (Some(Consonant), None),                            // Ka

2460

        0x0996 => (Some(Consonant), None),                            // Kha

2461

        0x0997 => (Some(Consonant), None),                            // Ga

2462

        0x0998 => (Some(Consonant), None),                            // Gha

2463

        0x0999 => (Some(Consonant), None),                            // Nga

2464

        0x099A => (Some(Consonant), None),                            // Ca

2465

        0x099B => (Some(Consonant), None),                            // Cha

2466

        0x099C => (Some(Consonant), None),                            // Ja

2467

        0x099D => (Some(Consonant), None),                            // Jha

2468

        0x099E => (Some(Consonant), None),                            // Nya

2469

        0x099F => (Some(Consonant), None),                            // Tta

2470

        0x09A0 => (Some(Consonant), None),                            // Ttha

2471

        0x09A1 => (Some(Consonant), None),                            // Dda

2472

        0x09A2 => (Some(Consonant), None),                            // Ddha

2473

        0x09A3 => (Some(Consonant), None),                            // Nna

2474

        0x09A4 => (Some(Consonant), None),                            // Ta

2475

        0x09A5 => (Some(Consonant), None),                            // Tha

2476

        0x09A6 => (Some(Consonant), None),                            // Da

2477

        0x09A7 => (Some(Consonant), None),                            // Dha

2478

        0x09A8 => (Some(Consonant), None),                            // Na

2479

        0x09A9 => (None, None),                                       // unassigned

2480

        0x09AA => (Some(Consonant), None),                            // Pa

2481

        0x09AB => (Some(Consonant), None),                            // Pha

2482

        0x09AC => (Some(Consonant), None),                            // Ba

2483

        0x09AD => (Some(Consonant), None),                            // Bha

2484

        0x09AE => (Some(Consonant), None),                            // Ma

2485

        0x09AF => (Some(Consonant), None),                            // Ya

2486

        0x09B0 => (Some(Consonant), None),                            // Ra

2487

        0x09B1 => (None, None),                                       // unassigned

2488

        0x09B2 => (Some(Consonant), None),                            // La

2489

        0x09B3 => (None, None),                                       // unassigned

2490

        0x09B4 => (None, None),                                       // unassigned

2491

        0x09B5 => (None, None),                                       // unassigned

2492

        0x09B6 => (Some(Consonant), None),                            // Sha

2493

        0x09B7 => (Some(Consonant), None),                            // Ssa

2494

        0x09B8 => (Some(Consonant), None),                            // Sa

2495

        0x09B9 => (Some(Consonant), None),                            // Ha

2496

        0x09BA => (None, None),                                       // unassigned

2497

        0x09BB => (None, None),                                       // unassigned

2498

        0x09BC => (Some(Nukta), Some(BottomPosition)),                // Nukta

2499

        0x09BD => (Some(Avagraha), None),                             // Avagraha

2500

        0x09BE => (Some(VowelDependent), Some(RightPosition)),        // Sign Aa

2501

        0x09BF => (Some(VowelDependent), Some(LeftPosition)),         // Sign I

2502

        0x09C0 => (Some(VowelDependent), Some(RightPosition)),        // Sign Ii

2503

        0x09C1 => (Some(VowelDependent), Some(BottomPosition)),       // Sign U

2504

        0x09C2 => (Some(VowelDependent), Some(BottomPosition)),       // Sign Uu

2505

        0x09C3 => (Some(VowelDependent), Some(BottomPosition)),       // Sign Vocalic R

2506

        0x09C4 => (Some(VowelDependent), Some(BottomPosition)),       // Sign Vocalic Rr

2507

        0x09C5 => (None, None),                                       // unassigned

2508

        0x09C6 => (None, None),                                       // unassigned

2509

        0x09C7 => (Some(VowelDependent), Some(LeftPosition)),         // Sign E

2510

        0x09C8 => (Some(VowelDependent), Some(LeftPosition)),         // Sign Ai

2511

        0x09C9 => (None, None),                                       // unassigned

2512

        0x09CA => (None, None),                                       // unassigned

2513

        0x09CB => (Some(VowelDependent), Some(LeftAndRightPosition)), // Sign O

2514

        0x09CC => (Some(VowelDependent), Some(LeftAndRightPosition)), // Sign Au

2515

        0x09CD => (Some(Virama), Some(BottomPosition)),               // Virama

2516

        0x09CE => (Some(ConsonantDead), None),                        // Khanda Ta

2517

        0x09CF => (None, None),                                       // unassigned

2518

        0x09D0 => (None, None),                                       // unassigned

2519

        0x09D1 => (None, None),                                       // unassigned

2520

        0x09D2 => (None, None),                                       // unassigned

2521

        0x09D3 => (None, None),                                       // unassigned

2522

        0x09D4 => (None, None),                                       // unassigned

2523

        0x09D5 => (None, None),                                       // unassigned

2524

        0x09D6 => (None, None),                                       // unassigned

2525

        0x09D7 => (Some(VowelDependent), Some(RightPosition)),        // Au Length Mark

2526

        0x09D8 => (None, None),                                       // unassigned

2527

        0x09D9 => (None, None),                                       // unassigned

2528

        0x09DA => (None, None),                                       // unassigned

2529

        0x09DB => (None, None),                                       // unassigned

2530

        0x09DC => (Some(Consonant), None),                            // Rra

2531

        0x09DD => (Some(Consonant), None),                            // Rha

2532

        0x09DE => (None, None),                                       // unassigned

2533

        0x09DF => (Some(Consonant), None),                            // Yya

2534

        0x09E0 => (Some(VowelIndependent), None),                     // Vocalic Rr

2535

        0x09E1 => (Some(VowelIndependent), None),                     // Vocalic Ll

2536

        0x09E2 => (Some(VowelDependent), Some(BottomPosition)),       // Sign Vocalic L

2537

        0x09E3 => (Some(VowelDependent), Some(BottomPosition)),       // Sign Vocalic Ll

2538

        0x09E4 => (None, None),                                       // unassigned

2539

        0x09E5 => (None, None),                                       // unassigned

2540

        0x09E6 => (Some(Number), None),                               // Digit Zero

2541

        0x09E7 => (Some(Number), None),                               // Digit One

2542

        0x09E8 => (Some(Number), None),                               // Digit Two

2543

        0x09E9 => (Some(Number), None),                               // Digit Three

2544

        0x09EA => (Some(Number), None),                               // Digit Four

2545

        0x09EB => (Some(Number), None),                               // Digit Five

2546

        0x09EC => (Some(Number), None),                               // Digit Six

2547

        0x09ED => (Some(Number), None),                               // Digit Seven

2548

        0x09EE => (Some(Number), None),                               // Digit Eight

2549

        0x09EF => (Some(Number), None),                               // Digit Nine

2550

        0x09F0 => (Some(Consonant), None),                            // Assamese Ra

2551

        0x09F1 => (Some(Consonant), None),                            // Assamese Wa

2552

        0x09F2 => (Some(Symbol), None),                               // Rupee Mark

2553

        0x09F3 => (Some(Symbol), None),                               // Rupee Sign

2554

        0x09F4 => (Some(Number), None),                               // Numerator One

2555

        0x09F5 => (Some(Number), None),                               // Numerator Two

2556

        0x09F6 => (Some(Number), None),                               // Numerator Three

2557

        0x09F7 => (Some(Number), None),                               // Numerator Four

2558

        0x09F8 => (Some(Number), None),                               // Numerator One Less Than Denominator

2559

        0x09F9 => (Some(Number), None),                               // Denominator Sixteen

2560

        0x09FA => (Some(Symbol), None),                               // Isshar

2561

        0x09FB => (Some(Symbol), None),                               // Ganda Mark

2562

        0x09FC => (None, None),                                       // Vedic Anusvara

2563

        0x09FD => (None, None),                                       // Abbreviation Sign

2564

        0x09FE => (Some(SyllableModifier), Some(TopPosition)),        // Sandhi Mark

2565

2566

        // Gurmukhi character table

2567

        0x0A00 => (None, None),                                  // unassigned

2568

        0x0A01 => (Some(Bindu), Some(TopPosition)),              // Adak Bindi

2569

        0x0A02 => (Some(Bindu), Some(TopPosition)),              // Bindi

2570

        0x0A03 => (Some(Visarga), Some(RightPosition)),          // Visarga

2571

        0x0A04 => (None, None),                                  // unassigned

2572

        0x0A05 => (Some(VowelIndependent), None),                // A

2573

        0x0A06 => (Some(VowelIndependent), None),                // Aa

2574

        0x0A07 => (Some(VowelIndependent), None),                // I

2575

        0x0A08 => (Some(VowelIndependent), None),                // Ii

2576

        0x0A09 => (Some(VowelIndependent), None),                // U

2577

        0x0A0A => (Some(VowelIndependent), None),                // Uu

2578

        0x0A0B => (None, None),                                  // unassigned

2579

        0x0A0C => (None, None),                                  // unassigned

2580

        0x0A0D => (None, None),                                  // unassigned

2581

        0x0A0E => (None, None),                                  // unassigned

2582

        0x0A0F => (Some(VowelIndependent), None),                // Ee

2583

        0x0A10 => (Some(VowelIndependent), None),                // Ai

2584

        0x0A11 => (None, None),                                  // unassigned

2585

        0x0A12 => (None, None),                                  // unassigned

2586

        0x0A13 => (Some(VowelIndependent), None),                // Oo

2587

        0x0A14 => (Some(VowelIndependent), None),                // Au

2588

        0x0A15 => (Some(Consonant), None),                       // Ka

2589

        0x0A16 => (Some(Consonant), None),                       // Kha

2590

        0x0A17 => (Some(Consonant), None),                       // Ga

2591

        0x0A18 => (Some(Consonant), None),                       // Gha

2592

        0x0A19 => (Some(Consonant), None),                       // Nga

2593

        0x0A1A => (Some(Consonant), None),                       // Ca

2594

        0x0A1B => (Some(Consonant), None),                       // Cha

2595

        0x0A1C => (Some(Consonant), None),                       // Ja

2596

        0x0A1D => (Some(Consonant), None),                       // Jha

2597

        0x0A1E => (Some(Consonant), None),                       // Nya

2598

        0x0A1F => (Some(Consonant), None),                       // Tta

2599

        0x0A20 => (Some(Consonant), None),                       // Ttha

2600

        0x0A21 => (Some(Consonant), None),                       // Dda

2601

        0x0A22 => (Some(Consonant), None),                       // Ddha

2602

        0x0A23 => (Some(Consonant), None),                       // Nna

2603

        0x0A24 => (Some(Consonant), None),                       // Ta

2604

        0x0A25 => (Some(Consonant), None),                       // Tha

2605

        0x0A26 => (Some(Consonant), None),                       // Da

2606

        0x0A27 => (Some(Consonant), None),                       // Dha

2607

        0x0A28 => (Some(Consonant), None),                       // Na

2608

        0x0A29 => (None, None),                                  // unassigned

2609

        0x0A2A => (Some(Consonant), None),                       // Pa

2610

        0x0A2B => (Some(Consonant), None),                       // Pha

2611

        0x0A2C => (Some(Consonant), None),                       // Ba

2612

        0x0A2D => (Some(Consonant), None),                       // Bha

2613

        0x0A2E => (Some(Consonant), None),                       // Ma

2614

        0x0A2F => (Some(Consonant), None),                       // Ya

2615

        0x0A30 => (Some(Consonant), None),                       // Ra

2616

        0x0A31 => (None, None),                                  // unassigned

2617

        0x0A32 => (Some(Consonant), None),                       // La

2618

        0x0A33 => (Some(Consonant), None),                       // Lla

2619

        0x0A34 => (None, None),                                  // unassigned

2620

        0x0A35 => (Some(Consonant), None),                       // Va

2621

        0x0A36 => (Some(Consonant), None),                       // Sha

2622

        0x0A37 => (None, None),                                  // unassigned

2623

        0x0A38 => (Some(Consonant), None),                       // Sa

2624

        0x0A39 => (Some(Consonant), None),                       // Ha

2625

        0x0A3A => (None, None),                                  // unassigned

2626

        0x0A3B => (None, None),                                  // unassigned

2627

        0x0A3C => (Some(Nukta), Some(BottomPosition)),           // Nukta

2628

        0x0A3D => (None, None),                                  // unassigned

2629

        0x0A3E => (Some(VowelDependent), Some(RightPosition)),   // Sign Aa

2630

        0x0A3F => (Some(VowelDependent), Some(LeftPosition)),    // Sign I

2631

        0x0A40 => (Some(VowelDependent), Some(RightPosition)),   // Sign Ii

2632

        0x0A41 => (Some(VowelDependent), Some(BottomPosition)),  // Sign U

2633

        0x0A42 => (Some(VowelDependent), Some(BottomPosition)),  // Sign Uu

2634

        0x0A43 => (None, None),                                  // unassigned

2635

        0x0A44 => (None, None),                                  // unassigned

2636

        0x0A45 => (None, None),                                  // unassigned

2637

        0x0A46 => (None, None),                                  // unassigned

2638

        0x0A47 => (Some(VowelDependent), Some(TopPosition)),     // Sign Ee

2639

        0x0A48 => (Some(VowelDependent), Some(TopPosition)),     // Sign Ai

2640

        0x0A49 => (None, None),                                  // unassigned

2641

        0x0A4A => (None, None),                                  // unassigned

2642

        0x0A4B => (Some(VowelDependent), Some(TopPosition)),     // Sign Oo

2643

        0x0A4C => (Some(VowelDependent), Some(TopPosition)),     // Sign Au

2644

        0x0A4D => (Some(Virama), Some(BottomPosition)),          // Virama

2645

        0x0A4E => (None, None),                                  // unassigned

2646

        0x0A4F => (None, None),                                  // unassigned

2647

        0x0A50 => (None, None),                                  // unassigned

2648

        0x0A51 => (Some(Cantillation), None),                    // Udaat

2649

        0x0A52 => (None, None),                                  // unassigned

2650

        0x0A53 => (None, None),                                  // unassigned

2651

        0x0A54 => (None, None),                                  // unassigned

2652

        0x0A55 => (None, None),                                  // unassigned

2653

        0x0A56 => (None, None),                                  // unassigned

2654

        0x0A57 => (None, None),                                  // unassigned

2655

        0x0A58 => (None, None),                                  // unassigned

2656

        0x0A59 => (Some(Consonant), None),                       // Khha

2657

        0x0A5A => (Some(Consonant), None),                       // Ghha

2658

        0x0A5B => (Some(Consonant), None),                       // Za

2659

        0x0A5C => (Some(Consonant), None),                       // Rra

2660

        0x0A5D => (None, None),                                  // unassigned

2661

        0x0A5E => (Some(Consonant), None),                       // Fa

2662

        0x0A5F => (None, None),                                  // unassigned

2663

        0x0A60 => (None, None),                                  // unassigned

2664

        0x0A61 => (None, None),                                  // unassigned

2665

        0x0A62 => (None, None),                                  // unassigned

2666

        0x0A63 => (None, None),                                  // unassigned

2667

        0x0A64 => (None, None),                                  // unassigned

2668

        0x0A65 => (None, None),                                  // unassigned

2669

        0x0A66 => (Some(Number), None),                          // Digit Zero

2670

        0x0A67 => (Some(Number), None),                          // Digit One

2671

        0x0A68 => (Some(Number), None),                          // Digit Two

2672

        0x0A69 => (Some(Number), None),                          // Digit Three

2673

        0x0A6A => (Some(Number), None),                          // Digit Four

2674

        0x0A6B => (Some(Number), None),                          // Digit Five

2675

        0x0A6C => (Some(Number), None),                          // Digit Six

2676

        0x0A6D => (Some(Number), None),                          // Digit Seven

2677

        0x0A6E => (Some(Number), None),                          // Digit Eight

2678

        0x0A6F => (Some(Number), None),                          // Digit Nine

2679

        0x0A70 => (Some(Bindu), Some(TopPosition)),              // Tippi

2680

        0x0A71 => (Some(GeminationMark), Some(TopPosition)),     // Addak

2681

        0x0A72 => (Some(ConsonantPlaceholder), None),            // Iri

2682

        0x0A73 => (Some(ConsonantPlaceholder), None),            // Ura

2683

        0x0A74 => (None, None),                                  // Ek Onkar

2684

        0x0A75 => (Some(ConsonantMedial), Some(BottomPosition)), // Yakash

2685

        0x0A76 => (None, None),                                  // Abbreviation Sign

2686

2687

        // Gujarati character table

2688

        0x0A81 => (Some(Bindu), Some(TopPosition)),                  // Candrabindu

2689

        0x0A82 => (Some(Bindu), Some(TopPosition)),                  // Anusvara

2690

        0x0A83 => (Some(Visarga), Some(RightPosition)),              // Visarga

2691

        0x0A84 => (None, None),                                      // unassigned

2692

        0x0A85 => (Some(VowelIndependent), None),                    // A

2693

        0x0A86 => (Some(VowelIndependent), None),                    // Aa

2694

        0x0A87 => (Some(VowelIndependent), None),                    // I

2695

        0x0A88 => (Some(VowelIndependent), None),                    // Ii

2696

        0x0A89 => (Some(VowelIndependent), None),                    // U

2697

        0x0A8A => (Some(VowelIndependent), None),                    // Uu

2698

        0x0A8B => (Some(VowelIndependent), None),                    // Vocalic R

2699

        0x0A8C => (Some(VowelIndependent), None),                    // Vocalic L

2700

        0x0A8D => (Some(VowelIndependent), None),                    // Candra E

2701

        0x0A8E => (None, None),                                      // unassigned

2702

        0x0A8F => (Some(VowelIndependent), None),                    // E

2703

        0x0A90 => (Some(VowelIndependent), None),                    // Ai

2704

        0x0A91 => (Some(VowelIndependent), None),                    // Candra O

2705

        0x0A92 => (None, None),                                      // unassigned

2706

        0x0A93 => (Some(VowelIndependent), None),                    // O

2707

        0x0A94 => (Some(VowelIndependent), None),                    // Au

2708

        0x0A95 => (Some(Consonant), None),                           // Ka

2709

        0x0A96 => (Some(Consonant), None),                           // Kha

2710

        0x0A97 => (Some(Consonant), None),                           // Ga

2711

        0x0A98 => (Some(Consonant), None),                           // Gha

2712

        0x0A99 => (Some(Consonant), None),                           // Nga

2713

        0x0A9A => (Some(Consonant), None),                           // Ca

2714

        0x0A9B => (Some(Consonant), None),                           // Cha

2715

        0x0A9C => (Some(Consonant), None),                           // Ja

2716

        0x0A9D => (Some(Consonant), None),                           // Jha

2717

        0x0A9E => (Some(Consonant), None),                           // Nya

2718

        0x0A9F => (Some(Consonant), None),                           // Tta

2719

        0x0AA0 => (Some(Consonant), None),                           // Ttha

2720

        0x0AA1 => (Some(Consonant), None),                           // Dda

2721

        0x0AA2 => (Some(Consonant), None),                           // Ddha

2722

        0x0AA3 => (Some(Consonant), None),                           // Nna

2723

        0x0AA4 => (Some(Consonant), None),                           // Ta

2724

        0x0AA5 => (Some(Consonant), None),                           // Tha

2725

        0x0AA6 => (Some(Consonant), None),                           // Da

2726

        0x0AA7 => (Some(Consonant), None),                           // Dha

2727

        0x0AA8 => (Some(Consonant), None),                           // Na

2728

        0x0AA9 => (None, None),                                      // unassigned

2729

        0x0AAA => (Some(Consonant), None),                           // Pa

2730

        0x0AAB => (Some(Consonant), None),                           // Pha

2731

        0x0AAC => (Some(Consonant), None),                           // Ba

2732

        0x0AAD => (Some(Consonant), None),                           // Bha

2733

        0x0AAE => (Some(Consonant), None),                           // Ma

2734

        0x0AAF => (Some(Consonant), None),                           // Ya

2735

        0x0AB0 => (Some(Consonant), None),                           // Ra

2736

        0x0AB1 => (None, None),                                      // unassigned

2737

        0x0AB2 => (Some(Consonant), None),                           // La

2738

        0x0AB3 => (Some(Consonant), None),                           // Lla

2739

        0x0AB4 => (None, None),                                      // unassigned

2740

        0x0AB5 => (Some(Consonant), None),                           // Va

2741

        0x0AB6 => (Some(Consonant), None),                           // Sha

2742

        0x0AB7 => (Some(Consonant), None),                           // Ssa

2743

        0x0AB8 => (Some(Consonant), None),                           // Sa

2744

        0x0AB9 => (Some(Consonant), None),                           // Ha

2745

        0x0ABA => (None, None),                                      // unassigned

2746

        0x0ABB => (None, None),                                      // unassigned

2747

        0x0ABC => (Some(Nukta), Some(BottomPosition)),               // Nukta

2748

        0x0ABD => (Some(Avagraha), None),                            // Avagraha

2749

        0x0ABE => (Some(VowelDependent), Some(RightPosition)),       // Sign Aa

2750

        0x0ABF => (Some(VowelDependent), Some(LeftPosition)),        // Sign I

2751

        0x0AC0 => (Some(VowelDependent), Some(RightPosition)),       // Sign Ii

2752

        0x0AC1 => (Some(VowelDependent), Some(BottomPosition)),      // Sign U

2753

        0x0AC2 => (Some(VowelDependent), Some(BottomPosition)),      // Sign Uu

2754

        0x0AC3 => (Some(VowelDependent), Some(BottomPosition)),      // Sign Vocalic R

2755

        0x0AC4 => (Some(VowelDependent), Some(BottomPosition)),      // Sign Vocalic Rr

2756

        0x0AC5 => (Some(VowelDependent), Some(TopPosition)),         // Sign Candra E

2757

        0x0AC6 => (None, None),                                      // unassigned

2758

        0x0AC7 => (Some(VowelDependent), Some(TopPosition)),         // Sign E

2759

        0x0AC8 => (Some(VowelDependent), Some(TopPosition)),         // Sign Ai

2760

        0x0AC9 => (Some(VowelDependent), Some(TopAndRightPosition)), // Sign Candra O

2761

        0x0ACA => (None, None),                                      // unassigned

2762

        0x0ACB => (Some(VowelDependent), Some(RightPosition)),       // Sign O

2763

        0x0ACC => (Some(VowelDependent), Some(RightPosition)),       // Sign Au

2764

        0x0ACD => (Some(Virama), Some(BottomPosition)),              // Virama

2765

        0x0ACE => (None, None),                                      // unassigned

2766

        0x0ACF => (None, None),                                      // unassigned

2767

        0x0AD0 => (None, None),                                      // Om

2768

        0x0AD1 => (None, None),                                      // unassigned

2769

        0x0AD2 => (None, None),                                      // unassigned

2770

        0x0AD3 => (None, None),                                      // unassigned

2771

        0x0AD4 => (None, None),                                      // unassigned

2772

        0x0AD5 => (None, None),                                      // unassigned

2773

        0x0AD6 => (None, None),                                      // unassigned

2774

        0x0AD7 => (None, None),                                      // unassigned

2775

        0x0AD8 => (None, None),                                      // unassigned

2776

        0x0AD9 => (None, None),                                      // unassigned

2777

        0x0ADA => (None, None),                                      // unassigned

2778

        0x0ADB => (None, None),                                      // unassigned

2779

        0x0ADC => (None, None),                                      // unassigned

2780

        0x0ADD => (None, None),                                      // unassigned

2781

        0x0ADE => (None, None),                                      // unassigned

2782

        0x0ADF => (None, None),                                      // unassigned

2783

        0x0AE0 => (Some(VowelIndependent), None),                    // Vocalic Rr

2784

        0x0AE1 => (Some(VowelIndependent), None),                    // Vocalic Ll

2785

        0x0AE2 => (Some(VowelDependent), Some(BottomPosition)),      // Sign Vocalic L

2786

        0x0AE3 => (Some(VowelDependent), Some(BottomPosition)),      // Sign Vocalic Ll

2787

        0x0AE4 => (None, None),                                      // unassigned

2788

        0x0AE5 => (None, None),                                      // unassigned

2789

        0x0AE6 => (Some(Number), None),                              // Digit Zero

2790

        0x0AE7 => (Some(Number), None),                              // Digit One

2791

        0x0AE8 => (Some(Number), None),                              // Digit Two

2792

        0x0AE9 => (Some(Number), None),                              // Digit Three

2793

        0x0AEA => (Some(Number), None),                              // Digit Four

2794

        0x0AEB => (Some(Number), None),                              // Digit Five

2795

        0x0AEC => (Some(Number), None),                              // Digit Six

2796

        0x0AED => (Some(Number), None),                              // Digit Seven

2797

        0x0AEE => (Some(Number), None),                              // Digit Eight

2798

        0x0AEF => (Some(Number), None),                              // Digit Nine

2799

        0x0AF0 => (Some(Symbol), None),                              // Abbreviation

2800

        0x0AF1 => (Some(Symbol), None),                              // Rupee Sign

2801

        0x0AF2 => (None, None),                                      // unassigned

2802

        0x0AF3 => (None, None),                                      // unassigned

2803

        0x0AF4 => (None, None),                                      // unassigned

2804

        0x0AF5 => (None, None),                                      // unassigned

2805

        0x0AF6 => (None, None),                                      // unassigned

2806

        0x0AF7 => (None, None),                                      // unassigned

2807

        0x0AF8 => (None, None),                                      // unassigned

2808

        0x0AF9 => (Some(Consonant), None),                           // Zha

2809

        0x0AFA => (Some(Cantillation), Some(TopPosition)),           // Sukun

2810

        0x0AFB => (Some(Cantillation), Some(TopPosition)),           // Shadda

2811

        0x0AFC => (Some(Cantillation), Some(TopPosition)),           // Maddah

2812

        0x0AFD => (Some(Nukta), Some(TopPosition)),                  // Three-Dot Nukta Above

2813

        0x0AFE => (Some(Nukta), Some(TopPosition)),                  // Circle Nukta Above

2814

        0x0AFF => (Some(Nukta), Some(TopPosition)),                  // Two-Circle Nukta Above

2815

2816

        // Oriya character table

2817

        0x0B00 => (None, None),                                          // unassigned

2818

        0x0B01 => (Some(Bindu), Some(TopPosition)),                      // Candrabindu

2819

        0x0B02 => (Some(Bindu), Some(RightPosition)),                    // Anusvara

2820

        0x0B03 => (Some(Visarga), Some(RightPosition)),                  // Visarga

2821

        0x0B04 => (None, None),                                          // unassigned

2822

        0x0B05 => (Some(VowelIndependent), None),                        // A

2823

        0x0B06 => (Some(VowelIndependent), None),                        // Aa

2824

        0x0B07 => (Some(VowelIndependent), None),                        // I

2825

        0x0B08 => (Some(VowelIndependent), None),                        // Ii

2826

        0x0B09 => (Some(VowelIndependent), None),                        // U

2827

        0x0B0A => (Some(VowelIndependent), None),                        // Uu

2828

        0x0B0B => (Some(VowelIndependent), None),                        // Vocalic R

2829

        0x0B0C => (Some(VowelIndependent), None),                        // Vocalic L

2830

        0x0B0D => (None, None),                                          // unassigned

2831

        0x0B0E => (None, None),                                          // unassigned

2832

        0x0B0F => (Some(VowelIndependent), None),                        // E

2833

        0x0B10 => (Some(VowelIndependent), None),                        // Ai

2834

        0x0B11 => (None, None),                                          // unassigned

2835

        0x0B12 => (None, None),                                          // unassigned

2836

        0x0B13 => (Some(VowelIndependent), None),                        // O

2837

        0x0B14 => (Some(VowelIndependent), None),                        // Au

2838

        0x0B15 => (Some(Consonant), None),                               // Ka

2839

        0x0B16 => (Some(Consonant), None),                               // Kha

2840

        0x0B17 => (Some(Consonant), None),                               // Ga

2841

        0x0B18 => (Some(Consonant), None),                               // Gha

2842

        0x0B19 => (Some(Consonant), None),                               // Nga

2843

        0x0B1A => (Some(Consonant), None),                               // Ca

2844

        0x0B1B => (Some(Consonant), None),                               // Cha

2845

        0x0B1C => (Some(Consonant), None),                               // Ja

2846

        0x0B1D => (Some(Consonant), None),                               // Jha

2847

        0x0B1E => (Some(Consonant), None),                               // Nya

2848

        0x0B1F => (Some(Consonant), None),                               // Tta

2849

        0x0B20 => (Some(Consonant), None),                               // Ttha

2850

        0x0B21 => (Some(Consonant), None),                               // Dda

2851

        0x0B22 => (Some(Consonant), None),                               // Ddha

2852

        0x0B23 => (Some(Consonant), None),                               // Nna

2853

        0x0B24 => (Some(Consonant), None),                               // Ta

2854

        0x0B25 => (Some(Consonant), None),                               // Tha

2855

        0x0B26 => (Some(Consonant), None),                               // Da

2856

        0x0B27 => (Some(Consonant), None),                               // Dha

2857

        0x0B28 => (Some(Consonant), None),                               // Na

2858

        0x0B29 => (None, None),                                          // unassigned

2859

        0x0B2A => (Some(Consonant), None),                               // Pa

2860

        0x0B2B => (Some(Consonant), None),                               // Pha

2861

        0x0B2C => (Some(Consonant), None),                               // Ba

2862

        0x0B2D => (Some(Consonant), None),                               // Bha

2863

        0x0B2E => (Some(Consonant), None),                               // Ma

2864

        0x0B2F => (Some(Consonant), None),                               // Ya

2865

        0x0B30 => (Some(Consonant), None),                               // Ra

2866

        0x0B31 => (None, None),                                          // unassigned

2867

        0x0B32 => (Some(Consonant), None),                               // La

2868

        0x0B33 => (Some(Consonant), None),                               // Lla

2869

        0x0B34 => (None, None),                                          // unassigned

2870

        0x0B35 => (Some(Consonant), None),                               // Va

2871

        0x0B36 => (Some(Consonant), None),                               // Sha

2872

        0x0B37 => (Some(Consonant), None),                               // Ssa

2873

        0x0B38 => (Some(Consonant), None),                               // Sa

2874

        0x0B39 => (Some(Consonant), None),                               // Ha

2875

        0x0B3A => (None, None),                                          // unassigned

2876

        0x0B3B => (None, None),                                          // unassigned

2877

        0x0B3C => (Some(Nukta), Some(BottomPosition)),                   // Nukta

2878

        0x0B3D => (Some(Avagraha), None),                                // Avagraha

2879

        0x0B3E => (Some(VowelDependent), Some(RightPosition)),           // Sign Aa

2880

        0x0B3F => (Some(VowelDependent), Some(TopPosition)),             // Sign I

2881

        0x0B40 => (Some(VowelDependent), Some(RightPosition)),           // Sign Ii

2882

        0x0B41 => (Some(VowelDependent), Some(BottomPosition)),          // Sign U

2883

        0x0B42 => (Some(VowelDependent), Some(BottomPosition)),          // Sign Uu

2884

        0x0B43 => (Some(VowelDependent), Some(BottomPosition)),          // Sign Vocalic R

2885

        0x0B44 => (Some(VowelDependent), Some(BottomPosition)),          // Sign Vocalic Rr

2886

        0x0B45 => (None, None),                                          // unassigned

2887

        0x0B46 => (None, None),                                          // unassigned

2888

        0x0B47 => (Some(VowelDependent), Some(LeftPosition)),            // Sign E

2889

        0x0B48 => (Some(VowelDependent), Some(TopAndLeftPosition)),      // Sign Ai

2890

        0x0B49 => (None, None),                                          // unassigned

2891

        0x0B4A => (None, None),                                          // unassigned

2892

        0x0B4B => (Some(VowelDependent), Some(LeftAndRightPosition)),    // Sign O

2893

        0x0B4C => (Some(VowelDependent), Some(TopLeftAndRightPosition)), // Sign Au

2894

        0x0B4D => (Some(Virama), Some(BottomPosition)),                  // Virama

2895

        0x0B4E => (None, None),                                          // unassigned

2896

        0x0B4F => (None, None),                                          // unassigned

2897

        0x0B50 => (None, None),                                          // unassigned

2898

        0x0B51 => (None, None),                                          // unassigned

2899

        0x0B52 => (None, None),                                          // unassigned

2900

        0x0B53 => (None, None),                                          // unassigned

2901

        0x0B54 => (None, None),                                          // unassigned

2902

        0x0B55 => (None, None),                                          // unassigned

2903

        0x0B56 => (Some(VowelDependent), Some(TopPosition)),             // Ai Length Mark

2904

        0x0B57 => (Some(VowelDependent), Some(TopAndRightPosition)),     // Au Length Mark

2905

        0x0B58 => (None, None),                                          // unassigned

2906

        0x0B59 => (None, None),                                          // unassigned

2907

        0x0B5A => (None, None),                                          // unassigned

2908

        0x0B5B => (None, None),                                          // unassigned

2909

        0x0B5C => (Some(Consonant), None),                               // Rra

2910

        0x0B5D => (Some(Consonant), None),                               // Rha

2911

        0x0B5E => (None, None),                                          // unassigned

2912

        0x0B5F => (Some(Consonant), None),                               // Yya

2913

        0x0B60 => (Some(VowelIndependent), None),                        // Vocalic Rr

2914

        0x0B61 => (Some(VowelIndependent), None),                        // Vocalic Ll

2915

        0x0B62 => (Some(VowelDependent), Some(BottomPosition)),          // Sign Vocalic L

2916

        0x0B63 => (Some(VowelDependent), Some(BottomPosition)),          // Sign Vocalic Ll

2917

        0x0B64 => (None, None),                                          // unassigned

2918

        0x0B65 => (None, None),                                          // unassigned

2919

        0x0B66 => (Some(Number), None),                                  // Digit Zero

2920

        0x0B67 => (Some(Number), None),                                  // Digit One

2921

        0x0B68 => (Some(Number), None),                                  // Digit Two

2922

        0x0B69 => (Some(Number), None),                                  // Digit Three

2923

        0x0B6A => (Some(Number), None),                                  // Digit Four

2924

        0x0B6B => (Some(Number), None),                                  // Digit Five

2925

        0x0B6C => (Some(Number), None),                                  // Digit Six

2926

        0x0B6D => (Some(Number), None),                                  // Digit Seven

2927

        0x0B6E => (Some(Number), None),                                  // Digit Eight

2928

        0x0B6F => (Some(Number), None),                                  // Digit Nine

2929

        0x0B70 => (Some(Symbol), None),                                  // Isshar

2930

        0x0B71 => (Some(Consonant), None),                               // Wa

2931

        0x0B72 => (Some(Number), None),                                  // Fraction 1/4

2932

        0x0B73 => (Some(Number), None),                                  // Fraction 1/2

2933

        0x0B74 => (Some(Number), None),                                  // Fraction 3/4

2934

        0x0B75 => (Some(Number), None),                                  // Fraction 1/16

2935

        0x0B76 => (Some(Number), None),                                  // Fraction 1/8

2936

        0x0B77 => (Some(Number), None),                                  // Fraction 3/16

2937

        0x0B78 => (None, None),                                          // unassigned

2938

        0x0B79 => (None, None),                                          // unassigned

2939

        0x0B7A => (None, None),                                          // unassigned

2940

        0x0B7B => (None, None),                                          // unassigned

2941

        0x0B7C => (None, None),                                          // unassigned

2942

        0x0B7D => (None, None),                                          // unassigned

2943

        0x0B7E => (None, None),                                          // unassigned

2944

        0x0B7F => (None, None),                                          // unassigned

2945

2946

        // Tamil character table

2947

        0x0B80 => (None, None),                                       // unassigned

2948

        0x0B81 => (None, None),                                       // unassigned

2949

        0x0B82 => (Some(Bindu), Some(TopPosition)),                   // Anusvara

2950

        0x0B83 => (Some(ModifyingLetter), None),                      // Visarga

2951

        0x0B84 => (None, None),                                       // unassigned

2952

        0x0B85 => (Some(VowelIndependent), None),                     // A

2953

        0x0B86 => (Some(VowelIndependent), None),                     // Aa

2954

        0x0B87 => (Some(VowelIndependent), None),                     // I

2955

        0x0B88 => (Some(VowelIndependent), None),                     // Ii

2956

        0x0B89 => (Some(VowelIndependent), None),                     // U

2957

        0x0B8A => (Some(VowelIndependent), None),                     // Uu

2958

        0x0B8B => (None, None),                                       // unassigned

2959

        0x0B8C => (None, None),                                       // unassigned

2960

        0x0B8D => (None, None),                                       // unassigned

2961

        0x0B8E => (Some(VowelIndependent), None),                     // E

2962

        0x0B8F => (Some(VowelIndependent), None),                     // Ee

2963

        0x0B90 => (Some(VowelIndependent), None),                     // Ai

2964

        0x0B91 => (None, None),                                       // unassigned

2965

        0x0B92 => (Some(VowelIndependent), None),                     // O

2966

        0x0B93 => (Some(VowelIndependent), None),                     // Oo

2967

        0x0B94 => (Some(VowelIndependent), None),                     // Au

2968

        0x0B95 => (Some(Consonant), None),                            // Ka

2969

        0x0B96 => (None, None),                                       // unassigned

2970

        0x0B97 => (None, None),                                       // unassigned

2971

        0x0B98 => (None, None),                                       // unassigned

2972

        0x0B99 => (Some(Consonant), None),                            // Nga

2973

        0x0B9A => (Some(Consonant), None),                            // Ca

2974

        0x0B9B => (None, None),                                       // unassigned

2975

        0x0B9C => (Some(Consonant), None),                            // Ja

2976

        0x0B9D => (None, None),                                       // unassigned

2977

        0x0B9E => (Some(Consonant), None),                            // Nya

2978

        0x0B9F => (Some(Consonant), None),                            // Tta

2979

        0x0BA0 => (None, None),                                       // unassigned

2980

        0x0BA1 => (None, None),                                       // unassigned

2981

        0x0BA2 => (None, None),                                       // unassigned

2982

        0x0BA3 => (Some(Consonant), None),                            // Nna

2983

        0x0BA4 => (Some(Consonant), None),                            // Ta

2984

        0x0BA5 => (None, None),                                       // unassigned

2985

        0x0BA6 => (None, None),                                       // unassigned

2986

        0x0BA7 => (None, None),                                       // unassigned

2987

        0x0BA8 => (Some(Consonant), None),                            // Na

2988

        0x0BA9 => (Some(Consonant), None),                            // Nnna

2989

        0x0BAA => (Some(Consonant), None),                            // Pa

2990

        0x0BAB => (None, None),                                       // unassigned

2991

        0x0BAC => (None, None),                                       // unassigned

2992

        0x0BAD => (None, None),                                       // unassigned

2993

        0x0BAE => (Some(Consonant), None),                            // Ma

2994

        0x0BAF => (Some(Consonant), None),                            // Ya

2995

        0x0BB0 => (Some(Consonant), None),                            // Ra

2996

        0x0BB1 => (Some(Consonant), None),                            // Rra

2997

        0x0BB2 => (Some(Consonant), None),                            // La

2998

        0x0BB3 => (Some(Consonant), None),                            // Lla

2999

        0x0BB4 => (Some(Consonant), None),                            // Llla

3000

        0x0BB5 => (Some(Consonant), None),                            // Va

3001

        0x0BB6 => (Some(Consonant), None),                            // Sha

3002

        0x0BB7 => (Some(Consonant), None),                            // Ssa

3003

        0x0BB8 => (Some(Consonant), None),                            // Sa

3004

        0x0BB9 => (Some(Consonant), None),                            // Ha

3005

        0x0BBA => (None, None),                                       // unassigned

3006

        0x0BBB => (None, None),                                       // unassigned

3007

        0x0BBC => (None, None),                                       // unassigned

3008

        0x0BBD => (None, None),                                       // unassigned

3009

        0x0BBE => (Some(VowelDependent), Some(RightPosition)),        // Sign Aa

3010

        0x0BBF => (Some(VowelDependent), Some(RightPosition)),        // Sign I

3011

        0x0BC0 => (Some(VowelDependent), Some(TopPosition)),          // Sign Ii

3012

        0x0BC1 => (Some(VowelDependent), Some(RightPosition)),        // Sign U

3013

        0x0BC2 => (Some(VowelDependent), Some(RightPosition)),        // Sign Uu

3014

        0x0BC3 => (None, None),                                       // unassigned

3015

        0x0BC4 => (None, None),                                       // unassigned

3016

        0x0BC5 => (None, None),                                       // unassigned

3017

        0x0BC6 => (Some(VowelDependent), Some(LeftPosition)),         // Sign E

3018

        0x0BC7 => (Some(VowelDependent), Some(LeftPosition)),         // Sign Ee

3019

        0x0BC8 => (Some(VowelDependent), Some(LeftPosition)),         // Sign Ai

3020

        0x0BC9 => (None, None),                                       // unassigned

3021

        0x0BCA => (Some(VowelDependent), Some(LeftAndRightPosition)), // Sign O

3022

        0x0BCB => (Some(VowelDependent), Some(LeftAndRightPosition)), // Sign Oo

3023

        0x0BCC => (Some(VowelDependent), Some(LeftAndRightPosition)), // Sign Au

3024

        0x0BCD => (Some(Virama), Some(TopPosition)),                  // Virama

3025

        0x0BCE => (None, None),                                       // unassigned

3026

        0x0BCF => (None, None),                                       // unassigned

3027

        0x0BD0 => (None, None),                                       // Om

3028

        0x0BD1 => (None, None),                                       // unassigned

3029

        0x0BD2 => (None, None),                                       // unassigned

3030

        0x0BD3 => (None, None),                                       // unassigned

3031

        0x0BD4 => (None, None),                                       // unassigned

3032

        0x0BD5 => (None, None),                                       // unassigned

3033

        0x0BD6 => (None, None),                                       // unassigned

3034

        0x0BD7 => (Some(VowelDependent), Some(RightPosition)),        // Au Length Mark

3035

        0x0BD8 => (None, None),                                       // unassigned

3036

        0x0BD9 => (None, None),                                       // unassigned

3037

        0x0BDA => (None, None),                                       // unassigned

3038

        0x0BDB => (None, None),                                       // unassigned

3039

        0x0BDC => (None, None),                                       // unassigned

3040

        0x0BDD => (None, None),                                       // unassigned

3041

        0x0BDE => (None, None),                                       // unassigned

3042

        0x0BDF => (None, None),                                       // unassigned

3043

        0x0BE0 => (None, None),                                       // unassigned

3044

        0x0BE1 => (None, None),                                       // unassigned

3045

        0x0BE2 => (None, None),                                       // unassigned

3046

        0x0BE3 => (None, None),                                       // unassigned

3047

        0x0BE4 => (None, None),                                       // unassigned

3048

        0x0BE5 => (None, None),                                       // unassigned

3049

        0x0BE6 => (Some(Number), None),                               // Digit Zero

3050

        0x0BE7 => (Some(Number), None),                               // Digit One

3051

        0x0BE8 => (Some(Number), None),                               // Digit Two

3052

        0x0BE9 => (Some(Number), None),                               // Digit Three

3053

        0x0BEA => (Some(Number), None),                               // Digit Four

3054

        0x0BEB => (Some(Number), None),                               // Digit Five

3055

        0x0BEC => (Some(Number), None),                               // Digit Six

3056

        0x0BED => (Some(Number), None),                               // Digit Seven

3057

        0x0BEE => (Some(Number), None),                               // Digit Eight

3058

        0x0BEF => (Some(Number), None),                               // Digit Nine

3059

        0x0BF0 => (Some(Number), None),                               // Number Ten

3060

        0x0BF1 => (Some(Number), None),                               // Number One Hundred

3061

        0x0BF2 => (Some(Number), None),                               // Number One Thousand

3062

        0x0BF3 => (Some(Symbol), None),                               // Day Sign

3063

        0x0BF4 => (Some(Symbol), None),                               // Month Sign

3064

        0x0BF5 => (Some(Symbol), None),                               // Year Sign

3065

        0x0BF6 => (Some(Symbol), None),                               // Debit Sign

3066

        0x0BF7 => (Some(Symbol), None),                               // Credit Sign

3067

        0x0BF8 => (Some(Symbol), None),                               // As Above Sign

3068

        0x0BF9 => (Some(Symbol), None),                               // Tamil Rupee Sign

3069

        0x0BFA => (Some(Symbol), None),                               // Number Sign

3070

3071

        // Telugu character table

3072

        0x0C00 => (Some(Bindu), Some(TopPosition)),                   // Combining Candrabindu Above

3073

        0x0C01 => (Some(Bindu), Some(RightPosition)),                 // Candrabindu

3074

        0x0C02 => (Some(Bindu), Some(RightPosition)),                 // Anusvara

3075

        0x0C03 => (Some(Visarga), Some(RightPosition)),               // Visarga

3076

        0x0C04 => (Some(Bindu), Some(TopPosition)),                   // Combining Anusvara Above

3077

        0x0C05 => (Some(VowelIndependent), None),                     // A

3078

        0x0C06 => (Some(VowelIndependent), None),                     // Aa

3079

        0x0C07 => (Some(VowelIndependent), None),                     // I

3080

        0x0C08 => (Some(VowelIndependent), None),                     // Ii

3081

        0x0C09 => (Some(VowelIndependent), None),                     // U

3082

        0x0C0A => (Some(VowelIndependent), None),                     // Uu

3083

        0x0C0B => (Some(VowelIndependent), None),                     // Vocalic R

3084

        0x0C0C => (Some(VowelIndependent), None),                     // Vocalic L

3085

        0x0C0D => (None, None),                                       // unassigned

3086

        0x0C0E => (Some(VowelIndependent), None),                     // E

3087

        0x0C0F => (Some(VowelIndependent), None),                     // Ee

3088

        0x0C10 => (Some(VowelIndependent), None),                     // Ai

3089

        0x0C11 => (None, None),                                       // unassigned

3090

        0x0C12 => (Some(VowelIndependent), None),                     // O

3091

        0x0C13 => (Some(VowelIndependent), None),                     // Oo

3092

        0x0C14 => (Some(VowelIndependent), None),                     // Au

3093

        0x0C15 => (Some(Consonant), None),                            // Ka

3094

        0x0C16 => (Some(Consonant), None),                            // Kha

3095

        0x0C17 => (Some(Consonant), None),                            // Ga

3096

        0x0C18 => (Some(Consonant), None),                            // Gha

3097

        0x0C19 => (Some(Consonant), None),                            // Nga

3098

        0x0C1A => (Some(Consonant), None),                            // Ca

3099

        0x0C1B => (Some(Consonant), None),                            // Cha

3100

        0x0C1C => (Some(Consonant), None),                            // Ja

3101

        0x0C1D => (Some(Consonant), None),                            // Jha

3102

        0x0C1E => (Some(Consonant), None),                            // Nya

3103

        0x0C1F => (Some(Consonant), None),                            // Tta

3104

        0x0C20 => (Some(Consonant), None),                            // Ttha

3105

        0x0C21 => (Some(Consonant), None),                            // Dda

3106

        0x0C22 => (Some(Consonant), None),                            // Ddha

3107

        0x0C23 => (Some(Consonant), None),                            // Nna

3108

        0x0C24 => (Some(Consonant), None),                            // Ta

3109

        0x0C25 => (Some(Consonant), None),                            // Tha

3110

        0x0C26 => (Some(Consonant), None),                            // Da

3111

        0x0C27 => (Some(Consonant), None),                            // Dha

3112

        0x0C28 => (Some(Consonant), None),                            // Na

3113

        0x0C29 => (None, None),                                       // unassigned

3114

        0x0C2A => (Some(Consonant), None),                            // Pa

3115

        0x0C2B => (Some(Consonant), None),                            // Pha

3116

        0x0C2C => (Some(Consonant), None),                            // Ba

3117

        0x0C2D => (Some(Consonant), None),                            // Bha

3118

        0x0C2E => (Some(Consonant), None),                            // Ma

3119

        0x0C2F => (Some(Consonant), None),                            // Ya

3120

        0x0C30 => (Some(Consonant), None),                            // Ra

3121

        0x0C31 => (Some(Consonant), None),                            // Rra

3122

        0x0C32 => (Some(Consonant), None),                            // La

3123

        0x0C33 => (Some(Consonant), None),                            // Lla

3124

        0x0C34 => (Some(Consonant), None),                            // Llla

3125

        0x0C35 => (Some(Consonant), None),                            // Va

3126

        0x0C36 => (Some(Consonant), None),                            // Sha

3127

        0x0C37 => (Some(Consonant), None),                            // Ssa

3128

        0x0C38 => (Some(Consonant), None),                            // Sa

3129

        0x0C39 => (Some(Consonant), None),                            // Ha

3130

        0x0C3A => (None, None),                                       // unassigned

3131

        0x0C3B => (None, None),                                       // unassigned

3132

        0x0C3C => (Some(Nukta), Some(BottomPosition)),                // Nukta

3133

        0x0C3D => (Some(Avagraha), None),                             // Avagraha

3134

        0x0C3E => (Some(VowelDependent), Some(TopPosition)),          // Sign Aa

3135

        0x0C3F => (Some(VowelDependent), Some(TopPosition)),          // Sign I

3136

        0x0C40 => (Some(VowelDependent), Some(TopPosition)),          // Sign Ii

3137

        0x0C41 => (Some(VowelDependent), Some(RightPosition)),        // Sign U

3138

        0x0C42 => (Some(VowelDependent), Some(RightPosition)),        // Sign Uu

3139

        0x0C43 => (Some(VowelDependent), Some(RightPosition)),        // Sign Vocalic R

3140

        0x0C44 => (Some(VowelDependent), Some(RightPosition)),        // Sign Vocalic Rr

3141

        0x0C45 => (None, None),                                       // unassigned

3142

        0x0C46 => (Some(VowelDependent), Some(TopPosition)),          // Sign E

3143

        0x0C47 => (Some(VowelDependent), Some(TopPosition)),          // Sign Ee

3144

        0x0C48 => (Some(VowelDependent), Some(TopAndBottomPosition)), // Sign Ai

3145

        0x0C49 => (None, None),                                       // unassigned

3146

        0x0C4A => (Some(VowelDependent), Some(TopPosition)),          // Sign O

3147

        0x0C4B => (Some(VowelDependent), Some(TopPosition)),          // Sign Oo

3148

        0x0C4C => (Some(VowelDependent), Some(TopPosition)),          // Sign Au

3149

        0x0C4D => (Some(Virama), Some(TopPosition)),                  // Virama

3150

        0x0C4E => (None, None),                                       // unassigned

3151

        0x0C4F => (None, None),                                       // unassigned

3152

        0x0C50 => (None, None),                                       // unassigned

3153

        0x0C51 => (None, None),                                       // unassigned

3154

        0x0C52 => (None, None),                                       // unassigned

3155

        0x0C53 => (None, None),                                       // unassigned

3156

        0x0C54 => (None, None),                                       // unassigned

3157

        0x0C55 => (Some(VowelDependent), Some(TopPosition)),          // Length Mark

3158

        0x0C56 => (Some(VowelDependent), Some(BottomPosition)),       // Ai Length Mark

3159

        0x0C57 => (None, None),                                       // unassigned

3160

        0x0C58 => (Some(Consonant), None),                            // Tsa

3161

        0x0C59 => (Some(Consonant), None),                            // Dza

3162

        0x0C5A => (Some(Consonant), None),                            // Rrra

3163

        0x0C5B => (None, None),                                       // unassigned

3164

        0x0C5C => (None, None),                                       // unassigned

3165

        0x0C5D => (Some(ConsonantDead), None),                        // Nakaara Pollu

3166

        0x0C5E => (None, None),                                       // unassigned

3167

        0x0C5F => (None, None),                                       // unassigned

3168

        0x0C60 => (Some(VowelIndependent), None),                     // Vocalic Rr

3169

        0x0C61 => (Some(VowelIndependent), None),                     // Vocalic Ll

3170

        0x0C62 => (Some(VowelDependent), Some(BottomPosition)),       // Sign Vocalic L

3171

        0x0C63 => (Some(VowelDependent), Some(BottomPosition)),       // Sign Vocalic Ll

3172

        0x0C64 => (None, None),                                       // unassigned

3173

        0x0C65 => (None, None),                                       // unassigned

3174

        0x0C66 => (Some(Number), None),                               // Digit Zero

3175

        0x0C67 => (Some(Number), None),                               // Digit One

3176

        0x0C68 => (Some(Number), None),                               // Digit Two

3177

        0x0C69 => (Some(Number), None),                               // Digit Three

3178

        0x0C6A => (Some(Number), None),                               // Digit Four

3179

        0x0C6B => (Some(Number), None),                               // Digit Five

3180

        0x0C6C => (Some(Number), None),                               // Digit Six

3181

        0x0C6D => (Some(Number), None),                               // Digit Seven

3182

        0x0C6E => (Some(Number), None),                               // Digit Eight

3183

        0x0C6F => (Some(Number), None),                               // Digit Nine

3184

        0x0C70 => (None, None),                                       // unassigned

3185

        0x0C71 => (None, None),                                       // unassigned

3186

        0x0C72 => (None, None),                                       // unassigned

3187

        0x0C73 => (None, None),                                       // unassigned

3188

        0x0C74 => (None, None),                                       // unassigned

3189

        0x0C75 => (None, None),                                       // unassigned

3190

        0x0C76 => (None, None),                                       // unassigned

3191

        0x0C77 => (None, None),                                       // unassigned

3192

        0x0C78 => (Some(Number), None),                               // Fraction Zero Odd P

3193

        0x0C79 => (Some(Number), None),                               // Fraction One Odd P

3194

        0x0C7A => (Some(Number), None),                               // Fraction Two Odd P

3195

        0x0C7B => (Some(Number), None),                               // Fraction Three Odd P

3196

        0x0C7C => (Some(Number), None),                               // Fraction One Even P

3197

        0x0C7D => (Some(Number), None),                               // Fraction Two Even P

3198

        0x0C7E => (Some(Number), None),                               // Fraction Three Even P

3199

        0x0C7F => (Some(Symbol), None),                               // Tuumu

3200

3201

        // Kannada character table

3202

        0x0C80 => (None, None),                                      // Spacing Candrabindu

3203

        0x0C81 => (Some(Bindu), Some(TopPosition)),                  // Candrabindu

3204

        0x0C82 => (Some(Bindu), Some(RightPosition)),                // Anusvara

3205

        0x0C83 => (Some(Visarga), Some(RightPosition)),              // Visarga

3206

        0x0C84 => (None, None),                                      // Siddham

3207

        0x0C85 => (Some(VowelIndependent), None),                    // A

3208

        0x0C86 => (Some(VowelIndependent), None),                    // Aa

3209

        0x0C87 => (Some(VowelIndependent), None),                    // I

3210

        0x0C88 => (Some(VowelIndependent), None),                    // Ii

3211

        0x0C89 => (Some(VowelIndependent), None),                    // U

3212

        0x0C8A => (Some(VowelIndependent), None),                    // Uu

3213

        0x0C8B => (Some(VowelIndependent), None),                    // Vocalic R

3214

        0x0C8C => (Some(VowelIndependent), None),                    // Vocalic L

3215

        0x0C8D => (None, None),                                      // unassigned

3216

        0x0C8E => (Some(VowelIndependent), None),                    // E

3217

        0x0C8F => (Some(VowelIndependent), None),                    // Ee

3218

        0x0C90 => (Some(VowelIndependent), None),                    // Ai

3219

        0x0C91 => (None, None),                                      // unassigned

3220

        0x0C92 => (Some(VowelIndependent), None),                    // O

3221

        0x0C93 => (Some(VowelIndependent), None),                    // Oo

3222

        0x0C94 => (Some(VowelIndependent), None),                    // Au

3223

        0x0C95 => (Some(Consonant), None),                           // Ka

3224

        0x0C96 => (Some(Consonant), None),                           // Kha

3225

        0x0C97 => (Some(Consonant), None),                           // Ga

3226

        0x0C98 => (Some(Consonant), None),                           // Gha

3227

        0x0C99 => (Some(Consonant), None),                           // Nga

3228

        0x0C9A => (Some(Consonant), None),                           // Ca

3229

        0x0C9B => (Some(Consonant), None),                           // Cha

3230

        0x0C9C => (Some(Consonant), None),                           // Ja

3231

        0x0C9D => (Some(Consonant), None),                           // Jha

3232

        0x0C9E => (Some(Consonant), None),                           // Nya

3233

        0x0C9F => (Some(Consonant), None),                           // Tta

3234

        0x0CA0 => (Some(Consonant), None),                           // Ttha

3235

        0x0CA1 => (Some(Consonant), None),                           // Dda

3236

        0x0CA2 => (Some(Consonant), None),                           // Ddha

3237

        0x0CA3 => (Some(Consonant), None),                           // Nna

3238

        0x0CA4 => (Some(Consonant), None),                           // Ta

3239

        0x0CA5 => (Some(Consonant), None),                           // Tha

3240

        0x0CA6 => (Some(Consonant), None),                           // Da

3241

        0x0CA7 => (Some(Consonant), None),                           // Dha

3242

        0x0CA8 => (Some(Consonant), None),                           // Na

3243

        0x0CA9 => (None, None),                                      // unassigned

3244

        0x0CAA => (Some(Consonant), None),                           // Pa

3245

        0x0CAB => (Some(Consonant), None),                           // Pha

3246

        0x0CAC => (Some(Consonant), None),                           // Ba

3247

        0x0CAD => (Some(Consonant), None),                           // Bha

3248

        0x0CAE => (Some(Consonant), None),                           // Ma

3249

        0x0CAF => (Some(Consonant), None),                           // Ya

3250

        0x0CB0 => (Some(Consonant), None),                           // Ra

3251

        0x0CB1 => (Some(Consonant), None),                           // Rra

3252

        0x0CB2 => (Some(Consonant), None),                           // La

3253

        0x0CB3 => (Some(Consonant), None),                           // Lla

3254

        0x0CB4 => (None, None),                                      // unassigned

3255

        0x0CB5 => (Some(Consonant), None),                           // Va

3256

        0x0CB6 => (Some(Consonant), None),                           // Sha

3257

        0x0CB7 => (Some(Consonant), None),                           // Ssa

3258

        0x0CB8 => (Some(Consonant), None),                           // Sa

3259

        0x0CB9 => (Some(Consonant), None),                           // Ha

3260

        0x0CBA => (None, None),                                      // unassigned

3261

        0x0CBB => (None, None),                                      // unassigned

3262

        0x0CBC => (Some(Nukta), Some(BottomPosition)),               // Nukta

3263

        0x0CBD => (Some(Avagraha), None),                            // Avagraha

3264

        0x0CBE => (Some(VowelDependent), Some(RightPosition)),       // Sign Aa

3265

        0x0CBF => (Some(VowelDependent), Some(TopPosition)),         // Sign I

3266

        0x0CC0 => (Some(VowelDependent), Some(TopAndRightPosition)), // Sign Ii

3267

        0x0CC1 => (Some(VowelDependent), Some(RightPosition)),       // Sign U

3268

        0x0CC2 => (Some(VowelDependent), Some(RightPosition)),       // Sign Uu

3269

        0x0CC3 => (Some(VowelDependent), Some(RightPosition)),       // Sign Vocalic R

3270

        0x0CC4 => (Some(VowelDependent), Some(RightPosition)),       // Sign Vocalic Rr

3271

        0x0CC5 => (None, None),                                      // unassigned

3272

        0x0CC6 => (Some(VowelDependent), Some(TopPosition)),         // Sign E

3273

        0x0CC7 => (Some(VowelDependent), Some(TopAndRightPosition)), // Sign Ee

3274

        0x0CC8 => (Some(VowelDependent), Some(TopAndRightPosition)), // Sign Ai

3275

        0x0CC9 => (None, None),                                      // unassigned

3276

        0x0CCA => (Some(VowelDependent), Some(TopAndRightPosition)), // Sign O

3277

        0x0CCB => (Some(VowelDependent), Some(TopAndRightPosition)), // Sign Oo

3278

        0x0CCC => (Some(VowelDependent), Some(TopPosition)),         // Sign Au

3279

        0x0CCD => (Some(Virama), Some(TopPosition)),                 // Virama

3280

        0x0CCE => (None, None),                                      // unassigned

3281

        0x0CCF => (None, None),                                      // unassigned

3282

        0x0CD0 => (None, None),                                      // unassigned

3283

        0x0CD1 => (None, None),                                      // unassigned

3284

        0x0CD2 => (None, None),                                      // unassigned

3285

        0x0CD3 => (None, None),                                      // unassigned

3286

        0x0CD4 => (None, None),                                      // unassigned

3287

        0x0CD5 => (Some(VowelDependent), Some(RightPosition)),       // Length Mark

3288

        0x0CD6 => (Some(VowelDependent), Some(RightPosition)),       // Ai Length Mark

3289

        0x0CD7 => (None, None),                                      // unassigned

3290

        0x0CD8 => (None, None),                                      // unassigned

3291

        0x0CD9 => (None, None),                                      // unassigned

3292

        0x0CDA => (None, None),                                      // unassigned

3293

        0x0CDB => (None, None),                                      // unassigned

3294

        0x0CDC => (None, None),                                      // unassigned

3295

        0x0CDD => (Some(ConsonantDead), None),                       // Nakaara Pollu

3296

        0x0CDE => (Some(Consonant), None),                           // Fa

3297

        0x0CDF => (None, None),                                      // unassigned

3298

        0x0CE0 => (Some(VowelIndependent), None),                    // Vocalic Rr

3299

        0x0CE1 => (Some(VowelIndependent), None),                    // Vocalic Ll

3300

        0x0CE2 => (Some(VowelDependent), Some(BottomPosition)),      // Sign Vocalic L

3301

        0x0CE3 => (Some(VowelDependent), Some(BottomPosition)),      // Sign Vocalic Ll

3302

        0x0CE4 => (None, None),                                      // unassigned

3303

        0x0CE5 => (None, None),                                      // unassigned

3304

        0x0CE6 => (Some(Number), None),                              // Digit Zero

3305

        0x0CE7 => (Some(Number), None),                              // Digit One

3306

        0x0CE8 => (Some(Number), None),                              // Digit Two

3307

        0x0CE9 => (Some(Number), None),                              // Digit Three

3308

        0x0CEA => (Some(Number), None),                              // Digit Four

3309

        0x0CEB => (Some(Number), None),                              // Digit Five

3310

        0x0CEC => (Some(Number), None),                              // Digit Six

3311

        0x0CED => (Some(Number), None),                              // Digit Seven

3312

        0x0CEE => (Some(Number), None),                              // Digit Eight

3313

        0x0CEF => (Some(Number), None),                              // Digit Nine

3314

        0x0CF0 => (None, None),                                      // unassigned

3315

        0x0CF1 => (Some(ConsonantWithStacker), None),                // Jihvamuliya

3316

        0x0CF2 => (Some(ConsonantWithStacker), None),                // Upadhmaniya

3317

3318

        // Malayalam character table

3319

        0x0D00 => (Some(Bindu), Some(TopPosition)),                   // Combining Anusvara Above

3320

        0x0D01 => (Some(Bindu), Some(TopPosition)),                   // Candrabindu

3321

        0x0D02 => (Some(Bindu), Some(RightPosition)),                 // Anusvara

3322

        0x0D03 => (Some(Visarga), Some(RightPosition)),               // Visarga

3323

        0x0D04 => (None, None),                                       // unassigned

3324

        0x0D05 => (Some(VowelIndependent), None),                     // A

3325

        0x0D06 => (Some(VowelIndependent), None),                     // Aa

3326

        0x0D07 => (Some(VowelIndependent), None),                     // I

3327

        0x0D08 => (Some(VowelIndependent), None),                     // Ii

3328

        0x0D09 => (Some(VowelIndependent), None),                     // U

3329

        0x0D0A => (Some(VowelIndependent), None),                     // Uu

3330

        0x0D0B => (Some(VowelIndependent), None),                     // Vocalic R

3331

        0x0D0C => (Some(VowelIndependent), None),                     // Vocalic L

3332

        0x0D0D => (None, None),                                       // unassigned

3333

        0x0D0E => (Some(VowelIndependent), None),                     // E

3334

        0x0D0F => (Some(VowelIndependent), None),                     // Ee

3335

        0x0D10 => (Some(VowelIndependent), None),                     // Ai

3336

        0x0D11 => (None, None),                                       // unassigned

3337

        0x0D12 => (Some(VowelIndependent), None),                     // O

3338

        0x0D13 => (Some(VowelIndependent), None),                     // Oo

3339

        0x0D14 => (Some(VowelIndependent), None),                     // Au

3340

        0x0D15 => (Some(Consonant), None),                            // Ka

3341

        0x0D16 => (Some(Consonant), None),                            // Kha

3342

        0x0D17 => (Some(Consonant), None),                            // Ga

3343

        0x0D18 => (Some(Consonant), None),                            // Gha

3344

        0x0D19 => (Some(Consonant), None),                            // Nga

3345

        0x0D1A => (Some(Consonant), None),                            // Ca

3346

        0x0D1B => (Some(Consonant), None),                            // Cha

3347

        0x0D1C => (Some(Consonant), None),                            // Ja

3348

        0x0D1D => (Some(Consonant), None),                            // Jha

3349

        0x0D1E => (Some(Consonant), None),                            // Nya

3350

        0x0D1F => (Some(Consonant), None),                            // Tta

3351

        0x0D20 => (Some(Consonant), None),                            // Ttha

3352

        0x0D21 => (Some(Consonant), None),                            // Dda

3353

        0x0D22 => (Some(Consonant), None),                            // Ddha

3354

        0x0D23 => (Some(Consonant), None),                            // Nna

3355

        0x0D24 => (Some(Consonant), None),                            // Ta

3356

        0x0D25 => (Some(Consonant), None),                            // Tha

3357

        0x0D26 => (Some(Consonant), None),                            // Da

3358

        0x0D27 => (Some(Consonant), None),                            // Dha

3359

        0x0D28 => (Some(Consonant), None),                            // Na

3360

        0x0D29 => (Some(Consonant), None),                            // Nnna

3361

        0x0D2A => (Some(Consonant), None),                            // Pa

3362

        0x0D2B => (Some(Consonant), None),                            // Pha

3363

        0x0D2C => (Some(Consonant), None),                            // Ba

3364

        0x0D2D => (Some(Consonant), None),                            // Bha

3365

        0x0D2E => (Some(Consonant), None),                            // Ma

3366

        0x0D2F => (Some(Consonant), None),                            // Ya

3367

        0x0D30 => (Some(Consonant), None),                            // Ra

3368

        0x0D31 => (Some(Consonant), None),                            // Rra

3369

        0x0D32 => (Some(Consonant), None),                            // La

3370

        0x0D33 => (Some(Consonant), None),                            // Lla

3371

        0x0D34 => (Some(Consonant), None),                            // Llla

3372

        0x0D35 => (Some(Consonant), None),                            // Va

3373

        0x0D36 => (Some(Consonant), None),                            // Sha

3374

        0x0D37 => (Some(Consonant), None),                            // Ssa

3375

        0x0D38 => (Some(Consonant), None),                            // Sa

3376

        0x0D39 => (Some(Consonant), None),                            // Ha

3377

        0x0D3A => (Some(Consonant), None),                            // Ttta

3378

        0x0D3B => (Some(PureKiller), Some(TopPosition)),              // Vertical Bar Virama

3379

        0x0D3C => (Some(PureKiller), Some(TopPosition)),              // Circular Virama

3380

        0x0D3D => (Some(Avagraha), None),                             // Avagraha

3381

        0x0D3E => (Some(VowelDependent), Some(RightPosition)),        // Sign Aa

3382

        0x0D3F => (Some(VowelDependent), Some(RightPosition)),        // Sign I

3383

        0x0D40 => (Some(VowelDependent), Some(RightPosition)),        // Sign Ii

3384

        0x0D41 => (Some(VowelDependent), Some(RightPosition)),        // Sign U

3385

        0x0D42 => (Some(VowelDependent), Some(RightPosition)),        // Sign Uu

3386

        0x0D43 => (Some(VowelDependent), Some(BottomPosition)),       // Sign Vocalic R

3387

        0x0D44 => (Some(VowelDependent), Some(BottomPosition)),       // Sign Vocalic Rr

3388

        0x0D45 => (None, None),                                       // unassigned

3389

        0x0D46 => (Some(VowelDependent), Some(LeftPosition)),         // Sign E

3390

        0x0D47 => (Some(VowelDependent), Some(LeftPosition)),         // Sign Ee

3391

        0x0D48 => (Some(VowelDependent), Some(LeftPosition)),         // Sign Ai

3392

        0x0D49 => (None, None),                                       // unassigned

3393

        0x0D4A => (Some(VowelDependent), Some(LeftAndRightPosition)), // Sign O

3394

        0x0D4B => (Some(VowelDependent), Some(LeftAndRightPosition)), // Sign Oo

3395

        0x0D4C => (Some(VowelDependent), Some(LeftAndRightPosition)), // Sign Au

3396

        0x0D4D => (Some(Virama), Some(TopPosition)),                  // Virama

3397

        0x0D4E => (Some(ConsonantPreRepha), None),                    // Dot Reph

3398

        0x0D4F => (Some(Symbol), None),                               // Para

3399

        0x0D50 => (None, None),                                       // unassigned

3400

        0x0D51 => (None, None),                                       // unassigned

3401

        0x0D52 => (None, None),                                       // unassigned

3402

        0x0D53 => (None, None),                                       // unassigned

3403

        0x0D54 => (Some(ConsonantDead), None),                        // Chillu M

3404

        0x0D55 => (Some(ConsonantDead), None),                        // Chillu Y

3405

        0x0D56 => (Some(ConsonantDead), None),                        // Chillu Lll

3406

        0x0D57 => (Some(VowelDependent), Some(RightPosition)),        // Au Length Mark

3407

        0x0D58 => (Some(Number), None),                               // Fraction 1/160

3408

        0x0D59 => (Some(Number), None),                               // Fraction 1/40

3409

        0x0D5A => (Some(Number), None),                               // Fraction 3/80

3410

        0x0D5B => (Some(Number), None),                               // Fraction 1/20

3411

        0x0D5C => (Some(Number), None),                               // Fraction 1/10

3412

        0x0D5D => (Some(Number), None),                               // Fraction 3/20

3413

        0x0D5E => (Some(Number), None),                               // Fraction 1/5

3414

        0x0D5F => (Some(VowelIndependent), None),                     // Archaic Ii

3415

        0x0D60 => (Some(VowelIndependent), None),                     // Vocalic Rr

3416

        0x0D61 => (Some(VowelIndependent), None),                     // Vocalic Ll

3417

        0x0D62 => (Some(VowelDependent), Some(BottomPosition)),       // Sign Vocalic L

3418

        0x0D63 => (Some(VowelDependent), Some(BottomPosition)),       // Sign Vocalic Ll

3419

        0x0D64 => (None, None),                                       // unassigned

3420

        0x0D65 => (None, None),                                       // unassigned

3421

        0x0D66 => (Some(Number), None),                               // Digit Zero

3422

        0x0D67 => (Some(Number), None),                               // Digit One

3423

        0x0D68 => (Some(Number), None),                               // Digit Two

3424

        0x0D69 => (Some(Number), None),                               // Digit Three

3425

        0x0D6A => (Some(Number), None),                               // Digit Four

3426

        0x0D6B => (Some(Number), None),                               // Digit Five

3427

        0x0D6C => (Some(Number), None),                               // Digit Six

3428

        0x0D6D => (Some(Number), None),                               // Digit Seven

3429

        0x0D6E => (Some(Number), None),                               // Digit Eight

3430

        0x0D6F => (Some(Number), None),                               // Digit Nine

3431

        0x0D70 => (Some(Number), None),                               // Number Ten

3432

        0x0D71 => (Some(Number), None),                               // Number One Hundred

3433

        0x0D72 => (Some(Number), None),                               // Number One Thousand

3434

        0x0D73 => (Some(Number), None),                               // Fraction 1/4

3435

        0x0D74 => (Some(Number), None),                               // Fraction 1/2

3436

        0x0D75 => (Some(Number), None),                               // Fraction 3/4

3437

        0x0D76 => (Some(Number), None),                               // Fraction 1/16

3438

        0x0D77 => (Some(Number), None),                               // Fraction 1/8

3439

        0x0D78 => (Some(Number), None),                               // Fraction 3/16

3440

        0x0D79 => (Some(Symbol), None),                               // Date Mark

3441

        0x0D7A => (Some(ConsonantDead), None),                        // Chillu Nn

3442

        0x0D7B => (Some(ConsonantDead), None),                        // Chillu N

3443

        0x0D7C => (Some(ConsonantDead), None),                        // Chillu Rr

3444

        0x0D7D => (Some(ConsonantDead), None),                        // Chillu L

3445

        0x0D7E => (Some(ConsonantDead), None),                        // Chillu Ll

3446

        0x0D7F => (Some(ConsonantDead), None),                        // Chillu K

3447

3448

        // Sinhala character table

3449

        0x0D80 => (None, None),                                          // unassigned

3450

        0x0D81 => (None, None),                                          // unassigned

3451

        0x0D82 => (Some(Bindu), Some(RightPosition)),                    // Anusvara

3452

        0x0D83 => (Some(Visarga), Some(RightPosition)),                  // Visarga

3453

        0x0D84 => (None, None),                                          // unassigned

3454

        0x0D85 => (Some(VowelIndependent), None),                        // A

3455

        0x0D86 => (Some(VowelIndependent), None),                        // Aa

3456

        0x0D87 => (Some(VowelIndependent), None),                        // Ae

3457

        0x0D88 => (Some(VowelIndependent), None),                        // Aae

3458

        0x0D89 => (Some(VowelIndependent), None),                        // I

3459

        0x0D8A => (Some(VowelIndependent), None),                        // Ii

3460

        0x0D8B => (Some(VowelIndependent), None),                        // U

3461

        0x0D8C => (Some(VowelIndependent), None),                        // Uu

3462

        0x0D8D => (Some(VowelIndependent), None),                        // Vocalic R

3463

        0x0D8E => (Some(VowelIndependent), None),                        // Vocalic Rr

3464

        0x0D8F => (Some(VowelIndependent), None),                        // Vocalic L

3465

        0x0D90 => (Some(VowelIndependent), None),                        // Vocalic Ll

3466

        0x0D91 => (Some(VowelIndependent), None),                        // E

3467

        0x0D92 => (Some(VowelIndependent), None),                        // Ee

3468

        0x0D93 => (Some(VowelIndependent), None),                        // Ai

3469

        0x0D94 => (Some(VowelIndependent), None),                        // O

3470

        0x0D95 => (Some(VowelIndependent), None),                        // Oo

3471

        0x0D96 => (Some(VowelIndependent), None),                        // Au

3472

        0x0D97 => (None, None),                                          // unassigned

3473

        0x0D98 => (None, None),                                          // unassigned

3474

        0x0D99 => (None, None),                                          // unassigned

3475

        0x0D9A => (Some(Consonant), None),                               // Ka

3476

        0x0D9B => (Some(Consonant), None),                               // Kha

3477

        0x0D9C => (Some(Consonant), None),                               // Ga

3478

        0x0D9D => (Some(Consonant), None),                               // Gha

3479

        0x0D9E => (Some(Consonant), None),                               // Nga

3480

        0x0D9F => (Some(Consonant), None),                               // Nnga

3481

        0x0DA0 => (Some(Consonant), None),                               // Ca

3482

        0x0DA1 => (Some(Consonant), None),                               // Cha

3483

        0x0DA2 => (Some(Consonant), None),                               // Ja

3484

        0x0DA3 => (Some(Consonant), None),                               // Jha

3485

        0x0DA4 => (Some(Consonant), None),                               // Nya

3486

        0x0DA5 => (Some(Consonant), None),                               // Jnya

3487

        0x0DA6 => (Some(Consonant), None),                               // Nyja

3488

        0x0DA7 => (Some(Consonant), None),                               // Tta

3489

        0x0DA8 => (Some(Consonant), None),                               // Ttha

3490

        0x0DA9 => (Some(Consonant), None),                               // Dda

3491

        0x0DAA => (Some(Consonant), None),                               // Ddha

3492

        0x0DAB => (Some(Consonant), None),                               // Nna

3493

        0x0DAC => (Some(Consonant), None),                               // Nndda

3494

        0x0DAD => (Some(Consonant), None),                               // Ta

3495

        0x0DAE => (Some(Consonant), None),                               // Tha

3496

        0x0DAF => (Some(Consonant), None),                               // Da

3497

        0x0DB0 => (Some(Consonant), None),                               // Dha

3498

        0x0DB1 => (Some(Consonant), None),                               // Na

3499

        0x0DB2 => (None, None),                                          // unassigned

3500

        0x0DB3 => (Some(Consonant), None),                               // Nda

3501

        0x0DB4 => (Some(Consonant), None),                               // Pa

3502

        0x0DB5 => (Some(Consonant), None),                               // Pha

3503

        0x0DB6 => (Some(Consonant), None),                               // Ba

3504

        0x0DB7 => (Some(Consonant), None),                               // Bha

3505

        0x0DB8 => (Some(Consonant), None),                               // Ma

3506

        0x0DB9 => (Some(Consonant), None),                               // Mba

3507

        0x0DBA => (Some(Consonant), None),                               // Ya

3508

        0x0DBB => (Some(Consonant), None),                               // Ra

3509

        0x0DBC => (None, None),                                          // unassigned

3510

        0x0DBD => (Some(Consonant), None),                               // La

3511

        0x0DBE => (None, None),                                          // unassigned

3512

        0x0DBF => (None, None),                                          // unassigned

3513

        0x0DC0 => (Some(Consonant), None),                               // Va

3514

        0x0DC1 => (Some(Consonant), None),                               // Sha

3515

        0x0DC2 => (Some(Consonant), None),                               // Ssa

3516

        0x0DC3 => (Some(Consonant), None),                               // Sa

3517

        0x0DC4 => (Some(Consonant), None),                               // Ha

3518

        0x0DC5 => (Some(Consonant), None),                               // Lla

3519

        0x0DC6 => (Some(Consonant), None),                               // Fa

3520

        0x0DC7 => (None, None),                                          // unassigned

3521

        0x0DC8 => (None, None),                                          // unassigned

3522

        0x0DC9 => (None, None),                                          // unassigned

3523

        0x0DCA => (Some(Virama), Some(TopPosition)),                     // Virama

3524

        0x0DCB => (None, None),                                          // unassigned

3525

        0x0DCC => (None, None),                                          // unassigned

3526

        0x0DCD => (None, None),                                          // unassigned

3527

        0x0DCE => (None, None),                                          // unassigned

3528

        0x0DCF => (Some(VowelDependent), Some(RightPosition)),           // Sign Aa

3529

        0x0DD0 => (Some(VowelDependent), Some(RightPosition)),           // Sign Ae

3530

        0x0DD1 => (Some(VowelDependent), Some(RightPosition)),           // Sign Aae

3531

        0x0DD2 => (Some(VowelDependent), Some(TopPosition)),             // Sign I

3532

        0x0DD3 => (Some(VowelDependent), Some(TopPosition)),             // Sign Ii

3533

        0x0DD4 => (Some(VowelDependent), Some(BottomPosition)),          // Sign U

3534

        0x0DD5 => (None, None),                                          // unassigned

3535

        0x0DD6 => (Some(VowelDependent), Some(BottomPosition)),          // Sign Uu

3536

        0x0DD7 => (None, None),                                          // unassigned

3537

        0x0DD8 => (Some(VowelDependent), Some(RightPosition)),           // Sign Vocalic R

3538

        0x0DD9 => (Some(VowelDependent), Some(LeftPosition)),            // Sign E

3539

        0x0DDA => (Some(VowelDependent), Some(TopAndLeftPosition)),      // Sign Ee

3540

        0x0DDB => (Some(VowelDependent), Some(LeftPosition)),            // Sign Ai

3541

        0x0DDC => (Some(VowelDependent), Some(LeftAndRightPosition)),    // Sign O

3542

        0x0DDD => (Some(VowelDependent), Some(TopLeftAndRightPosition)), // Sign Oo

3543

        0x0DDE => (Some(VowelDependent), Some(LeftAndRightPosition)),    // Sign Au

3544

        0x0DDF => (Some(VowelDependent), Some(RightPosition)),           // Sign Vocalic L

3545

        0x0DE0 => (None, None),                                          // unassigned

3546

        0x0DE1 => (None, None),                                          // unassigned

3547

        0x0DE2 => (None, None),                                          // unassigned

3548

        0x0DE3 => (None, None),                                          // unassigned

3549

        0x0DE4 => (None, None),                                          // unassigned

3550

        0x0DE5 => (None, None),                                          // unassigned

3551

        0x0DE6 => (Some(Number), None),                                  // Digit Zero

3552

        0x0DE7 => (Some(Number), None),                                  // Digit One

3553

        0x0DE8 => (Some(Number), None),                                  // Digit Two

3554

        0x0DE9 => (Some(Number), None),                                  // Digit Three

3555

        0x0DEA => (Some(Number), None),                                  // Digit Four

3556

        0x0DEB => (Some(Number), None),                                  // Digit Five

3557

        0x0DEC => (Some(Number), None),                                  // Digit Six

3558

        0x0DED => (Some(Number), None),                                  // Digit Seven

3559

        0x0DEE => (Some(Number), None),                                  // Digit Eight

3560

        0x0DEF => (Some(Number), None),                                  // Digit Nine

3561

        0x0DF0 => (None, None),                                          // unassigned

3562

        0x0DF1 => (None, None),                                          // unassigned

3563

        0x0DF2 => (Some(VowelDependent), Some(RightPosition)),           // Sign Vocalic Rr

3564

        0x0DF3 => (Some(VowelDependent), Some(RightPosition)),           // Sign Vocalic Ll

3565

        0x0DF4 => (None, None),                                          // Kunddaliya

3566

        0x0DF5 => (None, None),                                          // unassigned

3567

        0x0DF6 => (None, None),                                          // unassigned

3568

        0x0DF7 => (None, None),                                          // unassigned

3569

        0x0DF8 => (None, None),                                          // unassigned

3570

        0x0DF9 => (None, None),                                          // unassigned

3571

        0x0DFA => (None, None),                                          // unassigned

3572

        0x0DFB => (None, None),                                          // unassigned

3573

        0x0DFC => (None, None),                                          // unassigned

3574

        0x0DFD => (None, None),                                          // unassigned

3575

        0x0DFE => (None, None),                                          // unassigned

3576

        0x0DFF => (None, None),                                          // unassigned

3577

3578

        // Vedic Extensions character table

3579

        0x1CD0 => (Some(Cantillation), Some(TopPosition)),    // Tone Karshana

3580

        0x1CD1 => (Some(Cantillation), Some(TopPosition)),    // Tone Shara

3581

        0x1CD2 => (Some(Cantillation), Some(TopPosition)),    // Tone Prenkha

3582

        0x1CD3 => (None, None),                               // Sign Nihshvasa

3583

        0x1CD4 => (Some(Cantillation), Some(Overstruck)),     // Tone Midline Svarita

3584

        0x1CD5 => (Some(Cantillation), Some(BottomPosition)), // Tone Aggravated Independent Svarita

3585

        0x1CD6 => (Some(Cantillation), Some(BottomPosition)), // Tone Independent Svarita

3586

        0x1CD7 => (Some(Cantillation), Some(BottomPosition)), // Tone Kathaka Independent Svarita

3587

        0x1CD8 => (Some(Cantillation), Some(BottomPosition)), // Tone Candra Below

3588

        0x1CD9 => (Some(Cantillation), Some(BottomPosition)), // Tone Kathaka Independent Svarita Schroeder

3589

        0x1CDA => (Some(Cantillation), Some(TopPosition)),    // Tone Double Svarita

3590

        0x1CDB => (Some(Cantillation), Some(TopPosition)),    // Tone Triple Svarita

3591

        0x1CDC => (Some(Cantillation), Some(BottomPosition)), // Tone Kathaka Anudatta

3592

        0x1CDD => (Some(Cantillation), Some(BottomPosition)), // Tone Dot Below

3593

        0x1CDE => (Some(Cantillation), Some(BottomPosition)), // Tone Two Dots Below

3594

        0x1CDF => (Some(Cantillation), Some(BottomPosition)), // Tone Three Dots Below

3595

        0x1CE0 => (Some(Cantillation), Some(TopPosition)),    // Tone Rigvedic Kashmiri Independent Svarita

3596

        0x1CE1 => (Some(Cantillation), Some(RightPosition)),  // Tone Atharavedic Independent Svarita

3597

        0x1CE2 => (Some(Avagraha), Some(Overstruck)),         // Sign Visarga Svarita

3598

        0x1CE3 => (None, Some(Overstruck)),                   // Sign Visarga Udatta

3599

        0x1CE4 => (None, Some(Overstruck)),                   // Sign Reversed Visarga Udatta

3600

        0x1CE5 => (None, Some(Overstruck)),                   // Sign Visarga Anudatta

3601

        0x1CE6 => (None, Some(Overstruck)),                   // Sign Reversed Visarga Anudatta

3602

        0x1CE7 => (None, Some(Overstruck)),                   // Sign Visarga Udatta With Tail

3603

        0x1CE8 => (Some(Avagraha), Some(Overstruck)),         // Sign Visarga Anudatta With Tail

3604

        0x1CE9 => (Some(Symbol), None),                       // Sign Anusvara Antargomukha

3605

        0x1CEA => (None, None),                               // Sign Anusvara Bahirgomukha

3606

        0x1CEB => (None, None),                               // Sign Anusvara Vamagomukha

3607

        0x1CEC => (Some(Symbol), None),                       // Sign Anusvara Vamagomukha With Tail

3608

        0x1CED => (Some(Avagraha), Some(BottomPosition)),     // Sign Tiryak

3609

        0x1CEE => (Some(Symbol), None),                       // Sign Hexiform Long Anusvara

3610

        0x1CEF => (None, None),                               // Sign Long Anusvara

3611

        0x1CF0 => (None, None),                               // Sign Rthang Long Anusvara

3612

        0x1CF1 => (Some(Symbol), None),                       // Sign Anusvara Ubhayato Mukha

3613

        0x1CF2 => (Some(Visarga), None),                      // Sign Ardhavisarga

3614

        0x1CF3 => (Some(Visarga), None),                      // Sign Rotated Ardhavisarga

3615

        0x1CF4 => (Some(Cantillation), Some(TopPosition)),    // Tone Candra Above

3616

        0x1CF5 => (Some(ConsonantWithStacker), None),         // Sign Jihvamuliya

3617

        0x1CF6 => (Some(ConsonantWithStacker), None),         // Sign Upadhmaniya

3618

        0x1CF7 => (None, None),                               // Sign Atikrama

3619

        0x1CF8 => (Some(Cantillation), None),                 // Tone Ring Above

3620

        0x1CF9 => (Some(Cantillation), None),                 // Tone Double Ring Above

3621

3622

        // Devanagari Extended character table

3623

        0xA8E0 => (Some(Cantillation), Some(TopPosition)),   // Combining Zero

3624

        0xA8E1 => (Some(Cantillation), Some(TopPosition)),   // Combining One

3625

        0xA8E2 => (Some(Cantillation), Some(TopPosition)),   // Combining Two

3626

        0xA8E3 => (Some(Cantillation), Some(TopPosition)),   // Combining Three

3627

        0xA8E4 => (Some(Cantillation), Some(TopPosition)),   // Combining Four

3628

        0xA8E5 => (Some(Cantillation), Some(TopPosition)),   // Combining Five

3629

        0xA8E6 => (Some(Cantillation), Some(TopPosition)),   // Combining Six

3630

        0xA8E7 => (Some(Cantillation), Some(TopPosition)),   // Combining Seven

3631

        0xA8E8 => (Some(Cantillation), Some(TopPosition)),   // Combining Eight

3632

        0xA8E9 => (Some(Cantillation), Some(TopPosition)),   // Combining Nine

3633

        0xA8EA => (Some(Cantillation), Some(TopPosition)),   // Combining A

3634

        0xA8EB => (Some(Cantillation), Some(TopPosition)),   // Combining U

3635

        0xA8EC => (Some(Cantillation), Some(TopPosition)),   // Combining Ka

3636

        0xA8ED => (Some(Cantillation), Some(TopPosition)),   // Combining Na

3637

        0xA8EE => (Some(Cantillation), Some(TopPosition)),   // Combining Pa

3638

        0xA8EF => (Some(Cantillation), Some(TopPosition)),   // Combining Ra

3639

        0xA8F0 => (Some(Cantillation), Some(TopPosition)),   // Combining Vi

3640

        0xA8F1 => (Some(Cantillation), Some(TopPosition)),   // Combining Avagraha

3641

        0xA8F2 => (Some(Bindu), None),                       // Spacing Candrabindu

3642

        0xA8F3 => (Some(Bindu), None),                       // Candrabindu Virama

3643

        0xA8F4 => (None, None),                              // Double Candrabindu Virama

3644

        0xA8F5 => (None, None),                              // Candrabindu Two

3645

        0xA8F6 => (None, None),                              // Candrabindu Three

3646

        0xA8F7 => (None, None),                              // Candrabindu Avagraha

3647

        0xA8F8 => (None, None),                              // Pushpika

3648

        0xA8F9 => (None, None),                              // Gap Filler

3649

        0xA8FA => (None, None),                              // Caret

3650

        0xA8FB => (None, None),                              // Headstroke

3651

        0xA8FC => (None, None),                              // Siddham

3652

        0xA8FD => (None, None),                              // Jain Om

3653

        0xA8FE => (Some(VowelIndependent), None),            // Ay

3654

        0xA8FF => (Some(VowelDependent), Some(TopPosition)), // Sign Ay

3655

3656

        // Sinhala Archaic Numbers character table

3657

        0x111E0 => (None, None),         // unassigned

3658

        0x111E1 => (Some(Number), None), // Archaic Digit One

3659

        0x111E2 => (Some(Number), None), // Archaic Digit Two

3660

        0x111E3 => (Some(Number), None), // Archaic Digit Three

3661

        0x111E4 => (Some(Number), None), // Archaic Digit Four

3662

        0x111E5 => (Some(Number), None), // Archaic Digit Five

3663

        0x111E6 => (Some(Number), None), // Archaic Digit Six

3664

        0x111E7 => (Some(Number), None), // Archaic Digit Seven

3665

        0x111E8 => (Some(Number), None), // Archaic Digit Eight

3666

        0x111E9 => (Some(Number), None), // Archaic Digit Nine

3667

        0x111EA => (Some(Number), None), // Archaic Number Ten

3668

        0x111EB => (Some(Number), None), // Archaic Number 20

3669

        0x111EC => (Some(Number), None), // Archaic Number 30

3670

        0x111ED => (Some(Number), None), // Archaic Number 40

3671

        0x111EE => (Some(Number), None), // Archaic Number 50

3672

        0x111EF => (Some(Number), None), // Archaic Number 60

3673

        0x111F0 => (Some(Number), None), // Archaic Number 70

3674

        0x111F1 => (Some(Number), None), // Archaic Number 80

3675

        0x111F2 => (Some(Number), None), // Archaic Number 90

3676

        0x111F3 => (Some(Number), None), // Archaic Number 100

3677

        0x111F4 => (Some(Number), None), // Archaic Number 1000

3678

        0x111F5 => (None, None),         // unassigned

3679

        0x111F6 => (None, None),         // unassigned

3680

        0x111F7 => (None, None),         // unassigned

3681

        0x111F8 => (None, None),         // unassigned

3682

        0x111F9 => (None, None),         // unassigned

3683

        0x111FA => (None, None),         // unassigned

3684

        0x111FB => (None, None),         // unassigned

3685

        0x111FC => (None, None),         // unassigned

3686

        0x111FD => (None, None),         // unassigned

3687

        0x111FE => (None, None),         // unassigned

3688

        0x111FF => (None, None),         // unassigned

3689

3690

        // Grantha marks character table

3691

        0x11301 => (Some(Bindu), Some(TopPosition)),     // Grantha Candrabindu

3692

        0x11303 => (Some(Visarga), Some(RightPosition)), // Grantha Visarga

3693

        0x1133B => (Some(Nukta), Some(BottomPosition)),  // Combining Bindu Below

3694

        0x1133C => (Some(Nukta), Some(BottomPosition)),  // Grantha Nukta

3695

3696

        // Miscellaneous character table

3697

        0x00A0 => (Some(Placeholder), None),      // No-break space

3698

        0x00B2 => (Some(SyllableModifier), None), // Superscript Two (used in Tamil)

3699

        0x00B3 => (Some(SyllableModifier), None), // Superscript Three (used in Tamil)

3700

        0x200C => (Some(NonJoiner), None),        // Zero-width non-joiner

3701

        0x200D => (Some(Joiner), None),           // Zero-width joiner

3702

        0x2010 => (Some(Placeholder), None),      // Hyphen

3703

        0x2011 => (Some(Placeholder), None),      // No-break hyphen

3704

        0x2012 => (Some(Placeholder), None),      // Figure dash

3705

        0x2013 => (Some(Placeholder), None),      // En dash

3706

        0x2014 => (Some(Placeholder), None),      // Em dash

3707

        0x2074 => (Some(SyllableModifier), None), // Superscript Four (used in Tamil)

3708

        0x2082 => (Some(SyllableModifier), None), // Subscript Two (used in Tamil)

3709

        0x2083 => (Some(SyllableModifier), None), // Subscript Three (used in Tamil)

3710

        0x2084 => (Some(SyllableModifier), None), // Subscript Four (used in Tamil)

3711

        0x25CC => (Some(DottedCircle), None),     // Dotted circle

3712

3713

        _ => (None, None),

3714

3715

3716

3717

/////////////////////////////////////////////////////////////////////////////

3718

// Unit tests

3719

/////////////////////////////////////////////////////////////////////////////

3720

3721

#[cfg(test)]

3722

mod tests {

3723

    use super::*;

3724

3725

    mod matra_pos {

3726

        use super::*;

3727

3728

        #[test]

3729

        fn test_no_canonical_decomposition_matra() {

3730

            assert_eq!(

3731

                matra_pos('\u{0AC9}', Script::Gujarati),

3732

                Some(Pos::AfterPost)

3733

);

3734

            assert_eq!(matra_pos('\u{0B57}', Script::Oriya), Some(Pos::AfterPost));

3735

3736

3737

        #[test]

3738

        fn test_non_decomposed_matra() {

3739

            // Should never happen

3740

            assert_eq!(matra_pos('\u{09CB}', Script::Bengali), None);

3741

3742

3743

        #[test]

3744

        fn test_non_matra() {

3745

            assert_eq!(matra_pos('\u{09B6}', Script::Bengali), None);

3746

3747

3748

3749

    mod move_element {

3750

        use super::*;

3751

3752

        #[test]

3753

        fn test_move_forward() {

3754

            let mut v = [1, 2, 3, 4];

3755

            move_element(&mut v, 0, 3);

3756

3757

            assert_eq!([2, 3, 4, 1], v);

3758

3759

3760

        #[test]

3761

        fn test_move_backward() {

3762

            let mut v = [1, 2, 3, 4];

3763

            move_element(&mut v, 3, 1);

3764

3765

            assert_eq!([1, 4, 2, 3], v);

3766

3767

3768

3769

    mod constrain_vowel {

3770

        use super::*;

3771

3772

        #[test]

3773

        fn test_insert_one_dotted_circle() {

3774

            let mut cs = vec!['\u{0909}', '\u{0941}'];

3775

            constrain_vowel(&mut cs);

3776

3777

            assert_eq!(vec!['\u{0909}', '\u{25CC}', '\u{0941}'], cs);

3778

3779

3780

        #[test]

3781

        fn test_insert_two_dotted_circles() {

3782

            let mut cs = vec!['\u{0909}', '\u{0941}', '\u{090F}', '\u{0945}'];

3783

            constrain_vowel(&mut cs);

3784

3785

            assert_eq!(

3786

                vec!['\u{0909}', '\u{25CC}', '\u{0941}', '\u{090F}', '\u{25CC}', '\u{0945}'],

3787

cs

3788

);

3789

3790

3791

        #[test]

3792

        fn test_insert_dotted_circle_after_reph() {

3793

            let mut cs = vec!['\u{0930}', '\u{094D}', '\u{0907}'];

3794

            constrain_vowel(&mut cs);

3795

3796

            assert_eq!(vec!['\u{0930}', '\u{094D}', '\u{25CC}', '\u{0907}'], cs);

3797

3798

3799

        #[test]

3800

        fn test_should_not_insert_dotted_circle() {

3801

            let mut cs = vec!['\u{0930}', '\u{094D}'];

3802

            constrain_vowel(&mut cs);

3803

3804

            assert_eq!(vec!['\u{0930}', '\u{094D}'], cs);

3805

3806

3807

3808

    mod decompose_matra {

3809

        use super::*;

3810

3811

        #[test]

3812

        fn test_single_decomposition() {

3813

            let mut cs = vec!['\u{09CB}'];

3814

            decompose_matra(&mut cs);

3815

3816

            assert_eq!(vec!['\u{09C7}', '\u{09BE}'], cs);

3817

3818

3819

        #[test]

3820

        fn test_double_decomposition() {

3821

            let mut cs = vec!['\u{09CB}', '\u{09CB}'];

3822

            decompose_matra(&mut cs);

3823

3824

            assert_eq!(vec!['\u{09C7}', '\u{09BE}', '\u{09C7}', '\u{09BE}'], cs);

3825

3826

3827

3828

    mod recompose_bengali_ya_nukta {

3829

        use super::*;

3830

3831

        #[test]

3832

        fn test_single_codepoint() {

3833

            let mut cs = vec!['\u{09AF}'];

3834

            recompose_bengali_ya_nukta(&mut cs);

3835

3836

            assert_eq!(vec!['\u{09AF}'], cs);

3837

3838

3839

        #[test]

3840

        fn test_ya_nukta_ya() {

3841

            let mut cs = vec!['\u{09AF}', '\u{09BC}', '\u{09AF}'];

3842

            recompose_bengali_ya_nukta(&mut cs);

3843

3844

            assert_eq!(vec!['\u{09DF}', '\u{09AF}'], cs);

3845

3846

3847

        #[test]

3848

        fn test_ya_ya_nukta() {

3849

            let mut cs = vec!['\u{09AF}', '\u{09AF}', '\u{09BC}'];

3850

            recompose_bengali_ya_nukta(&mut cs);

3851

3852

            assert_eq!(vec!['\u{09AF}', '\u{09DF}'], cs);

3853

3854

3855

3856

    mod reorder_kannada_ra_halant_zwj {

3857

        use super::*;

3858

3859

        const R: char = '\u{0CB0}';

3860

        const H: char = '\u{0CCD}';

3861

        const Z: char = '\u{200D}';

3862

3863

        #[test]

3864

        fn test_ra_halant() {

3865

            let mut cs = vec![R, H];

3866

            reorder_kannada_ra_halant_zwj(&mut cs);

3867

3868

            assert_eq!(vec![R, H], cs);

3869

3870

3871

        #[test]

3872

        fn test_ra_halant_zwj() {

3873

            let mut cs = vec![R, H, Z];

3874

            reorder_kannada_ra_halant_zwj(&mut cs);

3875

3876

            assert_eq!(vec![R, Z, H], cs);

3877

3878

3879

        #[test]

3880

        fn test_non_initial_ra_halant_zwj() {

3881

            let mut cs = vec![R, H, R, H, Z];

3882

            reorder_kannada_ra_halant_zwj(&mut cs);

3883

3884

            assert_eq!(vec![R, H, R, H, Z], cs);

3885

3886

3887