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
|
import { asciiPrefix, decodeAscii, decodeLatin1 } from './latin1.js'
import encodings from './single-byte.encodings.js'
import { decode2string, nativeDecoder } from './platform.js'
export const E_STRICT = 'Input is not well-formed for this encoding'
const xUserDefined = 'x-user-defined'
const iso8i = 'iso-8859-8-i'
export const assertEncoding = (encoding) => {
if (Object.hasOwn(encodings, encoding) || encoding === xUserDefined || encoding === iso8i) return
throw new RangeError('Unsupported encoding')
}
const r = 0xff_fd
export function getEncoding(encoding) {
assertEncoding(encoding)
if (encoding === xUserDefined) return Array.from({ length: 128 }, (_, i) => 0xf7_80 + i)
if (encoding === iso8i) encoding = 'iso-8859-8'
const enc = encodings[encoding]
const deltas = enc.flatMap((x) => (Array.isArray(x) ? new Array(x[0]).fill(x[1] ?? 0) : x))
return deltas.map((x, i) => (x === r ? x : x + 128 + i))
}
const mappers = new Map()
const decoders = new Map()
const encmaps = new Map()
// Used only on Node.js, no reason to optimize for anything else
// E.g. avoiding .from and filling zero-initialized arr manually is faster on Hermes, but we avoid this codepath on Hermes completely
export function encodingMapper(encoding) {
const cached = mappers.get(encoding)
if (cached) return cached
const codes = getEncoding(encoding)
const incomplete = codes.includes(r)
let map
const mapper = (arr, start = 0) => {
if (!map) {
map = new Uint16Array(256).map((_, i) => i) // Unicode subset
map.set(Uint16Array.from(codes), 128)
}
const o = Uint16Array.from(start === 0 ? arr : arr.subarray(start)) // copy to modify in-place, also those are 16-bit now
let i = 0
for (const end7 = o.length - 7; i < end7; i += 8) {
o[i] = map[o[i]]
o[i + 1] = map[o[i + 1]]
o[i + 2] = map[o[i + 2]]
o[i + 3] = map[o[i + 3]]
o[i + 4] = map[o[i + 4]]
o[i + 5] = map[o[i + 5]]
o[i + 6] = map[o[i + 6]]
o[i + 7] = map[o[i + 7]]
}
for (const end = o.length; i < end; i++) o[i] = map[o[i]]
return o
}
mappers.set(encoding, { mapper, incomplete })
return { mapper, incomplete }
}
export function encodingDecoder(encoding) {
const cached = decoders.get(encoding)
if (cached) return cached
const isLatin1 = encoding === 'iso-8859-1'
if (isLatin1 && !nativeDecoder) return (arr, loose = false) => decodeLatin1(arr) // native decoder is faster for ascii below
let strings
const codes = getEncoding(encoding)
const incomplete = codes.includes(r)
const decoder = (arr, loose = false) => {
if (!strings) {
const allCodes = Array.from({ length: 128 }, (_, i) => i).concat(codes)
while (allCodes.length < 256) allCodes.push(allCodes.length)
strings = allCodes.map((c) => String.fromCharCode(c))
}
const prefixLen = asciiPrefix(arr)
if (prefixLen === arr.length) return decodeAscii(arr)
if (isLatin1) return decodeLatin1(arr) // TODO: check if decodeAscii with subarray is faster for small prefixes too
const prefix = decodeLatin1(arr, 0, prefixLen) // TODO: check if decodeAscii with subarray is faster for small prefixes too
const suffix = decode2string(arr, prefix.length, arr.length, strings)
if (!loose && incomplete && suffix.includes('\uFFFD')) throw new TypeError(E_STRICT)
return prefix + suffix
}
decoders.set(encoding, decoder)
return decoder
}
export function encodeMap(encoding) {
const cached = encmaps.get(encoding)
if (cached) return cached
const codes = getEncoding(encoding)
let max = 128
while (codes.length < 128) codes.push(128 + codes.length)
for (const code of codes) if (code > max && code !== r) max = code
const map = new Uint8Array(max + 1) // < 10 KiB for all except macintosh, 63 KiB for macintosh
for (let i = 0; i < 128; i++) {
map[i] = i
if (codes[i] !== r) map[codes[i]] = 128 + i
}
encmaps.set(encoding, map)
return map
}
|
