acorn vs acorn-walk vs esprima vs estraverse vs recast
JavaScript Parsing and AST Manipulation
Search packages..
acornacorn-walkesprimaestraverserecastSimilar Packages:

JavaScript Parsing and AST Manipulation

JavaScript Parsing and AST (Abstract Syntax Tree) Manipulation libraries are tools that help developers analyze, transform, and manipulate JavaScript code programmatically. These libraries parse JavaScript code into a structured tree representation (AST), allowing for tasks like code analysis, transformation, linting, and building tools like compilers and code editors. They are essential for creating tools that understand and manipulate JavaScript code at a syntactic level.

Npm Package Weekly Downloads Trend

3 Years

Github Stars Ranking

Stat Detail

Package
Downloads
Stars
Size
Issues
Publish
License
acorn150,781,46811,339559 kB1522 days agoMIT
acorn-walk64,632,14611,33953.8 kB1522 days agoMIT
esprima07,134-1498 years agoBSD-2-Clause
estraverse0967-394 years agoBSD-2-Clause
recast05,226246 kB210a year agoMIT

Feature Comparison: acorn vs acorn-walk vs esprima vs estraverse vs recast

Parsing Performance

  • acorn:

    acorn is known for its fast parsing capabilities, making it one of the quickest parsers available for JavaScript. It is designed to be lightweight and efficient, which is beneficial for applications that require parsing large codebases or performing real-time parsing tasks.

  • esprima:

    esprima offers good parsing performance, though it is generally slower than acorn. However, it provides a more comprehensive feature set, including better error handling and support for a wider range of JavaScript syntax, which can be advantageous for tools that require detailed parsing capabilities.

  • recast:

    recast is not primarily focused on parsing speed, as its main strength lies in code transformation and pretty-printing. It uses esprima or acorn as its underlying parser, so its performance will depend on the parser used. It is best suited for projects where transformation capabilities are more critical than parsing speed.

AST Traversal

  • acorn-walk:

    acorn-walk provides a simple and efficient way to traverse the AST generated by acorn. It is lightweight and easy to use, making it ideal for projects that need straightforward tree traversal without additional complexity.

  • estraverse:

    estraverse is a more feature-rich library for AST traversal. It supports both pre-order and post-order traversal, and allows for easy modification of nodes during traversal. It is suitable for more complex traversal tasks where additional flexibility and functionality are required.

Code Transformation

  • estraverse:

    estraverse provides traversal capabilities that can be used in conjunction with other libraries to perform code transformations. However, it does not handle transformation or code generation on its own, so it is often used as a complementary tool in the transformation process.

  • recast:

    recast excels in code transformation while preserving the original formatting. It allows developers to manipulate the AST and then output the code with minimal changes to its original style. This makes it ideal for projects that require transformations but want to maintain the readability of the code.

Error Handling

  • acorn:

    acorn also provides good error handling, but it is more focused on compliance with the ECMAScript specification. While it reports errors effectively, it may not provide as much detail as esprima, especially for complex syntax errors.

  • esprima:

    esprima is known for its excellent error handling capabilities. It provides detailed error messages and supports error recovery, making it easier for developers to understand and fix issues in the code being parsed. This feature is particularly useful for tools that need to provide accurate feedback on syntax errors.

Example Code

  • acorn:

    Parsing with acorn

    import acorn from 'acorn';
const code = 'const x = 10;';
const ast = acorn.parse(code);
console.log(ast);
  • esprima:

    Parsing with esprima

    import esprima from 'esprima';
const code = 'const x = 10;';
const ast = esprima.parseScript(code);
console.log(ast);
  • recast:

    Transforming Code with recast

    import recast from 'recast';
const code = 'const x = 10;';
const ast = recast.parse(code);
const transformed = recast.print(ast).code;
console.log(transformed);

How to Choose: acorn vs acorn-walk vs esprima vs estraverse vs recast

  • acorn:

    Choose acorn if you need a fast, lightweight, and compliant JavaScript parser that generates an AST. It is suitable for projects where performance and adherence to the ECMAScript specification are critical.

  • acorn-walk:

    Opt for acorn-walk if you are using acorn and need a simple, efficient way to traverse the AST. It is perfect for projects that require lightweight tree traversal without the overhead of a full-fledged traversal library.

  • esprima:

    Select esprima if you require a full-featured, standards-compliant parser with a focus on providing detailed error messages and a rich set of features. It is ideal for tools that need comprehensive parsing capabilities and accurate error reporting.

  • estraverse:

    Use estraverse if you need a flexible and feature-rich library for traversing and manipulating ESTree-compliant ASTs. It provides a robust API for both traversal and modification, making it suitable for complex AST manipulations.

  • recast:

    Choose recast if you need a powerful tool for parsing, transforming, and pretty-printing JavaScript code while preserving the original formatting. It is ideal for projects that require code transformations with minimal changes to the original style.

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 acorn-walk

acorn-walk is a utility library designed to work with the Acorn parser, which is a small, fast JavaScript parser written in JavaScript. Acorn-walk allows developers to traverse and manipulate the abstract syntax tree (AST) generated by Acorn, making it easier to analyze and transform JavaScript code. This library is particularly useful for building tools like linters, code analyzers, and transpilers.

While acorn-walk is a powerful tool for working with JavaScript ASTs, there are several alternatives that provide similar functionality. Here are a few notable options:

  • acorn is the underlying parser that acorn-walk relies on. It is a fast and efficient JavaScript parser that generates an AST from JavaScript code. While acorn itself does not provide traversal capabilities, it serves as the foundation for acorn-walk and other libraries that build upon it. If you need a lightweight and performant parser for JavaScript, acorn is an excellent choice.
  • esprima is another popular JavaScript parser that generates an AST. It is known for its compliance with the ECMAScript specification and provides a robust parsing solution for JavaScript code. Esprima also allows for easy traversal of the generated AST, making it a suitable alternative for developers looking for a comprehensive parsing and traversal solution.
  • estraverse is a library specifically designed for traversing and manipulating ASTs in JavaScript. It works with ASTs generated by various parsers, including Acorn and Esprima. Estraverse provides a simple API for walking through the tree and applying transformations, making it a great choice for developers who need to analyze or modify JavaScript code at the AST level.
  • recast is a powerful tool for working with JavaScript code that allows for parsing, transforming, and printing code. It uses the Babel parser under the hood and provides a rich API for manipulating the AST. Recast is particularly useful for code transformations and refactoring, making it a strong alternative for developers looking to work with JavaScript code in a more comprehensive manner.

To see how these packages compare, check out the comparison: Comparing acorn vs acorn-walk 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.