unicode-shaper 0.3.0

Shape unicode text so that renderers like WebGL and WebGPU can properly display the glyphs.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123

import fs from 'fs'

const data = fs.readFileSync('./UnicodeData.txt', 'utf8')
const lines = data.split('\n')
const types = {
    LTR: 0,
    RTL: 0,
    weak: 0,
    neutral: 0,
};
const weaks = []
const neutrals = []
const leftToRights = []
const rightToLefts = []

for (const line of lines) {
    const [hexCode,,,, bidiClass] = line.split(';')
    if (bidiClass === 'L') {
        types.LTR++
        var int = parseInt(hexCode, 16)
        leftToRights.push(int)
    } else if (bidiClass === 'R' || bidiClass === 'AL') {
        types.RTL++
        var int = parseInt(hexCode, 16)
        // rightToLefts.push(int)
        rightToLefts.push(int)
    } else if (
        bidiClass === 'EN' ||
        bidiClass === 'ES' ||
        bidiClass === 'ET' ||
        bidiClass === 'AN' ||
        bidiClass === 'CS' ||
        bidiClass === 'NSM'
    ) {
        types.weak++
        var int = parseInt(hexCode, 16)
        weaks.push(int)
    }
    else if (
        bidiClass === 'BN' ||
        bidiClass === 'B' ||
        bidiClass === 'S' ||
        bidiClass === 'WS' ||
        bidiClass === 'ON' ||
        bidiClass === 'LRE' ||
        bidiClass === 'LRO' ||
        bidiClass === 'RLE' ||
        bidiClass === 'RLO' ||
        bidiClass === 'PDF' ||
        bidiClass === 'LRI' ||
        bidiClass === 'RLI' ||
        bidiClass === 'FSI' ||
        bidiClass === 'PDI'
    ) {
        types.neutral++
        var int = parseInt(hexCode, 16)
        neutrals.push(int)
    }
}

console.log(types)

// const RTLRanges = createRanges(rightToLefts)

// console.log('RTL: ')
// console.log(RTLRanges)
// // print RTLRanges but convert the numbers to hex
// console.log(RTLRanges.map((range) => range.map((n) => {
//     var str = n.toString(16).toUpperCase()
//     while (str.length < 4) str = '0' + str
//     return '0x' + str
// })))

// const WeakRanges = createRanges(weaks)

// console.log('weak: ')
// // console.log(WeakRanges)
// // print WeakRanges but convert the numbers to hex
// var weakMap = WeakRanges.map((range) => range.map((n) => {
//     var str = n.toString(16).toUpperCase()
//     while (str.length < 4) str = '0' + str
//     return '0x' + str
// }))
// var index = weakMap.findIndex((range) => range[0] === '0xAAB0')
// weakMap = weakMap.slice(index)
// console.log(weakMap)

const NeutralRanges = createRanges(neutrals)

console.log('neutral: ')
// console.log(NeutralRanges)
// print NeutralRanges but convert the numbers to hex
var neutralMap = NeutralRanges.map((range) => range.map((n) => {
    var str = n.toString(16).toUpperCase()
    while (str.length < 4) str = '0' + str
    return '0x' + str
}));
// find the range index whose first number is '0x30A0'
var index = neutralMap.findIndex((range) => range[0] === '0x30A0')
// slice neutralMap from that index to the end
neutralMap = neutralMap.slice(index)
console.log(neutralMap)

// create a function that takes an array of numbers and returns an array of ranges
function createRanges (arr) {
    // step 1: group consecutive numbers
    const ranges = []
    let curRange = []
    for (let i = 0; i < arr.length; i++) {
        const n = arr[i]
        curRange.push(n)
        const next = arr[i + 1]
        if (next - n > 1) {
            ranges.push(curRange)
            curRange = []
        }
    }
    // step 2: convert the groups to ranges
    return ranges.map((range) => {
        if (range.length > 1) return [range[0], range[range.length - 1]]
        else return [range[0], range[0]]
    });
}