regenerate-unicode-properties 10.2.2

Clean-room public code sample — generation instructions

Write a brand-new, minimal, self-contained code sample in this clean-room directory.
Do not copy, paraphrase, or reference any existing project source. Work only from this spec.

A csx.json manifest scaffold already exists. Do not recreate it from memory. Preserve its case.goal, packages and symbols; fill its empty case.contract with exact assertions and correct its environment, commands and verifierAdapter for the files you generate.

Goal: verify pkg:npm/regenerate-unicode-properties@10.2.2
Kind: HOW

Use EXACTLY these public packages and versions:
  - pkg:npm/regenerate-unicode-properties@10.2.2

Rules:
  - One focused purpose; the smallest project that proves the goal.
  - Include a contract test (test/contract.*) that runs OFFLINE and exits 0 exactly when the goal behavior works.
  - Pin every dependency with a lockfile so resolution is reproducible.
  - No secrets, credentials, or tokens. No real URLs (only example.com or localhost). No absolute paths.
  - No personal names, emails, company names, or project identifiers of any kind.
  - No binaries and no generated output (node_modules, dist, target, venv, .git, .env).
  - Keep it under 200 files and 256KB packed.

{"case":{"caseId":"case:sha256:0125ddadccd9d8187e79fe3d129699ce47d292ba5d3b3520bdc7ded597da3058","constraints":{"executionContext":"node"},"contract":["regenerate-unicode-properties maps Unicode property categories to supported property names and provides the Unicode specification version","Binary_Property and General_Category modules provide regenerate sets to test character code points and compile regular expressions","Script and Script_Extensions modules provide regenerate sets matching specific script code points","Property_of_Strings modules provide character code point sets and multi-character string sequences such as RGI emoji sequences"],"goal":"verify pkg:npm/regenerate-unicode-properties@10.2.2","kind":"HOW","packages":["pkg:npm/regenerate-unicode-properties@10.2.2"],"schemaVersion":1},"contractCommand":["node","test/contract.js"],"environment":{"arch":"x64","distro":"ubuntu","ecosystem":"npm","executionContext":"node","language":"javascript","libc":"glibc","libcVersion":"2.39","moduleSystem":"cjs","os":"linux","osVersionBucket":"24","packageManager":"npm","packageManagerVersion":"10.9.8","runtime":"node","runtimeVersion":"22.23.2","schemaVersion":1},"license":"MIT-0","packages":["pkg:npm/regenerate-unicode-properties@10.2.2"],"schemaVersion":1,"subject":"pkg:npm/regenerate-unicode-properties@10.2.2","verifierAdapter":"node-typescript@1"}

{
  "name": "regenerate-unicode-properties-sample",
  "version": "1.0.0",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "regenerate-unicode-properties-sample",
      "version": "1.0.0",
      "dependencies": {
        "regenerate-unicode-properties": "10.2.2"
      }
    },
    "node_modules/regenerate": {
      "version": "1.4.2",
      "resolved": "https://registry.npmjs.org/regenerate/-/regenerate-1.4.2.tgz",
      "integrity": "sha512-zrceR/XhGYU/d/opr2EKO7aRHUeiBI8qjtfHqADTwZd6Szfy16la6kqD0MIUs5z5hx6AaKa+PixpPrR289+I0A==",
      "license": "MIT"
    },
    "node_modules/regenerate-unicode-properties": {
      "version": "10.2.2",
      "resolved": "https://registry.npmjs.org/regenerate-unicode-properties/-/regenerate-unicode-properties-10.2.2.tgz",
      "integrity": "sha512-m03P+zhBeQd1RGnYxrGyDAPpWX/epKirLrp8e3qevZdVkKtnCrjjWczIbYc8+xd6vcTStVlqfycTx1KR4LOr0g==",
      "license": "MIT",
      "dependencies": {
        "regenerate": "^1.4.2"
      },
      "engines": {
        "node": ">=4"
      }
    }
  }
}

{
  "name": "regenerate-unicode-properties-sample",
  "version": "1.0.0",
  "dependencies": {
    "regenerate-unicode-properties": "10.2.2"
  }
}

{
  "schemaVersion": 1,
  "goal": "verify pkg:npm/regenerate-unicode-properties@10.2.2",
  "kind": "HOW",
  "packages": [
    "pkg:npm/regenerate-unicode-properties@10.2.2"
  ]
}

const unicodePropertiesMap = require('regenerate-unicode-properties');
const unicodeVersion = require('regenerate-unicode-properties/unicode-version.js');
const asciiProperty = require('regenerate-unicode-properties/Binary_Property/ASCII.js');
const alphabeticProperty = require('regenerate-unicode-properties/Binary_Property/Alphabetic.js');
const greekScript = require('regenerate-unicode-properties/Script/Greek.js');
const latinScript = require('regenerate-unicode-properties/Script/Latin.js');
const decimalNumberCategory = require('regenerate-unicode-properties/General_Category/Decimal_Number.js');
const rgiEmojiProperty = require('regenerate-unicode-properties/Property_of_Strings/RGI_Emoji.js');

/**
 * Returns available Unicode property categories and their property names.
 *
 * @returns {Map<string, string[]>} Map of category name to array of property names.
 */
function getPropertyMap() {
  return unicodePropertiesMap;
}

/**
 * Returns the supported Unicode specification version.
 *
 * @returns {string} Unicode version string.
 */
function getSupportedUnicodeVersion() {
  return unicodeVersion;
}

/**
 * Checks whether a given character or code point matches a regenerate property set.
 *
 * @param {{ characters: { contains: (cp: number) => boolean } }} propertyObject - Property module export.
 * @param {string|number} input - Character string or integer code point.
 * @returns {boolean} True if the code point belongs to the property set.
 */
function matchesProperty(propertyObject, input) {
  const codePoint = typeof input === 'number' ? input : input.codePointAt(0);
  return propertyObject.characters.contains(codePoint);
}

/**
 * Compiles a regular expression character class matching characters in a regenerate set.
 *
 * @param {{ characters: { toString: () => string } }} propertyObject - Property module export.
 * @param {string} [flags=''] - Optional RegExp flags.
 * @returns {RegExp} Compiled regular expression.
 */
function compileCharacterClass(propertyObject, flags = '') {
  return new RegExp(propertyObject.characters.toString(), flags);
}

module.exports = {
  getPropertyMap,
  getSupportedUnicodeVersion,
  matchesProperty,
  compileCharacterClass,
  asciiProperty,
  alphabeticProperty,
  greekScript,
  latinScript,
  decimalNumberCategory,
  rgiEmojiProperty,
};

const assert = require('node:assert/strict');
const {
  getPropertyMap,
  getSupportedUnicodeVersion,
  matchesProperty,
  compileCharacterClass,
  asciiProperty,
  alphabeticProperty,
  greekScript,
  latinScript,
  decimalNumberCategory,
  rgiEmojiProperty,
} = require('../src/index.js');

// Contract 1: regenerate-unicode-properties maps Unicode property categories to supported property names and provides the Unicode specification version
{
  const map = getPropertyMap();
  assert.strictEqual(map instanceof Map, true, 'Property map should be an instance of Map');

  const categories = Array.from(map.keys());
  assert.ok(categories.includes('Binary_Property'), 'Should contain Binary_Property category');
  assert.ok(categories.includes('General_Category'), 'Should contain General_Category category');
  assert.ok(categories.includes('Script'), 'Should contain Script category');
  assert.ok(categories.includes('Script_Extensions'), 'Should contain Script_Extensions category');
  assert.ok(categories.includes('Property_of_Strings'), 'Should contain Property_of_Strings category');

  const binaryProps = map.get('Binary_Property');
  assert.ok(Array.isArray(binaryProps), 'Binary_Property value should be an array');
  assert.ok(binaryProps.includes('ASCII'), 'Binary_Property should include ASCII');
  assert.ok(binaryProps.includes('Alphabetic'), 'Binary_Property should include Alphabetic');

  const version = getSupportedUnicodeVersion();
  assert.strictEqual(typeof version, 'string', 'Unicode version should be a string');
  assert.strictEqual(version, '17.0.0', 'Unicode version should match package data');
}

// Contract 2: Binary_Property and General_Category modules provide regenerate sets to test character code points and compile regular expressions
{
  assert.strictEqual(matchesProperty(asciiProperty, 0x41), true, 'ASCII contains A (0x41)');
  assert.strictEqual(matchesProperty(asciiProperty, 'Z'), true, 'ASCII contains Z character');
  assert.strictEqual(matchesProperty(asciiProperty, 0x7F), true, 'ASCII contains DEL (0x7F)');
  assert.strictEqual(matchesProperty(asciiProperty, 0x80), false, 'ASCII does not contain 0x80');
  assert.strictEqual(matchesProperty(asciiProperty, 'Ω'), false, 'ASCII does not contain non-ASCII character');

  assert.strictEqual(matchesProperty(alphabeticProperty, 'A'), true, 'Alphabetic contains A');
  assert.strictEqual(matchesProperty(alphabeticProperty, 'α'), true, 'Alphabetic contains Greek alpha');
  assert.strictEqual(matchesProperty(alphabeticProperty, '1'), false, 'Alphabetic does not contain digit');

  assert.strictEqual(matchesProperty(decimalNumberCategory, '0'), true, 'Decimal_Number contains ASCII 0');
  assert.strictEqual(matchesProperty(decimalNumberCategory, '9'), true, 'Decimal_Number contains ASCII 9');
  assert.strictEqual(matchesProperty(decimalNumberCategory, 0x0660), true, 'Decimal_Number contains Arabic-Indic 0 (0x0660)');
  assert.strictEqual(matchesProperty(decimalNumberCategory, 'A'), false, 'Decimal_Number does not contain letter A');

  const asciiRegex = compileCharacterClass(asciiProperty);
  assert.strictEqual(asciiRegex.test('Hello'), true, 'Compiled ASCII regex matches ASCII string');
  assert.strictEqual(asciiRegex.test(''), false, 'Empty string does not match single character class');
}

// Contract 3: Script and Script_Extensions modules provide regenerate sets matching specific script code points
{
  assert.strictEqual(matchesProperty(greekScript, 0x03B1), true, 'Greek script contains alpha (0x03B1)');
  assert.strictEqual(matchesProperty(greekScript, 'Ω'), true, 'Greek script contains capital Omega');
  assert.strictEqual(matchesProperty(greekScript, 'A'), false, 'Greek script does not contain Latin A');

  assert.strictEqual(matchesProperty(latinScript, 'A'), true, 'Latin script contains Latin A');
  assert.strictEqual(matchesProperty(latinScript, 'z'), true, 'Latin script contains Latin z');
  assert.strictEqual(matchesProperty(latinScript, 'Ω'), false, 'Latin script does not contain Greek Omega');

  const greekRegex = compileCharacterClass(greekScript);
  assert.strictEqual(greekRegex.test('α'), true, 'Compiled Greek regex matches Greek character');
  assert.strictEqual(greekRegex.test('a'), false, 'Compiled Greek regex rejects Latin character');
}

// Contract 4: Property_of_Strings modules provide character code point sets and multi-character string sequences such as RGI emoji sequences
{
  assert.ok(rgiEmojiProperty.characters, 'RGI_Emoji should provide characters set');
  assert.ok(Array.isArray(rgiEmojiProperty.strings), 'RGI_Emoji should provide strings array');

  assert.strictEqual(matchesProperty(rgiEmojiProperty, 0x1F600), true, 'RGI_Emoji characters contains grinning face');
  assert.strictEqual(matchesProperty(rgiEmojiProperty, '🔥'), true, 'RGI_Emoji characters contains fire emoji');
  assert.strictEqual(matchesProperty(rgiEmojiProperty, 'A'), false, 'RGI_Emoji characters does not contain plain text letter');

  assert.ok(rgiEmojiProperty.strings.includes('0️⃣'), 'RGI_Emoji strings contains keycap digit sequence 0️⃣');
  assert.ok(rgiEmojiProperty.strings.includes('#️⃣'), 'RGI_Emoji strings contains keycap hash sequence #️⃣');
  assert.ok(rgiEmojiProperty.strings.length > 2000, 'RGI_Emoji strings should contain comprehensive emoji sequences');
}

console.log('All pkg:npm/regenerate-unicode-properties@10.2.2 contracts passed successfully.');