perf: front-code the Names table

`Names/index.mjs` stored every character name as a JSON string inside
the run-length array shared with the other property maps. Names are
sorted by code point and neighbouring names share long prefixes (e.g.
`LATIN SMALL LETTER A WITH …`), so the table is now written as text: a
first line with the `[gap, length]` run pairs as JSON, followed by one
front-coded name per line (a base64 digit for the number of characters
shared with the previous name, then the remainder). The new
`decode-names.mjs` rebuilds the same `Map<number, string>`, with the
same entries in the same order; this was verified against all 35
versions, and a new test checks representative lookups.

For Unicode 18.0.0 `Names/index.mjs` shrinks from 158 KB to 123 KB, and
the package from 410 KB to 390 KB packed (1.43 MB to 1.39 MB unpacked).

Assisted-By: Claude Fable 5.1
Issue: #109

Author: JLHwung

index.mjs

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

scripts/encode-ranges.mjs

@@ -57,4 +57,4 @@ const encodeRegenerate = (regenerateSet) => {
 	return encodeDeltas(deltas);
 };
 
-export { encodeRanges, encodeRegenerate };
+export { base64enc, encodeRanges, encodeRegenerate };

scripts/utils.mjs

@@ -4,25 +4,30 @@ import { fileURLToPath } from 'node:url';
 import zlib from 'node:zlib';
 import jsesc from 'jsesc';
 import regenerate from 'regenerate';
-import { encodeRanges, encodeRegenerate } from './encode-ranges.mjs';
+import { base64enc, encodeRanges, encodeRegenerate } from './encode-ranges.mjs';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
-const brotliInline = (data) => {
-	if (data instanceof Map) {
-		return `new Map(${brotliInline([...data])})`;
-	}
-	const json = JSON.stringify(data);
-	const brotliBuffer = zlib.brotliCompressSync(json, {
+// Brotli-compress `text` and return a JS expression that decompresses it into
+// a Buffer at runtime.
+const brotliInlineBuffer = (text) => {
+	const brotliBuffer = zlib.brotliCompressSync(text, {
 		params: {
 			[zlib.constants.BROTLI_PARAM_QUALITY]: zlib.constants.BROTLI_MAX_QUALITY,
 			[zlib.constants.BROTLI_PARAM_LGWIN]:
 				zlib.constants.BROTLI_MAX_WINDOW_BITS,
-			[zlib.constants.BROTLI_PARAM_SIZE_HINT]: Buffer.byteLength(json),
+			[zlib.constants.BROTLI_PARAM_SIZE_HINT]: Buffer.byteLength(text),
 		},
 	});
 	const str = brotliBuffer.toString('base64');
-	return `JSON.parse(brotliDecompressSync(Buffer.from('${str}', 'base64')))`;
+	return `brotliDecompressSync(Buffer.from('${str}', 'base64'))`;
+};
+
+const brotliInline = (data) => {
+	if (data instanceof Map) {
+		return `new Map(${brotliInline([...data])})`;
+	}
+	return `JSON.parse(${brotliInlineBuffer(JSON.stringify(data))})`;
 };
 
 const range = (start, stop) => {
@@ -83,6 +88,30 @@ const samePropertyRuns = (codePointProperties) => {
 	return result;
 };
 
+// Front-code the names in the flat runs produced by `samePropertyRuns`.
+// See static/decode-names.mjs for the format and the decoder.
+const encodeNames = (flatRuns) => {
+	const runs = [];
+	const lines = [];
+	let previous = '';
+	for (let i = 0; i < flatRuns.length; i += 3) {
+		runs.push(flatRuns[i], flatRuns[i + 1]);
+		const name = flatRuns[i + 2];
+		let shared = 0;
+		while (
+			shared < 63 &&
+			shared < name.length &&
+			shared < previous.length &&
+			name.charCodeAt(shared) === previous.charCodeAt(shared)
+		) {
+			shared++;
+		}
+		lines.push(base64enc[shared] + name.slice(shared));
+		previous = name;
+	}
+	return JSON.stringify(runs) + '\n' + lines.join('\n');
+};
+
 // Only write the file if its content has changed.
 // Reading files is cheaper than writing files, and most files don’t change between builds.
 const writeFileIfChanged = (filePath, content) => {
@@ -304,9 +333,14 @@ const writeFiles = (options) => {
 			// or `bidi-brackets/index.mjs`
 			// or `Names/index.mjs`
 			const flatRuns = samePropertyRuns(auxMap[type]);
-			const output = `import { brotliDecompressSync } from 'node:zlib';\nimport decodePropertyMap from '../decode-property-map.mjs';\n\nexport default decodePropertyMap(${brotliInline(
-				flatRuns,
-			)});\n`;
+			const output =
+				type === 'Names'
+					? `import { brotliDecompressSync } from 'node:zlib';\nimport decodeNames from '../decode-names.mjs';\n\nexport default decodeNames(${brotliInlineBuffer(
+							encodeNames(flatRuns),
+						)}.toString());\n`
+					: `import { brotliDecompressSync } from 'node:zlib';\nimport decodePropertyMap from '../decode-property-map.mjs';\n\nexport default decodePropertyMap(${brotliInline(
+							flatRuns,
+						)});\n`;
 			writeFileIfChanged(path.resolve(dir, 'index.mjs'), output);
 			writeFileIfChanged(
 				path.resolve(dir, 'index.d.mts'),

static/decode-names.d.mts

@@ -0,0 +1,7 @@
+/**
+ * Decode a front-coded table of character names into a map from code point
+ * to name.
+ */
+declare function decodeNames(input: string): Map<number, string>;
+
+export default decodeNames;

static/decode-names.mjs

@@ -0,0 +1,40 @@
+/**
+ * This file ships to end users.
+ * See `encodeNames` in scripts/utils.mjs for the encoder.
+ */
+
+const base64enc =
+	'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_';
+
+/**
+ * Decode a front-coded table of character names into a map from code point
+ * to name.
+ *
+ * The first line of `input` is a JSON array of `[gap, length]` pairs, one per
+ * name, describing the run of code points each name applies to: `gap` is the
+ * number of unnamed code points since the end of the previous run, and
+ * `length` is the number of consecutive code points sharing the name.
+ *
+ * Every following line holds one name, front-coded against the previous
+ * name: the first character is the base64 digit for the number of leading
+ * characters shared with the previous name, and the rest is the remainder.
+ * @param {string} input
+ */
+const decodeNames = (input) => {
+	const lines = input.split('\n');
+	const runs = JSON.parse(lines[0]);
+	const map = new Map();
+	let previous = '';
+	for (let codePoint = 0, i = 1, j = 0; i < lines.length; i++, j += 2) {
+		const line = lines[i];
+		const name = previous.slice(0, base64enc.indexOf(line[0])) + line.slice(1);
+		previous = name;
+		codePoint += runs[j];
+		for (const end = codePoint + runs[j + 1]; codePoint < end; codePoint++) {
+			map.set(codePoint, name);
+		}
+	}
+	return map;
+};
+
+export default decodeNames;

tests/tests.mjs

@@ -143,6 +143,28 @@ suite(`The generated latest Unicode js`, () => {
 		);
 		t.assert.snapshot([...map.entries()]);
 	});
+	test('Names should decode to the expected names', async (t) => {
+		const { default: names } = await import(
+			`../output/unicode-${newest}/Names/index.mjs`
+		);
+		const entries = [...names];
+		t.assert.deepStrictEqual(entries[0], [0, '<control>']);
+		t.assert.strictEqual(names.get(0x41), 'LATIN CAPITAL LETTER A');
+		t.assert.strictEqual(names.get(0x4e00), 'CJK Ideograph');
+		t.assert.strictEqual(names.get(0xac00), 'Hangul Syllable');
+		t.assert.strictEqual(names.get(0xf900), 'CJK COMPATIBILITY IDEOGRAPH-F900');
+		t.assert.strictEqual(names.get(0x1f600), 'GRINNING FACE');
+		t.assert.deepStrictEqual(entries.at(-1), [
+			0x10fffd,
+			'Plane 16 Private Use',
+		]);
+		// Entries are in code point order.
+		for (let i = 1; i < entries.length; i++) {
+			if (entries[i][0] <= entries[i - 1][0]) {
+				t.assert.fail(`entry ${i} out of order`);
+			}
+		}
+	});
 	test('every mapping symbols.mjs should match code-points.mjs', async (t) => {
 		await assertSymbolsMatchCodePoints(t, newest);
 	});