Generate the No_Block default for gaps between blocks

Assisted-By: GPT-6

Author: JLHwung

scripts/parse-blocks-scripts-properties.mjs

@@ -283,6 +283,7 @@ const parseDerivedGeneralCategory = async (version) => {
 };
 
 const parseBlocks = async (version) => {
+	let map;
 	if (
 		version === '3.0.1' ||
 		version === '3.0.0' ||
@@ -292,7 +293,7 @@ const parseBlocks = async (version) => {
 		if (!source) {
 			return;
 		}
-		const map = {};
+		map = {};
 		for (const line of source.trimEnd().split('\n')) {
 			const record = line.split('#')[0].trim();
 			if (!record) {
@@ -307,10 +308,21 @@ const parseBlocks = async (version) => {
 				parseInt(end, 16),
 			);
 		}
-		return map;
 	} else {
-		return await parseBlocksScriptsProperties('blocks', version);
+		map = await parseBlocksScriptsProperties('blocks', version);
+	}
+	if (!map) {
+		return;
 	}
+	// Block=No_Block covers every gap between the explicitly named blocks.
+	const noBlock = regenerate().addRange(0, CODEPOINT_MAX);
+	for (const [block, codePoints] of Object.entries(map)) {
+		if (block !== 'No_Block') {
+			noBlock.remove(codePoints);
+		}
+	}
+	map.No_Block = noBlock;
+	return map;
 };
 
 const parseProperties = async (version) => {

tests/parser-formats.mjs

@@ -55,10 +55,13 @@ test('Block names exclude inline comments in modern and legacy formats', async (
 	);
 	for (const version of ['3.0.1', '18.0.0']) {
 		const map = await parseBlocks(version);
-		t.assert.deepEqual(Object.keys(map), ['Basic_Latin']);
+		t.assert.deepEqual(Object.keys(map).sort(), ['Basic_Latin', 'No_Block']);
 		t.assert.ok(map.Basic_Latin.contains(0));
 		t.assert.ok(map.Basic_Latin.contains(0x7f));
 		t.assert.ok(!map.Basic_Latin.contains(0x80));
+		t.assert.ok(!map.No_Block.contains(0x7f));
+		t.assert.ok(map.No_Block.contains(0x80));
+		t.assert.ok(map.No_Block.contains(0x10ffff));
 	}
 });
 

tests/parsers.mjs

@@ -8,12 +8,37 @@ import parseDecompositionMapping from '../scripts/parse-decomposition-mapping.mj
 import parseIndicConjunctBreak from '../scripts/parse-indic-conjunct-break.mjs';
 import parseJoiningType from '../scripts/parse-joining-type.mjs';
 import {
+	parseBlocks,
 	parseDerivedCoreProperties,
 	parseDerivedNormalizationProperties,
 	parseProperties,
 	parseScripts,
 } from '../scripts/parse-blocks-scripts-properties.mjs';
 
+test('Block values cover Unicode, including No_Block gaps', async (t) => {
+	for (const version of ['2.0.14', '3.1.0', '18.0.0']) {
+		const blocks = await parseBlocks(version);
+		t.assert.ok(blocks.No_Block.contains(0x40000), version);
+		t.assert.ok(!blocks.No_Block.contains(0x41), version);
+		const ranges = Object.values(blocks)
+			.flatMap((set) => {
+				const result = [];
+				for (let i = 0; i < set.data.length; i += 2) {
+					result.push(set.data.slice(i, i + 2));
+				}
+				return result;
+			})
+			.sort((a, b) => a[0] - b[0]);
+		let end = 0;
+		for (const [start, next] of ranges) {
+			t.assert.equal(start, end, `${version}: Block must partition Unicode`);
+			end = next;
+		}
+		t.assert.equal(end, 0x110000);
+	}
+	t.assert.equal(await parseBlocks('1.1.5'), undefined);
+});
+
 test('Hangul has pairwise canonical decomposition mappings', async (t) => {
 	for (const version of ['2.0.14', '3.2.0', '18.0.0']) {
 		const { Canonical } = await parseDecompositionMapping(version);