@babel/helper-validator-identifier 7.29.7

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/%40babel/helper-validator-identifier@7.29.7
Kind: HOW

Use EXACTLY these public packages and versions:
  - pkg:npm/%40babel/helper-validator-identifier@7.29.7
Constraints:
  - executionContext: node
Required runtime conditions:
  - ecosystem: npm
  - language: javascript
  - moduleSystem: cjs
  - packageManager: npm@10.9.8
  - runtime: node@22.23.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:ae0439d6f78b2aede80a22aa0535cd9d8b03ab65fc31ff8b124d916adb98ddf8","constraints":{"executionContext":"node"},"contract":["isIdentifierStart returns true for valid ASCII and Unicode identifier start characters like dollar sign, underscore, letters, and false for digits","isIdentifierChar returns true for valid identifier continuation characters including decimal digits and false for punctuation characters like hyphens","isIdentifierName returns true for valid JavaScript identifier names and false for invalid strings containing spaces, hyphens, leading numbers, or empty strings","isKeyword returns true for standard ECMAScript keywords such as return, const, class, and function and false for arbitrary variable names","isReservedWord identifies module-specific reserved words like await only when inModule flag is true and enum unconditionally","isStrictReservedWord recognizes strict-mode reserved words including let, yield, and private","isStrictBindReservedWord recognizes strict-mode binding restricted identifiers like eval and arguments"],"goal":"verify pkg:npm/%40babel/helper-validator-identifier@7.29.7","kind":"HOW","packages":["pkg:npm/%40babel/helper-validator-identifier@7.29.7"],"schemaVersion":1},"contractCommand":["node","test/contract.mjs"],"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/%40babel/helper-validator-identifier@7.29.7"],"schemaVersion":1,"subject":"pkg:npm/%40babel/helper-validator-identifier@7.29.7","verifierAdapter":"node-typescript@1"}

{
  "name": "sample-babel-helper-validator-identifier",
  "version": "1.0.0",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "sample-babel-helper-validator-identifier",
      "version": "1.0.0",
      "license": "MIT-0",
      "dependencies": {
        "@babel/helper-validator-identifier": "7.29.7"
      }
    },
    "node_modules/@babel/helper-validator-identifier": {
      "version": "7.29.7",
      "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.29.7.tgz",
      "integrity": "sha512-qehxGkRj55h/ff8EMaJ+cYhyaKlHIxqYDn682wQD7RNp9UujOQsHog2uS0r2vzr4pW+sXf90NeeayjcNaX3fFg==",
      "license": "MIT",
      "engines": {
        "node": ">=6.9.0"
      }
    }
  }
}

{
  "name": "sample-babel-helper-validator-identifier",
  "version": "1.0.0",
  "private": true,
  "description": "Clean-room verification of pkg:npm/%40babel/helper-validator-identifier@7.29.7",
  "main": "src/index.js",
  "license": "MIT-0",
  "dependencies": {
    "@babel/helper-validator-identifier": "7.29.7"
  }
}

{
  "schemaVersion": 1,
  "goal": "verify pkg:npm/%40babel/helper-validator-identifier@7.29.7",
  "kind": "HOW",
  "packages": [
    "pkg:npm/%40babel/helper-validator-identifier@7.29.7"
  ],
  "constraints": {
    "executionContext": "node"
  },
  "runtimeConditions": {
    "ecosystem": "npm",
    "language": "javascript",
    "moduleSystem": "cjs",
    "packageManager": "npm@10.9.8",
    "runtime": "node@22.23.2"
  }
}

const {
  isIdentifierStart,
  isIdentifierChar,
  isIdentifierName,
  isKeyword,
  isReservedWord,
  isStrictReservedWord,
  isStrictBindReservedWord,
} = require('@babel/helper-validator-identifier');

/**
 * Validates if a Unicode code point can be the start of a JavaScript identifier.
 * @param {number} code - Unicode character code.
 * @returns {boolean}
 */
function isValidIdentifierStart(code) {
  return isIdentifierStart(code);
}

/**
 * Validates if a Unicode code point can be a continuation character of a JavaScript identifier.
 * @param {number} code - Unicode character code.
 * @returns {boolean}
 */
function isValidIdentifierChar(code) {
  return isIdentifierChar(code);
}

/**
 * Validates whether a string is a valid JavaScript identifier name.
 * @param {string} name - Identifier name to validate.
 * @returns {boolean}
 */
function isValidIdentifier(name) {
  return isIdentifierName(name);
}

/**
 * Checks whether a word is an ECMAScript keyword.
 * @param {string} word - Word to check.
 * @returns {boolean}
 */
function isReservedKeyword(word) {
  return isKeyword(word);
}

/**
 * Checks whether a word is a reserved word in module or script mode.
 * @param {string} word - Word to check.
 * @param {boolean} [inModule=false] - Whether parsing in module context.
 * @returns {boolean}
 */
function isReserved(word, inModule = false) {
  return isReservedWord(word, inModule);
}

/**
 * Checks whether a word is a strict-mode reserved word.
 * @param {string} word - Word to check.
 * @param {boolean} [inModule=false] - Whether parsing in module context.
 * @returns {boolean}
 */
function isStrictReserved(word, inModule = false) {
  return isStrictReservedWord(word, inModule);
}

/**
 * Checks whether a word is a strict-mode binding restricted word.
 * @param {string} word - Word to check.
 * @param {boolean} [inModule=false] - Whether parsing in module context.
 * @returns {boolean}
 */
function isStrictBindReserved(word, inModule = false) {
  return isStrictBindReservedWord(word, inModule);
}

module.exports = {
  isValidIdentifierStart,
  isValidIdentifierChar,
  isValidIdentifier,
  isReservedKeyword,
  isReserved,
  isStrictReserved,
  isStrictBindReserved,
};

import assert from 'node:assert';
import { createRequire } from 'node:module';

const require = createRequire(import.meta.url);
const {
  isValidIdentifierStart,
  isValidIdentifierChar,
  isValidIdentifier,
  isReservedKeyword,
  isReserved,
  isStrictReserved,
  isStrictBindReserved,
} = require('../src/index.js');

async function runContract() {
  // 1. isIdentifierStart returns true for valid ASCII and Unicode identifier start characters like dollar sign, underscore, letters, and false for digits
  assert.strictEqual(isValidIdentifierStart('$'.charCodeAt(0)), true, '$ is valid identifier start');
  assert.strictEqual(isValidIdentifierStart('_'.charCodeAt(0)), true, '_ is valid identifier start');
  assert.strictEqual(isValidIdentifierStart('a'.charCodeAt(0)), true, 'a is valid identifier start');
  assert.strictEqual(isValidIdentifierStart('Z'.charCodeAt(0)), true, 'Z is valid identifier start');
  assert.strictEqual(isValidIdentifierStart('π'.charCodeAt(0)), true, 'π is valid identifier start');
  assert.strictEqual(isValidIdentifierStart('0'.charCodeAt(0)), false, '0 is not valid identifier start');
  assert.strictEqual(isValidIdentifierStart('-'.charCodeAt(0)), false, '- is not valid identifier start');

  // 2. isIdentifierChar returns true for valid identifier continuation characters including decimal digits and false for punctuation characters like hyphens
  assert.strictEqual(isValidIdentifierChar('0'.charCodeAt(0)), true, '0 is valid identifier char');
  assert.strictEqual(isValidIdentifierChar('9'.charCodeAt(0)), true, '9 is valid identifier char');
  assert.strictEqual(isValidIdentifierChar('a'.charCodeAt(0)), true, 'a is valid identifier char');
  assert.strictEqual(isValidIdentifierChar('_'.charCodeAt(0)), true, '_ is valid identifier char');
  assert.strictEqual(isValidIdentifierChar('$'.charCodeAt(0)), true, '$ is valid identifier char');
  assert.strictEqual(isValidIdentifierChar('-'.charCodeAt(0)), false, '- is not valid identifier char');
  assert.strictEqual(isValidIdentifierChar(' '.charCodeAt(0)), false, 'space is not valid identifier char');

  // 3. isIdentifierName returns true for valid JavaScript identifier names and false for invalid strings containing spaces, hyphens, leading numbers, or empty strings
  assert.strictEqual(isValidIdentifier('myVar'), true, 'myVar is a valid identifier name');
  assert.strictEqual(isValidIdentifier('_privateField'), true, '_privateField is a valid identifier name');
  assert.strictEqual(isValidIdentifier('$element'), true, '$element is a valid identifier name');
  assert.strictEqual(isValidIdentifier('camelCase123'), true, 'camelCase123 is a valid identifier name');
  assert.strictEqual(isValidIdentifier(''), false, 'empty string is not a valid identifier name');
  assert.strictEqual(isValidIdentifier('123abc'), false, 'leading digit identifier is not valid');
  assert.strictEqual(isValidIdentifier('kebab-case'), false, 'hyphenated name is not valid');
  assert.strictEqual(isValidIdentifier('hello world'), false, 'space separated name is not valid');

  // 4. isKeyword returns true for standard ECMAScript keywords such as return, const, class, and function and false for arbitrary variable names
  assert.strictEqual(isReservedKeyword('return'), true, 'return is a keyword');
  assert.strictEqual(isReservedKeyword('const'), true, 'const is a keyword');
  assert.strictEqual(isReservedKeyword('class'), true, 'class is a keyword');
  assert.strictEqual(isReservedKeyword('function'), true, 'function is a keyword');
  assert.strictEqual(isReservedKeyword('if'), true, 'if is a keyword');
  assert.strictEqual(isReservedKeyword('myVariable'), false, 'myVariable is not a keyword');
  assert.strictEqual(isReservedKeyword('customName'), false, 'customName is not a keyword');

  // 5. isReservedWord identifies module-specific reserved words like await only when inModule flag is true and enum unconditionally
  assert.strictEqual(isReserved('await', true), true, 'await is reserved in module');
  assert.strictEqual(isReserved('await', false), false, 'await is not reserved in non-module script');
  assert.strictEqual(isReserved('enum', true), true, 'enum is reserved in module');
  assert.strictEqual(isReserved('enum', false), true, 'enum is reserved in script');
  assert.strictEqual(isReserved('myIdentifier', true), false, 'myIdentifier is not reserved');

  // 6. isStrictReservedWord recognizes strict-mode reserved words including let, yield, and private
  assert.strictEqual(isStrictReserved('let', false), true, 'let is strict reserved');
  assert.strictEqual(isStrictReserved('yield', false), true, 'yield is strict reserved');
  assert.strictEqual(isStrictReserved('private', false), true, 'private is strict reserved');
  assert.strictEqual(isStrictReserved('public', false), true, 'public is strict reserved');
  assert.strictEqual(isStrictReserved('interface', false), true, 'interface is strict reserved');
  assert.strictEqual(isStrictReserved('normalVar', false), false, 'normalVar is not strict reserved');

  // 7. isStrictBindReservedWord recognizes strict-mode binding restricted identifiers like eval and arguments
  assert.strictEqual(isStrictBindReserved('eval', false), true, 'eval is strict bind reserved');
  assert.strictEqual(isStrictBindReserved('arguments', false), true, 'arguments is strict bind reserved');
  assert.strictEqual(isStrictBindReserved('let', false), true, 'let is strict bind reserved because it is strict reserved');
  assert.strictEqual(isStrictBindReserved('myVar', false), false, 'myVar is not strict bind reserved');

  console.log('Contract tests passed successfully.');
}

runContract().catch((err) => {
  console.error('Contract test failed:', err);
  process.exit(1);
});