acorn vs ast-types vs esprima vs estraverse vs recast
JavaScript AST Tooling for Code Transformation
Search packages..
acornast-typesesprimaestraverserecastSimilar Packages:

JavaScript AST Tooling for Code Transformation

acorn, esprima, estraverse, ast-types, and recast form a toolkit for parsing, analyzing, and modifying JavaScript code programmatically. acorn and esprima are parsers that turn source code into Abstract Syntax Trees (AST). estraverse walks these trees to find specific patterns. ast-types provides definitions and builders for AST nodes. recast combines these steps to transform code while preserving original formatting, making it ideal for codemods and refactoring tools.

Npm Package Weekly Downloads Trend

3 Years

Github Stars Ranking

Stat Detail

Package
Downloads
Stars
Size
Issues
Publish
License
acorn011,350559 kB15a month agoMIT
ast-types01,170-1416 years agoMIT
esprima07,134-1478 years agoBSD-2-Clause
estraverse0966-394 years agoBSD-2-Clause
recast05,229246 kB210a year agoMIT

JavaScript AST Tooling: Parsing, Traversal, and Transformation

When building tools like linters, bundlers, or codemods, you need to understand JavaScript code as data. The packages acorn, esprima, estraverse, ast-types, and recast each handle a specific part of this pipeline. Let's compare how they approach parsing, walking, and modifying code.

🧩 Parsing: Turning Code into Trees

acorn is a minimalist, fast parser that focuses on speed and modularity.

  • It supports modern ECMAScript versions via plugins.
  • It returns a standard ESTree-compatible AST.
  • Best for tools that need to parse many files quickly.
// acorn: Fast parsing
import * as acorn from 'acorn';

const ast = acorn.parse('const x = 10;', {
  ecmaVersion: 2022,
  sourceType: 'module'
});

console.log(ast.body[0].kind); // "const"

esprima was the pioneering parser for JavaScript but is now considered legacy.

  • It strictly follows the ESTree specification.
  • It is slower and less modular than acorn.
  • Still used in some older toolchains but rarely chosen for new work.
// esprima: Legacy parsing
import * as esprima from 'esprima';

const ast = esprima.parseScript('const x = 10;', {
  loc: true,
  range: true
});

console.log(ast.body[0].kind); // "const"

🚶 Traversal: Walking the Tree

estraverse provides a dedicated way to walk the AST produced by parsers like acorn or esprima.

  • It separates the walking logic from the parsing logic.
  • You define enter and leave callbacks to handle nodes.
  • You can modify the tree or stop traversal early.
// estraverse: Walking the AST
import * as estraverse from 'estraverse';
import * as acorn from 'acorn';

const ast = acorn.parse('const x = 10;', { ecmaVersion: 2022 });

estraverse.traverse(ast, {
  enter(node) {
    if (node.type === 'Identifier') {
      console.log('Found:', node.name);
    }
  }
});

🏗️ Building and Validating Nodes

ast-types defines the shapes of AST nodes and provides builders to create them.

  • It ensures that nodes you create are valid according to the spec.
  • It is often used alongside recast to construct new code.
  • Useful for type checking AST structures in TypeScript projects.
// ast-types: Building nodes
import { namedTypes, builders } from 'ast-types';

const id = builders.identifier('myVariable');

// Validate the node
if (namedTypes.Identifier.check(id)) {
  console.log('Valid identifier:', id.name);
}

🔄 Transformation: Modifying Code with Style

recast is a high-level tool that combines parsing, traversal, and printing.

  • Its main feature is preserving original formatting (whitespace, comments).
  • It uses esprima or acorn under the hood but hides the complexity.
  • Ideal for codemods where you want clean diffs in Git.
// recast: Transform with formatting
import * as recast from 'recast';
import { builders } from 'ast-types';

const code = `const x = 10;`;
const ast = recast.parse(code);

// Modify the AST
ast.program.body[0].declarations[0].init = builders.literal(20);

// Print only changed parts, keep rest intact
const output = recast.print(ast).code;
console.log(output); // "const x = 20;"

📦 Input and Output Handling

The way these tools handle code input and output defines their use case.

  • Use acorn or esprima when you only need the AST for analysis (e.g., linting rules).
  • Use estraverse when you need to decouple walking logic from your parser choice.
  • Use ast-types when you are generating new code nodes programmatically.
  • Use recast when you need to output valid JavaScript code that looks like the original.

💡 Tip: If you use recast, you often don't need to import estraverse directly because recast has its own traversal methods that integrate with its printer.

⚠️ Maintenance and Ecosystem Status

Not all packages are maintained equally. This affects long-term project stability.

  • acorn is actively maintained and widely used in the ecosystem (e.g., Rollup, ESLint).
  • esprima is in maintenance mode. It receives few updates and lacks support for the latest JS features without forks.
  • recast is actively maintained and updated to support new syntax via its parser options.
  • estraverse and ast-types are stable utilities that change infrequently because the ESTree spec is stable.
// acorn: Extensible via plugins
import * as acorn from 'acorn';
import * as acornWalk from 'acorn-walk';

// acorn-walk is a modern alternative to estraverse for acorn ASTs
acornWalk.simple(ast, {
  Identifier(node) {
    console.log(node.name);
  }
});

🌐 Real-World Scenarios

Scenario 1: Building a Linter Rule

You need to find all unused variables in a file.

  • ✅ Best choice: acorn + estraverse (or acorn-walk)
  • Why? You only need to read the AST, not change the code. Speed matters.
// Linter analysis
const ast = acorn.parse(code, { ecmaVersion: 2022 });
estraverse.traverse(ast, {
  enter(node) {
    if (node.type === 'VariableDeclarator') {
      // Check usage logic here
    }
  }
});

Scenario 2: Automated Refactoring (Codemod)

You need to rename a function across 1000 files without breaking formatting.

  • ✅ Best choice: recast
  • Why? It preserves whitespace and comments, making code review easy.
// Codemod transformation
const ast = recast.parse(code);
// ... modify ast ...
const newCode = recast.print(ast).code;

Scenario 3: Generating Boilerplate Code

You are building a CLI that scaffolds new components.

  • ✅ Best choice: ast-types + recast
  • Why? ast-types ensures the generated nodes are valid; recast prints them nicely.
// Scaffolding
const fn = builders.functionDeclaration(
  builders.identifier('init'),
  [],
  builders.blockStatement([])
);
const output = recast.print({ type: 'Program', body: [fn] }).code;

Scenario 4: Legacy Tool Maintenance

You are fixing a bug in an older tool built 5 years ago.

  • ✅ Best choice: esprima
  • Why? The existing AST structure might depend on esprima's specific output quirks.
// Legacy support
const ast = esprima.parse(code, { loc: true });
// Do not migrate unless necessary

📌 Summary Table

PackagePrimary RoleOutputFormatting Preserved?Active Maintenance?
acornParserAST❌✅
esprimaParserAST❌⚠️ (Legacy)
estraverseTraversalVoid/Modified AST❌✅
ast-typesTypes/BuildersNode ObjectsN/A✅
recastTransformationCode String✅✅

💡 Final Recommendation

Think about your end goal: Analysis or Modification.

  • For Analysis (linting, metrics): Use acorn to parse and estraverse (or acorn-walk) to inspect. It is fast and lightweight.
  • For Modification (codemods, transpilers): Use recast. It handles the hard parts of reprinting code so your diffs stay clean.
  • For Node Creation: Use ast-types to ensure you are building valid structures before printing them.

Avoid esprima for new projects unless you have a specific constraint. The community has largely standardized on acorn for parsing and recast for transformation. These tools work together seamlessly — recast can even use acorn as its underlying parser if configured.

How to Choose: acorn vs ast-types vs esprima vs estraverse vs recast

  • acorn:

    Choose acorn when you need a fast, lightweight, and modular parser for modern JavaScript. It is the standard choice for build tools and linters that require high performance and extensibility via plugins. It is best suited for scenarios where you need to generate an AST quickly without worrying about preserving the original code formatting.

  • ast-types:

    Choose ast-types when you need to validate AST node structures or programmatically build new nodes. It provides a robust system of type definitions and builders that ensure your generated code conforms to the ESTree specification. This is essential when writing tools that construct code from scratch rather than just modifying existing trees.

  • esprima:

    Choose esprima primarily for legacy support or if you require strict ESTree compatibility for older JavaScript versions. It is less actively developed than acorn and is generally not recommended for new projects unless you are maintaining a toolchain that already depends on it. Consider acorn or espree for modern ECMAScript features.

  • estraverse:

    Choose estraverse when you need to walk or traverse an AST produced by any ESTree-compatible parser. It offers a simple API for visiting nodes with enter and leave callbacks, allowing you to analyze or modify the tree structure. It is the go-to utility for separation of concerns between parsing and tree manipulation.

  • recast:

    Choose recast when you need to transform code while keeping the original formatting, comments, and whitespace intact. It is the industry standard for codemods and automated refactoring tools where diff readability is critical. It handles the complex work of reprinting only the changed parts of the code, reducing noise in version control.

Similar Npm Packages to acorn

acorn is a small, fast, and efficient JavaScript parser written in JavaScript. It is designed to parse ECMAScript (JavaScript) code and generate an Abstract Syntax Tree (AST) that can be used for various purposes, such as code analysis, transformation, or linting. Acorn is known for its speed and flexibility, making it a popular choice among developers who need a lightweight solution for parsing JavaScript.

While Acorn is a powerful tool, there are alternatives available that also serve the purpose of parsing JavaScript code. Here are a couple of notable alternatives:

  • esprima is another popular JavaScript parser that is known for its compliance with the ECMAScript specification. It generates a comprehensive AST and is often used in tools that require a deep understanding of JavaScript syntax. Esprima is particularly valued for its accuracy and adherence to the latest ECMAScript standards. If you need a parser that strictly follows the ECMAScript specification and provides detailed error reporting, Esprima is a solid choice.
  • typescript is primarily known as a superset of JavaScript that adds static typing to the language. However, it also includes a powerful parser that can analyze and transform JavaScript and TypeScript code. TypeScript's parser is particularly useful if you are working in a TypeScript environment or need to handle both TypeScript and JavaScript codebases. Its type-checking capabilities can help catch errors early in the development process, making it a great option for larger projects.

To see how Acorn compares with Esprima and TypeScript, check out the comparison: Comparing acorn vs esprima vs typescript.

Similar Npm Packages to ast-types

ast-types is a library for working with Abstract Syntax Trees (ASTs) in JavaScript. It provides a set of utilities for defining and manipulating AST node types, making it easier for developers to work with code analysis, transformation, and generation. While ast-types offers a robust solution for AST manipulation, there are several alternatives in the JavaScript ecosystem that serve similar purposes. Here are a few notable alternatives:

  • acorn is a small, fast, and efficient JavaScript parser that produces an AST from JavaScript code. It is designed to be easy to integrate and can be extended with plugins to support additional syntax. Acorn is particularly useful for projects that require a lightweight parser for JavaScript, and it is often used in combination with other tools for code analysis and transformation.

  • esprima is another popular JavaScript parser that generates an AST from JavaScript code. It is known for its speed and compliance with the ECMAScript specification. Esprima is widely used in various tools and libraries for static analysis, code transformation, and linting. If you need a reliable parser that adheres closely to the ECMAScript standard, Esprima is a solid choice.

  • estraverse is a library for traversing and manipulating ASTs. It is often used in conjunction with parsers like Acorn or Esprima to analyze and transform JavaScript code. Estraverse provides a simple API for walking through the nodes of an AST, allowing developers to perform operations like searching, modifying, or generating new ASTs based on existing ones.

  • recast is a powerful library for code transformation that allows developers to work with ASTs while preserving the original formatting of the code. It uses the ast-types library for defining and manipulating AST nodes, making it easy to perform complex code transformations. Recast is particularly useful for projects that require code refactoring or automated code modifications while maintaining readability.

To see how ast-types compares with acorn, esprima, estraverse, and recast, check out the comparison: Comparing acorn vs ast-types vs esprima vs estraverse vs recast.

Similar Npm Packages to esprima

esprima is a high-performance, standard-compliant JavaScript parser that can analyze JavaScript code and produce an Abstract Syntax Tree (AST). It is widely used in various tools and libraries for tasks such as code analysis, linting, and transformation. Esprima is known for its speed and accuracy, making it a popular choice among developers who need to parse JavaScript code efficiently.

While Esprima is a powerful tool, there are alternatives that also serve the purpose of parsing JavaScript. Here are a couple of notable options:

  • acorn is a small, fast, and efficient JavaScript parser that is designed to be easy to extend. It is particularly well-suited for projects that require a lightweight solution for parsing JavaScript. Acorn supports the latest ECMAScript features and can be easily integrated into various tools and workflows. Its modular architecture allows developers to customize the parser to fit their specific needs, making it a flexible option for those who want to create their own tools or integrate parsing capabilities into existing projects.

  • typescript is primarily known as a superset of JavaScript that adds static typing to the language. However, TypeScript also includes a powerful compiler that can parse JavaScript code and produce an AST. This makes it a viable alternative for projects that already use TypeScript and want to leverage its parsing capabilities. TypeScript's parser is designed to handle modern JavaScript features and provides type information, which can be beneficial for developers looking to perform static analysis or transformations on their code.

To explore how Esprima compares with Acorn and TypeScript, check out the comparison: Comparing acorn vs esprima vs typescript.

Similar Npm Packages to recast

recast is a powerful JavaScript syntax tree transformer that allows developers to manipulate and transform JavaScript code programmatically. It is particularly useful for code refactoring, linting, and generating code in a structured manner. By using recast, developers can parse JavaScript code into an abstract syntax tree (AST), apply transformations, and then generate the modified code back into a readable format. This makes it an essential tool for projects that require code analysis and transformation.

While recast is a robust option for code transformation, several alternatives can also be considered:

  • acorn is a small, fast, and efficient JavaScript parser that produces an abstract syntax tree (AST) from JavaScript code. It is designed to be lightweight and can be easily integrated into various projects. Acorn is particularly useful for developers who need a straightforward parsing solution without the overhead of additional features. However, it does not provide built-in transformation capabilities, so it is often used in conjunction with other libraries for code manipulation.
  • babel is a widely-used JavaScript compiler that allows developers to transform modern JavaScript code into a backward-compatible version for older environments. Babel can also be used for code transformation and manipulation through its plugin system, making it a versatile tool for developers. It supports a wide range of plugins and presets, enabling extensive customization for various use cases, including code refactoring and optimization.
  • esprima is another high-performance, standard-compliant JavaScript parser that produces an AST. It is known for its speed and accuracy, making it a popular choice for developers who need to analyze and manipulate JavaScript code. While esprima focuses primarily on parsing, it can be combined with other libraries for transformation tasks.
  • jscodeshift is a toolkit for running codemods, which are scripts that help automate code transformations. Built on top of recast, jscodeshift provides a higher-level API for performing common code modifications, making it easier for developers to apply large-scale changes across codebases. It is particularly useful for migrating code or applying consistent style changes.
  • typescript is a superset of JavaScript that adds static typing to the language. While primarily known for its type-checking capabilities, TypeScript also includes a powerful compiler that can parse and transform code. Developers can leverage TypeScript's AST for various code manipulation tasks, making it a viable alternative for those working in TypeScript environments.

To see how recast compares with acorn, babel, esprima, jscodeshift, and typescript, check out the comparison: Comparing acorn vs babel vs esprima vs jscodeshift vs recast vs typescript.

README for acorn

Acorn

A tiny, fast JavaScript parser written in JavaScript.

Community

Acorn is open source software released under an MIT license.

You are welcome to report bugs or create pull requests on github.

Installation

The easiest way to install acorn is from npm:

npm install acorn

Alternately, you can download the source and build acorn yourself:

git clone https://github.com/acornjs/acorn.git
cd acorn
npm install

Importing acorn

ESM as well as CommonJS is supported for all 3: acorn, acorn-walk and acorn-loose.

ESM example for acorn:

import * as acorn from "acorn"

CommonJS example for acorn:

let acorn = require("acorn")

ESM is preferred, as it allows better editor auto-completions by offering TypeScript support. For this reason, following examples will use ESM imports.

Interface

parse(input, options) is the main interface to the library. The input parameter is a string, options must be an object setting some of the options listed below. The return value will be an abstract syntax tree object as specified by the ESTree spec.

import * as acorn from "acorn"
console.log(acorn.parse("1 + 1", {ecmaVersion: 2020}))

When encountering a syntax error, the parser will raise a SyntaxError object with a meaningful message. The error object will have a pos property that indicates the string offset at which the error occurred, and a loc object that contains a {line, column} object referring to that same position.

Options are provided by in a second argument, which should be an object containing any of these fields (only ecmaVersion is required):

  • ecmaVersion: Indicates the ECMAScript version to parse. Can be a number, either in year (2022) or plain version number (6) form, or "latest" (the latest the library supports). This influences support for strict mode, the set of reserved words, and support for new syntax features.

    NOTE: Only 'stage 4' (finalized) ECMAScript features are being implemented by Acorn. Other proposed new features must be implemented through plugins.

  • sourceType: Indicate the mode the code should be parsed in. Can be either "script", "module" or "commonjs". This influences global strict mode and parsing of import and export declarations.

    NOTE: If set to "module", then static import / export syntax will be valid, even if ecmaVersion is less than 6. If set to "commonjs", it is the same as "script" except that the top-level scope behaves like a function.

  • onInsertedSemicolon: If given a callback, that callback will be called whenever a missing semicolon is inserted by the parser. The callback will be given the character offset of the point where the semicolon is inserted as argument, and if locations is on, also a {line, column} object representing this position.

  • onTrailingComma: Like onInsertedSemicolon, but for trailing commas.

  • allowReserved: If false, using a reserved word will generate an error. Defaults to true for ecmaVersion 3, false for higher versions. When given the value "never", reserved words and keywords can also not be used as property names (as in Internet Explorer's old parser).

  • allowReturnOutsideFunction: By default, a return statement at the top level raises an error. Set this to true to accept such code.

  • allowImportExportEverywhere: By default, import and export declarations can only appear at a program's top level. Setting this option to true allows them anywhere where a statement is allowed, and also allows import.meta expressions to appear in scripts (when sourceType is not "module").

  • allowAwaitOutsideFunction: If false, await expressions can only appear inside async functions. Defaults to true in modules for ecmaVersion 2022 and later, false for lower versions. Setting this option to true allows to have top-level await expressions. They are still not allowed in non-async functions, though. Setting this option to true is not allowed when sourceType: "commonjs".

  • allowSuperOutsideMethod: By default, super outside a method raises an error. Set this to true to accept such code.

  • allowHashBang: When this is enabled, if the code starts with the characters #! (as in a shellscript), the first line will be treated as a comment. Defaults to true when ecmaVersion >= 2023.

  • checkPrivateFields: By default, the parser will verify that private properties are only used in places where they are valid and have been declared. Set this to false to turn such checks off.

  • locations: When true, each node has a loc object attached with start and end subobjects, each of which contains the one-based line and zero-based column numbers in {line, column} form. Default is false.

  • onToken: If a function is passed for this option, each found token will be passed in same format as tokens returned from tokenizer().getToken().

    If array is passed, each found token is pushed to it.

    Note that you are not allowed to call the parser from the callback—that will corrupt its internal state.

  • onComment: If a function is passed for this option, whenever a comment is encountered the function will be called with the following parameters:

    • block: true if the comment is a block comment, false if it is a line comment.
    • text: The content of the comment.
    • start: Character offset of the start of the comment.
    • end: Character offset of the end of the comment.

    When the locations options is on, the {line, column} locations of the comment’s start and end are passed as two additional parameters.

    If array is passed for this option, each found comment is pushed to it as object in Esprima format:

    {
  "type": "Line" | "Block",
  "value": "comment text",
  "start": Number,
  "end": Number,
  // If `locations` option is on:
  "loc": {
    "start": {line: Number, column: Number}
    "end": {line: Number, column: Number}
  },
  // If `ranges` option is on:
  "range": [Number, Number]
}

    Note that you are not allowed to call the parser from the callback—that will corrupt its internal state.

  • ranges: Nodes have their start and end characters offsets recorded in start and end properties (directly on the node, rather than the loc object, which holds line/column data. To also add a semi-standardized range property holding a [start, end] array with the same numbers, set the ranges option to true.

  • program: It is possible to parse multiple files into a single AST by passing the tree produced by parsing the first file as the program option in subsequent parses. This will add the toplevel forms of the parsed file to the "Program" (top) node of an existing parse tree.

  • sourceFile: When the locations option is true, you can pass this option to add a source attribute in every node’s loc object. Note that the contents of this option are not examined or processed in any way; you are free to use whatever format you choose.

  • directSourceFile: Like sourceFile, but a sourceFile property will be added (regardless of the location option) directly to the nodes, rather than the loc object.

  • preserveParens: If this option is true, parenthesized expressions are represented by (non-standard) ParenthesizedExpression nodes that have a single expression property containing the expression inside parentheses.

parseExpressionAt(input, offset, options) will parse a single expression in a string, and return its AST. It will not complain if there is more of the string left after the expression.

tokenizer(input, options) returns an object with a getToken method that can be called repeatedly to get the next token, a {start, end, type, value} object (with added loc property when the locations option is enabled and range property when the ranges option is enabled). When the token's type is tokTypes.eof, you should stop calling the method, since it will keep returning that same token forever.

Note that tokenizing JavaScript without parsing it is, in modern versions of the language, not really possible due to the way syntax is overloaded in ways that can only be disambiguated by the parse context. This package applies a bunch of heuristics to try and do a reasonable job, but you are advised to use parse with the onToken option instead of this.

In ES6 environment, returned result can be used as any other protocol-compliant iterable:

for (let token of acorn.tokenizer(str)) {
  // iterate over the tokens
}

// transform code to array of tokens:
var tokens = [...acorn.tokenizer(str)]

tokTypes holds an object mapping names to the token type objects that end up in the type properties of tokens.

getLineInfo(input, offset) can be used to get a {line, column} object for a given program string and offset.

The Parser class

Instances of the Parser class contain all the state and logic that drives a parse. It has static methods parse, parseExpressionAt, and tokenizer that match the top-level functions by the same name.

When extending the parser with plugins, you need to call these methods on the extended version of the class. To extend a parser with plugins, you can use its static extend method.

var acorn = require("acorn")
var jsx = require("acorn-jsx")
var JSXParser = acorn.Parser.extend(jsx())
JSXParser.parse("foo(<bar/>)", {ecmaVersion: 2020})

The extend method takes any number of plugin values, and returns a new Parser class that includes the extra parser logic provided by the plugins.

Command line interface

The bin/acorn utility can be used to parse a file from the command line. It accepts as arguments its input file and the following options:

  • --ecma3|--ecma5|--ecma6|--ecma7|--ecma8|--ecma9|--ecma10: Sets the ECMAScript version to parse. Default is version 9.

  • --module: Sets the parsing mode to "module". Is set to "script" otherwise.

  • --locations: Attaches a "loc" object to each node with "start" and "end" subobjects, each of which contains the one-based line and zero-based column numbers in {line, column} form.

  • --allow-hash-bang: If the code starts with the characters #! (as in a shellscript), the first line will be treated as a comment.

  • --allow-await-outside-function: Allows top-level await expressions. See the allowAwaitOutsideFunction option for more information.

  • --compact: No whitespace is used in the AST output.

  • --silent: Do not output the AST, just return the exit status.

  • --help: Print the usage information and quit.

The utility spits out the syntax tree as JSON data.

Existing plugins

npm-compare.com is an independent website designed to help developers choose the most suitable npm packages. We are not affiliated with npm, Inc, the official website for the npm registry. Note that npm is a registered trademark of npm, Inc. Please share your feedback via our GitHub repository. For more details, please refer to our Terms & Privacy.