perf: derive mapping symbols.mjs from code-points.mjs

For Case_Folding, Simple_Case_Mapping, Special_Casing and
Decomposition_Mapping, `symbols.mjs` shipped a second compressed copy of
the same data as `code-points.mjs`, differing only in that every code
point was replaced by its string. It now imports `code-points.mjs` and
derives the map through the new `mapping-to-symbols.mjs`. Small mappings
(fewer than 10 entries) keep their inline literals. The resulting maps
are identical, including entry order; a new test checks this for every
mapping directory.

For Unicode 18.0.0 this shrinks the package from 444 KB to 410 KB packed
(1.47 MB to 1.43 MB unpacked).

Assisted-By: Claude Fable 5.1
Issue: #109

Author: JLHwung

index.mjs

@@ -351,6 +351,8 @@ const generateData = async (version) => {
 		'decode-property-map.d.mts',
 		'decode-ranges.mjs',
 		'decode-ranges.d.mts',
+		'mapping-to-symbols.mjs',
+		'mapping-to-symbols.d.mts',
 	];
 	for (const file of staticFiles) {
 		fs.copyFileSync(

scripts/utils.mjs

@@ -215,22 +215,24 @@ const writeFiles = (options) => {
 				symbolsFileContent = `export default ${jsesc(codePointsAsArray.map((cp) => String.fromCodePoint(cp)))};\n`;
 			}
 		} else {
-			const symbols = new Map();
-			for (let [from, to] of codePoints) {
-				from = String.fromCodePoint(from);
-				if (Array.isArray(to)) {
-					to = String.fromCodePoint.apply(null, to);
-				} else {
-					to = String.fromCodePoint(to);
-				}
-				symbols.set(from, to);
-			}
 			if (codePoints.size < 10) {
+				const symbols = new Map();
+				for (let [from, to] of codePoints) {
+					from = String.fromCodePoint(from);
+					if (Array.isArray(to)) {
+						to = String.fromCodePoint.apply(null, to);
+					} else {
+						to = String.fromCodePoint(to);
+					}
+					symbols.set(from, to);
+				}
 				codePointsFileContent = `export default ${jsesc(codePoints)};\n`;
 				symbolsFileContent = `export default ${jsesc(symbols)};\n`;
 			} else {
 				codePointsFileContent = `import { brotliDecompressSync } from 'node:zlib';\n\nexport default ${brotliInline(codePoints)};\n`;
-				symbolsFileContent = `import { brotliDecompressSync } from 'node:zlib';\n\nexport default ${brotliInline(symbols)};\n`;
+				// The symbols map is derived from the code points map at runtime
+				// rather than shipped as a second copy of the same data.
+				symbolsFileContent = `import codePoints from './code-points.mjs';\nimport mappingToSymbols from '../../mapping-to-symbols.mjs';\n\nexport default mappingToSymbols(codePoints);\n`;
 			}
 			if (
 				(type === 'Case_Folding' && item === 'F') ||

static/mapping-to-symbols.d.mts

@@ -0,0 +1,9 @@
+/**
+ * Derive the symbol-to-symbol(s) map of a case mapping, case folding, or
+ * decomposition mapping from its code-point-to-code-point(s) map.
+ */
+declare function mappingToSymbols(
+	codePoints: Map<number, number | number[]>,
+): Map<string, string>;
+
+export default mappingToSymbols;

static/mapping-to-symbols.mjs

@@ -0,0 +1,25 @@
+/**
+ * This file ships to end users.
+ *
+ * Derive the symbol-to-symbol(s) map of a case mapping, case folding, or
+ * decomposition mapping from its code-point-to-code-point(s) map.
+ */
+
+const fromCodePoint = String.fromCodePoint;
+
+/**
+ * @param {Map<number, number | number[]>} codePoints
+ * @returns {Map<string, string>}
+ */
+const mappingToSymbols = (codePoints) => {
+	const symbols = new Map();
+	for (const [from, to] of codePoints) {
+		symbols.set(
+			fromCodePoint(from),
+			Array.isArray(to) ? fromCodePoint(...to) : fromCodePoint(to),
+		);
+	}
+	return symbols;
+};
+
+export default mappingToSymbols;

tests/tests.mjs

@@ -1,6 +1,11 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
 import { suite, test } from 'node:test';
 import resources from '../data/resources.mjs';
 
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
 const oldest = resources[0].version;
 const newest = resources.at(-1).version;
 
@@ -11,6 +16,38 @@ if (!process.env.CI) {
 	await generateData(newest);
 }
 
+// Every mapping `symbols.mjs` must equal its `code-points.mjs` with each code
+// point replaced by the corresponding symbol.
+const assertSymbolsMatchCodePoints = async (t, version) => {
+	const root = path.resolve(__dirname, '..', 'output', `unicode-${version}`);
+	let count = 0;
+	for (const type of [
+		'Case_Folding',
+		'Simple_Case_Mapping',
+		'Special_Casing',
+		'Decomposition_Mapping',
+	]) {
+		const typeDir = path.join(root, type);
+		if (!fs.existsSync(typeDir)) {
+			continue;
+		}
+		for (const name of fs.readdirSync(typeDir)) {
+			const dir = path.join(typeDir, name);
+			const { default: codePoints } = await import(
+				path.join(dir, 'code-points.mjs')
+			);
+			const { default: symbols } = await import(path.join(dir, 'symbols.mjs'));
+			const expected = [...codePoints].map(([from, to]) => [
+				String.fromCodePoint(from),
+				String.fromCodePoint(...(Array.isArray(to) ? to : [to])),
+			]);
+			t.assert.deepStrictEqual([...symbols], expected, `${type}/${name}`);
+			count++;
+		}
+	}
+	t.assert.ok(count > 0, 'found mapping directories');
+};
+
 suite(`The generated Unicode ${oldest} js`, () => {
 	test('General_Category/Modifier_Letter should match the snapshot', async (t) => {
 		const { default: data } = await import(
@@ -106,4 +143,7 @@ suite(`The generated latest Unicode js`, () => {
 		);
 		t.assert.snapshot([...map.entries()]);
 	});
+	test('every mapping symbols.mjs should match code-points.mjs', async (t) => {
+		await assertSymbolsMatchCodePoints(t, newest);
+	});
 });