@babel/parser 7.29.8

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/parser@7.29.8
Kind: HOW

Use EXACTLY these public packages and versions:
  - pkg:npm/%40babel/parser@7.29.8
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:bd491726c12e3841e0b6a5b5b87014baf84cde64d47d3d39a5c45ae2b04796ac","constraints":{"executionContext":"node"},"contract":["parse parses valid JavaScript code and returns a File AST with Program body","parse supports module sourceType with ES module import and export statements","parse supports syntax plugins including jsx and typescript","parse throws SyntaxError on invalid code with line and column location info","parseExpression parses a single JavaScript expression into an expression AST node","parseExpression throws SyntaxError when input contains statements rather than a single expression"],"goal":"verify pkg:npm/%40babel/parser@7.29.8","kind":"HOW","packages":["pkg:npm/%40babel/parser@7.29.8"],"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/parser@7.29.8"],"schemaVersion":1,"subject":"pkg:npm/%40babel/parser@7.29.8","verifierAdapter":"node-typescript@1"}

{
  "name": "sample-babel-parser",
  "version": "1.0.0",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "sample-babel-parser",
      "version": "1.0.0",
      "license": "MIT-0",
      "dependencies": {
        "@babel/parser": "7.29.8"
      }
    },
    "node_modules/@babel/helper-string-parser": {
      "version": "7.29.7",
      "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.29.7.tgz",
      "integrity": "sha512-Pb5ijPrZ89GDH8223L4UP8i6QApWxs04RbPQJTeWDV0/keR2E36MeKnyr6LYmUUvqRRI+Iv87SuF1W6ErINzYw==",
      "license": "MIT",
      "engines": {
        "node": ">=6.9.0"
      }
    },
    "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"
      }
    },
    "node_modules/@babel/parser": {
      "version": "7.29.8",
      "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.29.8.tgz",
      "integrity": "sha512-E8lTAYNB1KW+FH+VGJuZM1ioAx2E6oVlvQFRrf5P8ZZmsiJXYAD9vTFV7yyEURNzgh1dFqMZuO6tUwcARbqFCA==",
      "license": "MIT",
      "dependencies": {
        "@babel/types": "^7.29.8"
      },
      "bin": {
        "parser": "bin/babel-parser.js"
      },
      "engines": {
        "node": ">=6.0.0"
      }
    },
    "node_modules/@babel/types": {
      "version": "7.29.8",
      "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.29.8.tgz",
      "integrity": "sha512-Vj1jF3cPfxg7OAfoI7QnVKLoILlm2JF9pnVHrX8qx7AHMiYWT+NDAA7jChlNgRS4WTLc/fD1lXLmPixluj+3Gg==",
      "license": "MIT",
      "dependencies": {
        "@babel/helper-string-parser": "^7.29.7",
        "@babel/helper-validator-identifier": "^7.29.7"
      },
      "engines": {
        "node": ">=6.9.0"
      }
    }
  }
}

{
  "name": "sample-babel-parser",
  "version": "1.0.0",
  "private": true,
  "description": "Clean-room code sample for @babel/parser@7.29.8",
  "main": "src/index.js",
  "license": "MIT-0",
  "dependencies": {
    "@babel/parser": "7.29.8"
  }
}

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

const parser = require('@babel/parser');

const { parse, parseExpression, tokTypes } = parser;

/**
 * Parses JavaScript source code into an AST File node.
 *
 * @param {string} code - Source code string.
 * @param {object} [options] - Parser options.
 * @returns {object} AST File node.
 */
function parseSource(code, options = {}) {
  return parse(code, {
    sourceType: 'module',
    ...options
  });
}

/**
 * Parses a single JavaScript expression string into an AST Expression node.
 *
 * @param {string} expr - Expression string.
 * @param {object} [options] - Parser options.
 * @returns {object} AST Expression node.
 */
function parseSingleExpression(expr, options = {}) {
  return parseExpression(expr, options);
}

/**
 * Checks whether the given source string is syntactically valid according to specified options.
 *
 * @param {string} code - Source code to validate.
 * @param {object} [options] - Parser options.
 * @returns {boolean} True if valid, false if parsing throws a SyntaxError.
 */
function isValidSyntax(code, options = {}) {
  try {
    parse(code, options);
    return true;
  } catch (err) {
    if (err.name === 'SyntaxError' || err.code === 'BABEL_PARSER_SYNTAX_ERROR') {
      return false;
    }
    throw err;
  }
}

module.exports = {
  parser,
  parse,
  parseExpression,
  tokTypes,
  parseSource,
  parseSingleExpression,
  isValidSyntax
};

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

const require = createRequire(import.meta.url);
const {
  parser,
  parse,
  parseExpression,
  tokTypes,
  parseSource,
  parseSingleExpression,
  isValidSyntax
} = require('../src/index.js');

async function runTests() {
  // 1. parse parses valid JavaScript code and returns a File AST with Program body
  assert.equal(typeof parser.parse, 'function', 'parser.parse must be a function');
  assert.equal(typeof parse, 'function', 'parse must be a function');

  const basicCode = 'const answer = 40 + 2;';
  const ast = parseSource(basicCode);
  assert.equal(ast.type, 'File', 'Root AST type must be File');
  assert.ok(ast.program, 'AST must contain program node');
  assert.equal(ast.program.type, 'Program', 'Program type must be Program');
  assert.equal(ast.program.body.length, 1, 'Program body must have 1 statement');
  assert.equal(ast.program.body[0].type, 'VariableDeclaration', 'Statement must be VariableDeclaration');

  // 2. parse supports module sourceType with ES module import and export statements
  const moduleCode = 'import { util } from "module-a";\nexport const result = util();';
  const moduleAst = parse(moduleCode, { sourceType: 'module' });
  assert.equal(moduleAst.program.sourceType, 'module', 'Program sourceType must be module');
  assert.equal(moduleAst.program.body.length, 2, 'Module program body must have 2 statements');
  assert.equal(moduleAst.program.body[0].type, 'ImportDeclaration', 'First statement is ImportDeclaration');
  assert.equal(moduleAst.program.body[1].type, 'ExportNamedDeclaration', 'Second statement is ExportNamedDeclaration');

  // 3. parse supports syntax plugins including jsx and typescript
  const jsxCode = '<Button active={true}>Click</Button>;';
  const jsxAst = parse(jsxCode, { plugins: ['jsx'] });
  assert.equal(jsxAst.program.body[0].expression.type, 'JSXElement', 'JSX expression must parse to JSXElement');

  const tsCode = 'interface Item { id: number; } const item: Item = { id: 1 };';
  const tsAst = parse(tsCode, { plugins: ['typescript'] });
  assert.equal(tsAst.program.body[0].type, 'TSInterfaceDeclaration', 'Interface declaration must parse to TSInterfaceDeclaration');
  assert.ok(tsAst.program.body[1].declarations[0].id.typeAnnotation, 'Type annotation must be preserved on TypeScript node');

  // 4. parse throws SyntaxError on invalid code with line and column location info
  assert.equal(isValidSyntax('const valid = 100;'), true, 'Valid syntax returns true');
  assert.equal(isValidSyntax('const = ;'), false, 'Invalid syntax returns false');

  let syntaxErrorCaught = false;
  try {
    parse('function ( {');
  } catch (err) {
    syntaxErrorCaught = true;
    assert.equal(err.name, 'SyntaxError', 'Error name must be SyntaxError');
    assert.ok(err.loc, 'Error must contain loc property');
    assert.equal(typeof err.loc.line, 'number', 'loc.line must be a number');
    assert.equal(typeof err.loc.column, 'number', 'loc.column must be a number');
  }
  assert.ok(syntaxErrorCaught, 'SyntaxError must be thrown for malformed code');

  // 5. parseExpression parses a single JavaScript expression into an expression AST node
  assert.equal(typeof parser.parseExpression, 'function', 'parser.parseExpression must be a function');
  assert.equal(typeof parseExpression, 'function', 'parseExpression must be a function');

  const exprAst = parseSingleExpression('foo + bar * 2');
  assert.equal(exprAst.type, 'BinaryExpression', 'Root node must be BinaryExpression');
  assert.equal(exprAst.operator, '+', 'BinaryExpression operator must be +');
  assert.equal(exprAst.left.type, 'Identifier', 'Left operand is Identifier');
  assert.equal(exprAst.left.name, 'foo', 'Left operand name is foo');
  assert.equal(exprAst.right.type, 'BinaryExpression', 'Right operand is BinaryExpression');

  // 6. parseExpression throws SyntaxError when input contains statements rather than a single expression
  assert.throws(
    () => {
      parseSingleExpression('const a = 1; const b = 2;');
    },
    (err) => {
      return err.name === 'SyntaxError';
    },
    'parseExpression must throw SyntaxError on statements'
  );

  console.log('All contract assertions for @babel/parser passed successfully.');
}

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