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
124
125
|
import { readFileSync } from "node:fs";
import { describe, it, expect } from "vitest";
import * as entities from "./index.js";
import legacy from "../maps/legacy.json" with { type: "json" };
const levels = ["xml", "entities"];
describe("Documents", () => {
const levelDocuments = levels
.map((name) => new URL(`../maps/${name}.json`, import.meta.url))
.map((url) => JSON.parse(readFileSync(url, "utf8")))
.map((document, index) => [index, document]);
for (const [level, document] of levelDocuments) {
describe("Decode", () => {
it(levels[level], () => {
for (const entity of Object.keys(document)) {
for (let l = level; l < levels.length; l++) {
expect(entities.decode(`&${entity};`, l)).toBe(
document[entity],
);
expect(
entities.decode(`&${entity};`, { level: l }),
).toBe(document[entity]);
}
}
});
});
describe("Decode strict", () => {
it(levels[level], () => {
for (const entity of Object.keys(document)) {
for (let l = level; l < levels.length; l++) {
expect(entities.decodeStrict(`&${entity};`, l)).toBe(
document[entity],
);
expect(
entities.decode(`&${entity};`, {
level: l,
mode: entities.DecodingMode.Strict,
}),
).toBe(document[entity]);
}
}
});
});
describe("Encode", () => {
it(levels[level], () => {
for (const entity of Object.keys(document)) {
for (let l = level; l < levels.length; l++) {
const encoded = entities.encode(document[entity], l);
const decoded = entities.decode(encoded, l);
expect(decoded).toBe(document[entity]);
}
}
});
it("should only encode non-ASCII values if asked", () =>
expect(
entities.encode("Great #'s of 🎁", {
level,
mode: entities.EncodingMode.ASCII,
}),
).toBe("Great #'s of 🎁"));
});
}
describe("Legacy", () => {
const legacyMap: Record<string, string> = legacy;
it("should decode", () => {
for (const entity of Object.keys(legacyMap)) {
expect(entities.decodeHTML(`&${entity}`)).toBe(
legacyMap[entity],
);
expect(
entities.decodeStrict(`&${entity}`, {
level: entities.EntityLevel.HTML,
mode: entities.DecodingMode.Legacy,
}),
).toBe(legacyMap[entity]);
}
});
});
});
const astral = [
["1d306", "\uD834\uDF06"],
["1d11e", "\uD834\uDD1E"],
];
const astralSpecial = [
["80", "\u20AC"],
["110000", "\uFFFD"],
];
describe("Astral entities", () => {
for (const [c, value] of astral) {
it(`should decode ${value}`, () =>
expect(entities.decode(`&#x${c};`)).toBe(value));
it(`should encode ${value}`, () =>
expect(entities.encode(value)).toBe(`&#x${c};`));
it(`should escape ${value}`, () =>
expect(entities.escape(value)).toBe(`&#x${c};`));
}
for (const [c, value] of astralSpecial) {
it(`should decode special \\u${c}`, () =>
expect(entities.decode(`&#x${c};`)).toBe(value));
}
});
describe("Escape", () => {
it("should always decode ASCII chars", () => {
for (let index = 0; index < 0x7f; index++) {
const c = String.fromCharCode(index);
expect(entities.decodeXML(entities.escape(c))).toBe(c);
}
});
it("should keep UTF8 characters", () =>
expect(entities.escapeUTF8('ß < "ü"')).toBe(`ß < "ü"`));
});
|
