Acorn ECMAScript Parser

The Acorn repository consists of three primary packages:

• acorn: The main JavaScript parser.
• acorn-loose: An error-tolerant parser designed to handle non-standard or broken syntax.
• acorn-walk: A utility for walking the syntax tree (AST).

Acorn supports plugins that can redefine parser behavior, add new token types, or extend tokenizer contexts.

A plugin is a function that takes a parser class and returns an extended parser class. To use multiple plugins, use the Parser.extend static method, which accepts any number of plugin functions as arguments.

Best Practice: Create the extended parser class once and reuse it for multiple parse calls to help the JavaScript engine's optimizer.

const {Parser} = require("acorn")

const MyParser = Parser.extend(
  require("acorn-jsx")(),
  require("acorn-bigint")
)
console.log(MyParser.parse("// Some bigint + JSX code"))

To build the content of the repository from source, clone the repository and run npm install.

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

The easiest way to install Acorn is using npm.

npm install acorn

Acorn supports both ESM and CommonJS. ESM is preferred as it provides better editor auto-completion via TypeScript support.

// ESM (Preferred)
import * as acorn from "acorn"

// CommonJS
let acorn = require("acorn")

The easiest way to install the error-tolerant parser is using npm.

npm install acorn-loose

The easiest way to install the Acorn AST walker is via npm.

npm install acorn-walk

To create a plugin, write a function that accepts a Parser class and returns a new class that extends it. You can override existing methods (like readToken) to implement additional functionality.

It is recommended that plugin packages export their plugin function as the default export, or export a constructor function if the plugin requires configuration parameters.

module.exports = function noisyReadToken(Parser) {
  return class extends Parser {
    readToken(code) {
      console.log("Reading a token!")
      super.readToken(code)
    }
  }
}

Every node in the Acorn AST implements the Node interface. All nodes contain:

• start: The character offset where the node begins.
• end: The character offset where the node ends.
• type: A string identifying the node type (e.g., 'Identifier', 'Literal', 'IfStatement').
• range?: An optional [number, number] array of start and end offsets (enabled via ranges: true).
• loc?: An optional SourceLocation object containing line and column information (enabled via locations: true).

The TokenType class contains several boolean and configuration properties used by the parser to disambiguate syntax:

• beforeExpr: Set on tokens that can be followed by an expression. This is used to distinguish between division (/) and regular expressions.
• startsExpr: Set on tokens that either start an expression (like a quote) or continue one (like the body of a string). This is used to check if a token ends a yield expression.
• isLoop: Marks keywords that start a loop (e.g., for, while), which helps the parser manage continue jumps to labels.
• isAssign: Marks tokens that act as assignment operators (e.g., =, +=).
• prefix / postfix: Marks unary operators as prefix or postfix.
• binop: Specifies that a token is a binary operator and carries its precedence value.