acorn

acorn

Version 8.15.0
Published 2 months ago
555 kB
No dependencies
MIT license

Install

npm i acorn

yarn add acorn

pnpm add acorn

Overview

ECMAScript parser

Index

Variables

variable defaultOptions

const defaultOptions: Options;

variable tokTypes

const tokTypes: {
    num: TokenType;
    regexp: TokenType;
    string: TokenType;
    name: TokenType;
    privateId: TokenType;
    eof: TokenType;
    bracketL: TokenType;
    bracketR: TokenType;
    braceL: TokenType;
    braceR: TokenType;
    parenL: TokenType;
    parenR: TokenType;
    comma: TokenType;
    semi: TokenType;
    colon: TokenType;
    dot: TokenType;
    question: TokenType;
    questionDot: TokenType;
    arrow: TokenType;
    template: TokenType;
    invalidTemplate: TokenType;
    ellipsis: TokenType;
    backQuote: TokenType;
    dollarBraceL: TokenType;
    eq: TokenType;
    assign: TokenType;
    incDec: TokenType;
    prefix: TokenType;
    logicalOR: TokenType;
    logicalAND: TokenType;
    bitwiseOR: TokenType;
    bitwiseXOR: TokenType;
    bitwiseAND: TokenType;
    equality: TokenType;
    relational: TokenType;
    bitShift: TokenType;
    plusMin: TokenType;
    modulo: TokenType;
    star: TokenType;
    slash: TokenType;
    starstar: TokenType;
    coalesce: TokenType;
    _break: TokenType;
    _case: TokenType;
    _catch: TokenType;
    _continue: TokenType;
    _debugger: TokenType;
    _default: TokenType;
    _do: TokenType;
    _else: TokenType;
    _finally: TokenType;
    _for: TokenType;
    _function: TokenType;
    _if: TokenType;
    _return: TokenType;
    _switch: TokenType;
    _throw: TokenType;
    _try: TokenType;
    _var: TokenType;
    _const: TokenType;
    _while: TokenType;
    _with: TokenType;
    _new: TokenType;
    _this: TokenType;
    _super: TokenType;
    _class: TokenType;
    _extends: TokenType;
    _export: TokenType;
    _import: TokenType;
    _null: TokenType;
    _true: TokenType;
    _false: TokenType;
    _in: TokenType;
    _instanceof: TokenType;
    _typeof: TokenType;
    _void: TokenType;
    _delete: TokenType;
};

variable version

const version: string;

Functions

function getLineInfo

getLineInfo: (input: string, offset: number) => Position;

function parse

parse: (input: string, options: Options) => Program;

function parseExpressionAt

parseExpressionAt: (input: string, pos: number, options: Options) => Expression;

function tokenizer

tokenizer: (
    input: string,
    options: Options
) => { getToken(): Token; [Symbol.iterator](): Iterator<Token> };

Classes

class Parser

class Parser {}

constructor

protected constructor(options: Options, input: string, startPos?: number);

property input

input: string;

property options

options: Options;

method extend

static extend: (
    ...plugins: ((BaseParser: typeof Parser) => typeof Parser)[]
) => typeof Parser;

method parse

static parse: (input: string, options: Options) => Program;

method parseExpressionAt

static parseExpressionAt: (
    input: string,
    pos: number,
    options: Options
) => Expression;

method tokenizer

static tokenizer: (
    input: string,
    options: Options
) => { getToken(): Token; [Symbol.iterator](): Iterator<Token> };

class Token

class Token {}

property end

end: number;

property loc

loc?: SourceLocation;

property range

range?: [number, number];

property start

start: number;

property type

type: TokenType;

class TokenType

class TokenType {}

property keyword

keyword: string;

property label

label: string;

Interfaces

interface AnonymousClassDeclaration

interface AnonymousClassDeclaration extends Class {}

property id

id: null;

property type

type: 'ClassDeclaration';

interface AnonymousFunctionDeclaration

interface AnonymousFunctionDeclaration extends Function {}

property body

body: BlockStatement;

property id

id: null;

property type

type: 'FunctionDeclaration';

interface ArrayExpression

interface ArrayExpression extends Node {}

property elements

elements: Array<Expression | SpreadElement | null>;

property type

type: 'ArrayExpression';

interface ArrayPattern

interface ArrayPattern extends Node {}

property elements

elements: Array<Pattern | null>;

property type

type: 'ArrayPattern';

interface ArrowFunctionExpression

interface ArrowFunctionExpression extends Function {}

property type

type: 'ArrowFunctionExpression';

interface AssignmentExpression

interface AssignmentExpression extends Node {}

property left

left: Pattern;

property operator

operator: AssignmentOperator;

property right

right: Expression;

property type

type: 'AssignmentExpression';

interface AssignmentPattern

interface AssignmentPattern extends Node {}

property left

left: Pattern;

property right

right: Expression;

property type

type: 'AssignmentPattern';

interface AssignmentProperty

interface AssignmentProperty extends Node {}

property computed

computed: boolean;

property key

key: Expression;

property kind

kind: 'init';

property method

method: false;

property shorthand

shorthand: boolean;

property type

type: 'Property';

property value

value: Pattern;

interface AwaitExpression

interface AwaitExpression extends Node {}

property argument

argument: Expression;

property type

type: 'AwaitExpression';

interface BinaryExpression

interface BinaryExpression extends Node {}

property left

left: Expression | PrivateIdentifier;

property operator

operator: BinaryOperator;

property right

right: Expression;

property type

type: 'BinaryExpression';

interface BlockStatement

interface BlockStatement extends Node {}

property body

body: Array<Statement>;

property type

type: 'BlockStatement';

interface BreakStatement

interface BreakStatement extends Node {}

property label

label?: Identifier | null;

property type

type: 'BreakStatement';

interface CallExpression

interface CallExpression extends Node {}

property arguments

arguments: Array<Expression | SpreadElement>;

property callee

callee: Expression | Super;

property optional

optional: boolean;

property type

type: 'CallExpression';

interface CatchClause

interface CatchClause extends Node {}

property body

body: BlockStatement;

property param

param?: Pattern | null;

property type

type: 'CatchClause';

interface ChainExpression

interface ChainExpression extends Node {}

property expression

expression: MemberExpression | CallExpression;

property type

type: 'ChainExpression';

interface Class

interface Class extends Node {}

property body

body: ClassBody;

property id

id?: Identifier | null;

property superClass

superClass?: Expression | null;

interface ClassBody

interface ClassBody extends Node {}

property body

body: Array<MethodDefinition | PropertyDefinition | StaticBlock>;

property type

type: 'ClassBody';

interface ClassDeclaration

interface ClassDeclaration extends Class {}

property id

id: Identifier;

property type

type: 'ClassDeclaration';

interface ClassExpression

interface ClassExpression extends Class {}

property type

type: 'ClassExpression';

interface Comment

interface Comment {}

property end

end: number;

property loc

loc?: SourceLocation;

property range

range?: [number, number];

property start

start: number;

property type

type: 'Line' | 'Block';

property value

value: string;

interface ConditionalExpression

interface ConditionalExpression extends Node {}

property alternate

alternate: Expression;

property consequent

consequent: Expression;

property test

test: Expression;

property type

type: 'ConditionalExpression';

interface ContinueStatement

interface ContinueStatement extends Node {}

property label

label?: Identifier | null;

property type

type: 'ContinueStatement';

interface DebuggerStatement

interface DebuggerStatement extends Node {}

property type

type: 'DebuggerStatement';

interface DoWhileStatement

interface DoWhileStatement extends Node {}

property body

body: Statement;

property test

test: Expression;

property type

type: 'DoWhileStatement';

interface EmptyStatement

interface EmptyStatement extends Node {}

property type

type: 'EmptyStatement';

interface ExportAllDeclaration

interface ExportAllDeclaration extends Node {}

property attributes

attributes: Array<ImportAttribute>;

property exported

exported?: Identifier | Literal | null;

property source

source: Literal;

property type

type: 'ExportAllDeclaration';

interface ExportDefaultDeclaration

interface ExportDefaultDeclaration extends Node {}

property declaration

declaration:
    | AnonymousFunctionDeclaration
    | FunctionDeclaration
    | AnonymousClassDeclaration
    | ClassDeclaration
    | Expression;

property type

type: 'ExportDefaultDeclaration';

interface ExportNamedDeclaration

interface ExportNamedDeclaration extends Node {}

property attributes

attributes: Array<ImportAttribute>;

property declaration

declaration?: Declaration | null;

property source

source?: Literal | null;

property specifiers

specifiers: Array<ExportSpecifier>;

property type

type: 'ExportNamedDeclaration';

interface ExportSpecifier

interface ExportSpecifier extends Node {}

property exported

exported: Identifier | Literal;

property local

local: Identifier | Literal;

property type

type: 'ExportSpecifier';

interface ExpressionStatement

interface ExpressionStatement extends Node {}

property directive

directive?: string;

property expression

expression: Expression | Literal;

property type

type: 'ExpressionStatement';

interface ForInStatement

interface ForInStatement extends Node {}

property body

body: Statement;

property left

left: VariableDeclaration | Pattern;

property right

right: Expression;

property type

type: 'ForInStatement';

interface ForOfStatement

interface ForOfStatement extends Node {}

property await

await: boolean;

property body

body: Statement;

property left

left: VariableDeclaration | Pattern;

property right

right: Expression;

property type

type: 'ForOfStatement';

interface ForStatement

interface ForStatement extends Node {}

property body

body: Statement;

property init

init?: VariableDeclaration | Expression | null;

property test

test?: Expression | null;

property type

type: 'ForStatement';

property update

update?: Expression | null;

interface Function

interface Function extends Node {}

property async

async: boolean;

property body

body: BlockStatement | Expression;

property expression

expression: boolean;

property generator

generator: boolean;

property id

id?: Identifier | null;

property params

params: Array<Pattern>;

interface FunctionDeclaration

interface FunctionDeclaration extends Function {}

property body

body: BlockStatement;

property id

id: Identifier;

property type

type: 'FunctionDeclaration';

interface FunctionExpression

interface FunctionExpression extends Function {}

property body

body: BlockStatement;

property type

type: 'FunctionExpression';

interface Identifier

interface Identifier extends Node {}

property name

name: string;

property type

type: 'Identifier';

interface IfStatement

interface IfStatement extends Node {}

property alternate

alternate?: Statement | null;

property consequent

consequent: Statement;

property test

test: Expression;

property type

type: 'IfStatement';

interface ImportAttribute

interface ImportAttribute extends Node {}

property key

key: Identifier | Literal;

property type

type: 'ImportAttribute';

property value

value: Literal;

interface ImportDeclaration

interface ImportDeclaration extends Node {}

property attributes

attributes: Array<ImportAttribute>;

property source

source: Literal;

property specifiers

specifiers: Array<
    ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier
>;

property type

type: 'ImportDeclaration';

interface ImportDefaultSpecifier

interface ImportDefaultSpecifier extends Node {}

property local

local: Identifier;

property type

type: 'ImportDefaultSpecifier';

interface ImportExpression

interface ImportExpression extends Node {}

property options

options: Expression | null;

property source

source: Expression;

property type

type: 'ImportExpression';

interface ImportNamespaceSpecifier

interface ImportNamespaceSpecifier extends Node {}

property local

local: Identifier;

property type

type: 'ImportNamespaceSpecifier';

interface ImportSpecifier

interface ImportSpecifier extends Node {}

property imported

imported: Identifier | Literal;

property local

local: Identifier;

property type

type: 'ImportSpecifier';

interface LabeledStatement

interface LabeledStatement extends Node {}

property body

body: Statement;

property label

label: Identifier;

property type

type: 'LabeledStatement';

interface Literal

interface Literal extends Node {}

property bigint

bigint?: string;

property raw

raw?: string;

property regex

regex?: {
    pattern: string;
    flags: string;
};

property type

type: 'Literal';

property value

value?: string | boolean | null | number | RegExp | bigint;

interface LogicalExpression

interface LogicalExpression extends Node {}

property left

left: Expression;

property operator

operator: LogicalOperator;

property right

right: Expression;

property type

type: 'LogicalExpression';

interface MemberExpression

interface MemberExpression extends Node {}

property computed

computed: boolean;

property object

object: Expression | Super;

property optional

optional: boolean;

property property

property: Expression | PrivateIdentifier;

property type

type: 'MemberExpression';

interface MetaProperty

interface MetaProperty extends Node {}

property meta

meta: Identifier;

property property

property: Identifier;

property type

type: 'MetaProperty';

interface MethodDefinition

interface MethodDefinition extends Node {}

property computed

computed: boolean;

property key

key: Expression | PrivateIdentifier;

property kind

kind: 'constructor' | 'method' | 'get' | 'set';

property static

static: boolean;

property type

type: 'MethodDefinition';

property value

value: FunctionExpression;

interface NewExpression

interface NewExpression extends Node {}

property arguments

arguments: Array<Expression | SpreadElement>;

property callee

callee: Expression;

property type

type: 'NewExpression';

interface Node

interface Node {}

property end

end: number;

property loc

loc?: SourceLocation | null;

property range

range?: [number, number];

property start

start: number;

property type

type: string;

interface NodeTypes

interface NodeTypes {}

This interface is only used for defining AnyNode. It exists so that it can be extended by plugins:

Example 1

declare module 'acorn' {
  interface NodeTypes {
    pluginName: FirstNode | SecondNode | ThirdNode | ... | LastNode
  }
}

property core

core:
    | Statement
    | Expression
    | Declaration
    | ModuleDeclaration
    | Literal
    | Program
    | SwitchCase
    | CatchClause
    | Property
    | Super
    | SpreadElement
    | TemplateElement
    | AssignmentProperty
    | ObjectPattern
    | ArrayPattern
    | RestElement
    | AssignmentPattern
    | ClassBody
    | MethodDefinition
    | MetaProperty
    | ImportAttribute
    | ImportSpecifier
    | ImportDefaultSpecifier
    | ImportNamespaceSpecifier
    | ExportSpecifier
    | AnonymousFunctionDeclaration
    | AnonymousClassDeclaration
    | PropertyDefinition
    | PrivateIdentifier
    | StaticBlock
    | VariableDeclarator;

interface ObjectExpression

interface ObjectExpression extends Node {}

property properties

properties: Array<Property | SpreadElement>;

property type

type: 'ObjectExpression';

interface ObjectPattern

interface ObjectPattern extends Node {}

property properties

properties: Array<AssignmentProperty | RestElement>;

property type

type: 'ObjectPattern';

interface Options

interface Options {}

property allowAwaitOutsideFunction

allowAwaitOutsideFunction?: boolean;

By default, await identifiers are allowed to appear at the top-level scope only if ecmaVersion >= 2022. When enabled, await identifiers are allowed to appear at the top-level scope, but they are still not allowed in non-async functions.

property allowHashBang

allowHashBang?: boolean;

When enabled, hashbang directive in the beginning of file is allowed and treated as a line comment. Enabled by default when ecmaVersion >= 2023.

property allowImportExportEverywhere

allowImportExportEverywhere?: boolean;

When enabled, import/export statements are not constrained to appearing at the top of the program, and an import.meta expression in a script isn't considered an error.

property allowReserved

allowReserved?: boolean | 'never';

By default, reserved words are only enforced if ecmaVersion >= 5. Set allowReserved to a boolean value to explicitly turn this on an off. When this option has the value "never", reserved words and keywords can also not be used as property names.

property allowReturnOutsideFunction

allowReturnOutsideFunction?: boolean;

When enabled, a return at the top level is not considered an error.

property allowSuperOutsideMethod

allowSuperOutsideMethod?: boolean;

When enabled, super identifiers are not constrained to appearing in methods and do not raise an error when they appear elsewhere.

property checkPrivateFields

checkPrivateFields?: boolean;

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.

property directSourceFile

directSourceFile?: string;

This value, if given, is stored in every node, whether locations is on or off.

property ecmaVersion

ecmaVersion: ecmaVersion;

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.

property locations

locations?: boolean;

When locations is on, loc properties holding objects with start and end properties as Position objects will be attached to the nodes.

property onComment

onComment?:
    | ((
          isBlock: boolean,
          text: string,
          start: number,
          end: number,
          startLoc?: Position,
          endLoc?: Position
      ) => void)
    | Comment[];

This takes a export function or an array.
When a export function is passed, Acorn will call that export function with `(block, text, start, end) parameters whenever a comment is skipped. block` is a boolean indicating whether this is a block (/* *\/) comment, text is the content of the comment, and start and end are character offsets that denote the start and end of the comment. When the locations option is on, two more parameters are passed, the full locations of Position export type of the start and end of the comments.
When a array is passed, each found comment of Comment export type is pushed to the array.
Note that you are not allowed to call the parser from the callback—that will corrupt its internal state.

property onInsertedSemicolon

onInsertedSemicolon?: (lastTokEnd: number, lastTokEndLoc?: Position) => void;

a callback that will be called when a semicolon is automatically inserted.
Parameter lastTokEnd
the position of the comma as an offset
Parameter lastTokEndLoc
location if locations is enabled

property onToken

onToken?: ((token: Token) => void) | Token[];

a callback that will cause Acorn to call that export function with object in the same format as tokens returned from tokenizer().getToken(). Note that you are not allowed to call the parser from the callback—that will corrupt its internal state.

property onTrailingComma

onTrailingComma?: (lastTokEnd: number, lastTokEndLoc?: Position) => void;

similar to onInsertedSemicolon, but for trailing commas
Parameter lastTokEnd
the position of the comma as an offset
Parameter lastTokEndLoc
location if locations is enabled

property preserveParens

preserveParens?: boolean;

When enabled, parenthesized expressions are represented by (non-standard) ParenthesizedExpression nodes

property program

program?: Node;

It is possible to parse multiple files into a single AST by passing the tree produced by parsing the first file as 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.

property ranges

ranges?: boolean;

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] range property holding a `[start, end] array with the same numbers, set the ranges` option to true.

property sourceFile

sourceFile?: string;

When locations is on, you can pass this to record the source file in every node's loc object.

property sourceType

sourceType?: 'script' | 'module';

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

interface ParenthesizedExpression

interface ParenthesizedExpression extends Node {}

property expression

expression: Expression;

property type

type: 'ParenthesizedExpression';

interface Position

interface Position {}

property column

column: number;

0-based

property line

line: number;

1-based

interface PrivateIdentifier

interface PrivateIdentifier extends Node {}

property name

name: string;

property type

type: 'PrivateIdentifier';

interface Program

interface Program extends Node {}

property body

body: Array<Statement | ModuleDeclaration>;

property sourceType

sourceType: 'script' | 'module';

property type

type: 'Program';

interface Property

interface Property extends Node {}

property computed

computed: boolean;

property key

key: Expression;

property kind

kind: 'init' | 'get' | 'set';

property method

method: boolean;

property shorthand

shorthand: boolean;

property type

type: 'Property';

property value

value: Expression;

interface PropertyDefinition

interface PropertyDefinition extends Node {}

property computed

computed: boolean;

property key

key: Expression | PrivateIdentifier;

property static

static: boolean;

property type

type: 'PropertyDefinition';

property value

value?: Expression | null;

interface RestElement

interface RestElement extends Node {}

property argument

argument: Pattern;

property type

type: 'RestElement';

interface ReturnStatement

interface ReturnStatement extends Node {}

property argument

argument?: Expression | null;

property type

type: 'ReturnStatement';

interface SequenceExpression

interface SequenceExpression extends Node {}

property expressions

expressions: Array<Expression>;

property type

type: 'SequenceExpression';

interface SourceLocation

interface SourceLocation {}

property end

end: Position;

property source

source?: string | null;

property start

start: Position;

interface SpreadElement

interface SpreadElement extends Node {}

property argument

argument: Expression;

property type

type: 'SpreadElement';

interface StaticBlock

interface StaticBlock extends Node {}

property body

body: Array<Statement>;

property type

type: 'StaticBlock';

interface Super

interface Super extends Node {}

property type

type: 'Super';

interface SwitchCase

interface SwitchCase extends Node {}

property consequent

consequent: Array<Statement>;

property test

test?: Expression | null;

property type

type: 'SwitchCase';

interface SwitchStatement

interface SwitchStatement extends Node {}

property cases

cases: Array<SwitchCase>;

property discriminant

discriminant: Expression;

property type

type: 'SwitchStatement';

interface TaggedTemplateExpression

interface TaggedTemplateExpression extends Node {}

property quasi

quasi: TemplateLiteral;

property tag

tag: Expression;

property type

type: 'TaggedTemplateExpression';

interface TemplateElement

interface TemplateElement extends Node {}

property tail

tail: boolean;

property type

type: 'TemplateElement';

property value

value: {
    cooked?: string | null;
    raw: string;
};

interface TemplateLiteral

interface TemplateLiteral extends Node {}

property expressions

expressions: Array<Expression>;

property quasis

quasis: Array<TemplateElement>;

property type

type: 'TemplateLiteral';

interface ThisExpression

interface ThisExpression extends Node {}

property type

type: 'ThisExpression';

interface ThrowStatement

interface ThrowStatement extends Node {}

property argument

argument: Expression;

property type

type: 'ThrowStatement';

interface TryStatement

interface TryStatement extends Node {}

property block

block: BlockStatement;

property finalizer

finalizer?: BlockStatement | null;

property handler

handler?: CatchClause | null;

property type

type: 'TryStatement';

interface UnaryExpression

interface UnaryExpression extends Node {}

property argument

argument: Expression;

property operator

operator: UnaryOperator;

property prefix

prefix: boolean;

property type

type: 'UnaryExpression';

interface UpdateExpression

interface UpdateExpression extends Node {}

property argument

argument: Expression;

property operator

operator: UpdateOperator;

property prefix

prefix: boolean;

property type

type: 'UpdateExpression';

interface VariableDeclaration

interface VariableDeclaration extends Node {}

property declarations

declarations: Array<VariableDeclarator>;

property kind

kind: 'var' | 'let' | 'const' | 'using' | 'await using';

property type

type: 'VariableDeclaration';

interface VariableDeclarator

interface VariableDeclarator extends Node {}

property id

id: Pattern;

property init

init?: Expression | null;

property type

type: 'VariableDeclarator';

interface WhileStatement

interface WhileStatement extends Node {}

property body

body: Statement;

property test

test: Expression;

property type

type: 'WhileStatement';

interface WithStatement

interface WithStatement extends Node {}

property body

body: Statement;

property object

object: Expression;

property type

type: 'WithStatement';

interface YieldExpression

interface YieldExpression extends Node {}

property argument

argument?: Expression | null;

property delegate

delegate: boolean;

property type

type: 'YieldExpression';

Type Aliases

type AnyNode

type AnyNode = NodeTypes[keyof NodeTypes];

type AssignmentOperator

type AssignmentOperator =
    | '='
    | '+='
    | '-='
    | '*='
    | '/='
    | '%='
    | '<<='
    | '>>='
    | '>>>='
    | '|='
    | '^='
    | '&='
    | '**='
    | '||='
    | '&&='
    | '??=';

type BinaryOperator

type BinaryOperator =
    | '=='
    | '!='
    | '==='
    | '!=='
    | '<'
    | '<='
    | '>'
    | '>='
    | '<<'
    | '>>'
    | '>>>'
    | '+'
    | '-'
    | '*'
    | '/'
    | '%'
    | '|'
    | '^'
    | '&'
    | 'in'
    | 'instanceof'
    | '**';

type Declaration

type Declaration = FunctionDeclaration | VariableDeclaration | ClassDeclaration;

type ecmaVersion

type ecmaVersion =
    | 3
    | 5
    | 6
    | 7
    | 8
    | 9
    | 10
    | 11
    | 12
    | 13
    | 14
    | 15
    | 16
    | 17
    | 2015
    | 2016
    | 2017
    | 2018
    | 2019
    | 2020
    | 2021
    | 2022
    | 2023
    | 2024
    | 2025
    | 2026
    | 'latest';

type Expression

type Expression =
    | Identifier
    | Literal
    | ThisExpression
    | ArrayExpression
    | ObjectExpression
    | FunctionExpression
    | UnaryExpression
    | UpdateExpression
    | BinaryExpression
    | AssignmentExpression
    | LogicalExpression
    | MemberExpression
    | ConditionalExpression
    | CallExpression
    | NewExpression
    | SequenceExpression
    | ArrowFunctionExpression
    | YieldExpression
    | TemplateLiteral
    | TaggedTemplateExpression
    | ClassExpression
    | MetaProperty
    | AwaitExpression
    | ChainExpression
    | ImportExpression
    | ParenthesizedExpression;

type LogicalOperator

type LogicalOperator = '||' | '&&' | '??';

type ModuleDeclaration

type ModuleDeclaration =
    | ImportDeclaration
    | ExportNamedDeclaration
    | ExportDefaultDeclaration
    | ExportAllDeclaration;

type Pattern

type Pattern =
    | Identifier
    | MemberExpression
    | ObjectPattern
    | ArrayPattern
    | RestElement
    | AssignmentPattern;

type Statement

type Statement =
    | ExpressionStatement
    | BlockStatement
    | EmptyStatement
    | DebuggerStatement
    | WithStatement
    | ReturnStatement
    | LabeledStatement
    | BreakStatement
    | ContinueStatement
    | IfStatement
    | SwitchStatement
    | ThrowStatement
    | TryStatement
    | WhileStatement
    | DoWhileStatement
    | ForStatement
    | ForInStatement
    | ForOfStatement
    | Declaration;

type UnaryOperator

type UnaryOperator = '-' | '+' | '!' | '~' | 'typeof' | 'void' | 'delete';

type UpdateOperator

type UpdateOperator = '++' | '--';

Package Files (1)

dist/acorn.d.ts

Dependencies (0)

No dependencies.

Dev Dependencies (0)

No dev dependencies.

Peer Dependencies (0)

No peer dependencies.

Badge

To add a badge like this oneto your package's README, use the codes available below.

You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/acorn.

Markdown

[![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/acorn)

HTML

<a href="https://www.jsdocs.io/package/acorn"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>

Updated 2 months ago.
Package analyzed in 6330 ms.
Missing or incorrect documentation? Open an issue for this package.