Babel Literal to AST

2.1.0 · maintenance · verified Sun Apr 19

This utility package, `babel-literal-to-ast`, converts standard JavaScript literals and simple objects directly into their Abstract Syntax Tree (AST) representation, formatted according to Babel's specific AST specification. Unlike general-purpose AST parsers that convert source code strings, this library takes a live JavaScript value (like a number, string, boolean, array, or plain object) and returns the corresponding Babel AST node structure. It currently sits at version 2.1.0, with its last update in February 2019, suggesting a stable but no longer actively developed status. Its primary use case is within Babel transformers or other tools that manipulate Babel ASTs, providing a convenient way to inject or create AST nodes from known literal values without having to manually construct the AST objects or parse stringified code. A key differentiator is its direct output to Babel AST format, which has specific deviations from the more generic ESTree specification.

Common errors

```
TypeError: serialize is not a function
```
cause Attempting to use `require` in an ESM module context or a bundling issue where `default` export is not handled correctly.

fix Ensure you are using `import serialize from 'babel-literal-to-ast';` for ESM. If in CommonJS, try `const serialize = require('babel-literal-to-ast').default;` or ensure your bundler is configured correctly for default exports.
```
The 'type' of a node must be a string. Received 'Literal'
```
cause This error often occurs when a Babel transformer receives an AST node type that is not valid in its expected context, or when mixing Babel ASTs with strict ESTree expectations. For instance, a generic 'Literal' type from an older parser might clash with Babel's more specific `StringLiteral`, `NumericLiteral`, etc.

fix Verify that all AST nodes conform to the Babel AST specification. If integrating with non-Babel tools, ensure any conversions (e.g., via `babel-to-estree`) are applied correctly to align node types.

Warnings

gotcha The AST generated by `babel-literal-to-ast` adheres to Babel's specific AST format, which has notable deviations from the standard ESTree specification (e.g., `Literal` vs. `StringLiteral`, `NumericLiteral`, etc.). This means the output may not be directly compatible with tools or libraries expecting strict ESTree ASTs without an additional transformation step (e.g., using `babel-to-estree`).
Fix: If strict ESTree compatibility is required, consider using `babel-to-estree` to convert the generated AST, or manually adjust the nodes. Ensure all downstream tooling is aware of the Babel AST format.
gotcha The package has not been updated since February 2019 (v2.1.0). While its core functionality for converting simple literals is stable, it may not support newer JavaScript syntax features or be compatible with future major versions of `@babel/core` without updates.
Fix: Test thoroughly with newer Babel versions. For complex or very recent JavaScript features as input, manual AST construction or alternative, actively maintained libraries might be necessary. Monitor its GitHub for any activity or forks.
gotcha The `serialize` function directly converts JavaScript values. For complex types like Functions, Classes, or Dates, it will generally produce AST nodes that represent their literal form, not their executable code. For example, a function will become an `Identifier` named 'Function'.
Fix: Understand the limitations: this package is for *literals and plain objects/arrays of literals*. For converting arbitrary JavaScript code into AST, use `@babel/parser`.

Install

npm install babel-literal-to-ast npm
yarn add babel-literal-to-ast yarn
pnpm add babel-literal-to-ast pnpm

Imports

serialize
wrong:
```
const serialize = require('babel-literal-to-ast');
```
correct:
```
import serialize from 'babel-literal-to-ast';
```
The package is primarily designed for ESM usage as per the README example, though CJS `require` might work in older Node.js environments. For modern projects, use `import`.
Node types (indirect)
```
import * as t from '@babel/types';
```
While `babel-literal-to-ast` generates nodes, you'll often need `@babel/types` for manual AST manipulation or checking node types when working with the output. This is a common companion import in Babel projects.

Quickstart

Demonstrates converting various JavaScript literals and objects into their Babel AST representation and then generating code from them using `@babel/generator`.

import serialize from 'babel-literal-to-ast';
import generate from '@babel/generator';

// Basic literal: string
let astString = serialize('Hello, Babel!');
console.log('String AST:', generate(astString).code);
// Expected output: String AST: "Hello, Babel!"

// Basic literal: number
let astNumber = serialize(12345);
console.log('Number AST:', generate(astNumber).code);
// Expected output: Number AST: 12345

// Object literal
let astObject = serialize({
  message: 'Hello',
  version: 2.1,
  enabled: true,
  items: [1, 'two', null]
});
console.log('Object AST:', generate(astObject).code);
/* Expected output:
Object AST: ({ message: 'Hello', version: 2.1, enabled: true, items: [1, 'two', null] });
(Note: The wrapping parentheses are often added by @babel/generator for ExpressionStatement compatibility.)
*/

// Null and undefined (undefined usually becomes Identifier 'undefined')
let astNull = serialize(null);
let astUndefined = serialize(undefined);
console.log('Null AST:', generate(astNull).code);
console.log('Undefined AST:', generate(astUndefined).code);
// Expected output: Null AST: null
// Expected output: Undefined AST: undefined

view raw JSON →