跳到主要内容

@babel/parser

The Babel parser (previously Babylon) is a JavaScript parser used in Babel.

  • The latest ECMAScript version enabled by default (ES2020).
  • Comment attachment.
  • Support for JSX, Flow, TypeScript.
  • Support for experimental language proposals (accepting PRs for anything at least stage-0).

Credits​

Heavily based on acorn and acorn-jsx, thanks to the awesome work of @RReverser and @marijnh.

API​

babelParser.parse(code, [options])​

babelParser.parseExpression(code, [options])​

parse() parses the provided code as an entire ECMAScript program, while parseExpression() tries to parse a single Expression with performance in mind. When in doubt, use .parse().

Options​

History
VersionChanges
v7.26.0Added startIndex
v7.23.0Added createImportExpressions
v7.21.0Added allowNewTargetOutsideFunction and annexB
v7.16.0Added startColumn
v7.15.0Added attachComment
v7.7.0Added errorRecovery
v7.5.0Added allowUndeclaredExports
v7.2.0Added createParenthesizedExpressions

  • 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.

  • allowAwaitOutsideFunction: By default, await use is only allowed inside of an async function or, when the topLevelAwait plugin is enabled, in the top-level scope of modules. Set this to true to also accept it in the top-level scope of scripts. This option is discouraged in favor of topLevelAwait plugin.

  • allowNewTargetOutsideFunction: By default, new.target use is not allowed outside of a function or class. Set this to true to accept such code.

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

  • allowSuperOutsideMethod: By default, super use is not allowed outside of class and object methods. Set this to true to accept such code.

  • allowUndeclaredExports: By default, exporting an identifier that was not declared in the current module scope will raise an error. While this behavior is required by the ECMAScript modules specification, Babel's parser cannot anticipate transforms later in the plugin pipeline that might insert the appropriate declarations, so it is sometimes important to set this option to true to prevent the parser from prematurely complaining about undeclared exports that will be added later.

  • attachComment: By default, Babel attaches comments to adjacent AST nodes. When this option is set to false, comments are not attached. It can provide up to 30% performance improvement when the input code has many comments. @babel/eslint-parser will set it for you. It is not recommended to use attachComment: false with Babel transform, as doing so removes all the comments in output code, and renders annotations such as /* istanbul ignore next */ nonfunctional.

  • annexB: By default, Babel parses JavaScript according to ECMAScript's Annex B "Additional ECMAScript Features for Web Browsers" syntax. When this option is set to false, Babel will parse syntax without the extensions specific to Annex B.

  • createImportExpressions: By default, the parser parses dynamic import import() as call expression nodes. When this option is set to true, ImportExpression AST nodes are created instead. This option will default to true in Babel 8.

  • createParenthesizedExpressions: By default, the parser sets extra.parenthesized on the expression nodes. When this option is set to true, ParenthesizedExpression AST nodes are created instead.

  • errorRecovery: By default, Babel always throws an error when it finds some invalid code. When this option is set to true, it will store the parsing error and try to continue parsing the invalid input file. The resulting AST will have an errors property representing an array of all the parsing errors. Note that even when this option is enabled, @babel/parser could throw for unrecoverable errors.

  • plugins: Array containing the plugins that you want to enable.

  • sourceType: Indicate the mode the code should be parsed in. Can be one of "script", "module", or "unambiguous". Defaults to "script". "unambiguous" will make @babel/parser attempt to guess, based on the presence of ES6 import or export statements. Files with ES6 imports and exports are considered "module" and are otherwise "script".

  • sourceFilename: Correlate output AST nodes with their source filename. Useful when generating code and source maps from the ASTs of multiple input files.

  • startColumn: By default, the parsed code is treated as if it starts from line 1, column 0. You can provide a column number to alternatively start with. Useful for integration with other source tools.

  • startLine: By default, the parsed code is treated as if it starts from line 1, column 0. You can provide a line number to alternatively start with. Useful for integration with other source tools.

  • startIndex: By default, all source indexes start from 0. With this option you can provide an alternative start index. To ensure accurate AST source indexes this option should always be provided when startLine is greater than 1. Useful for integration with other source tools.

  • strictMode: By default, ECMAScript code is parsed as strict only if a "use strict"; directive is present or if the parsed file is an ECMAScript module. Set this option to true to always parse files in strict mode.

  • ranges: Adds a range property to each node: [node.start, node.end]

  • tokens: Adds all parsed tokens to a tokens property on the File node

Output​

The Babel parser generates AST according to Babel AST format. It is based on ESTree spec with the following deviations:

备注

The estree plugin can revert these deviations. Use it only if you are passing Babel AST to other ESTree-compliant tools.

AST for JSX code is based on Facebook JSX AST.

Semver​

The Babel Parser follows semver in most situations. The only thing to note is that some spec-compliancy bug fixes may be released under patch versions.

For example: We push a fix to early error on something like #107 - multiple default exports per file. That would be considered a bug fix even though it would cause a build to fail.

Example​

JavaScript
require("@babel/parser").parse("code", {
  // parse in strict mode and allow module declarations
  sourceType: "module",

  plugins: [
    // enable jsx and flow syntax
    "jsx",
    "flow",
  ],
});

Plugins​

Miscellaneous​

NameCode Example
estree (repo)n/a

Language extensions​

History
VersionChanges
v7.6.0Added v8intrinsic
NameCode Example
flow (repo)var a: string = "";
flowComments (docs)/*:: type Foo = {...}; */
jsx (repo)<a attr="b">{s}</a>
typescript (repo)var a: string = "";
v8intrinsic%DebugPrint(foo);

ECMAScript proposals​

History
VersionChanges
v7.23.0Added sourcePhaseImports, deferredImportEvaluation, optionalChainingAssign
v7.22.0Enabled regexpUnicodeSets by default, added importAttributes
v7.20.0Added explicitResourceManagement, importReflection
v7.17.0Added regexpUnicodeSets, destructuringPrivate, decoratorAutoAccessors
v7.15.0Added hack to the proposal option of pipelineOperator. Moved topLevelAwait, privateIn to Latest ECMAScript features
v7.14.0Added asyncDoExpressions. Moved classProperties, classPrivateProperties, classPrivateMethods, moduleStringNames to Latest ECMAScript features
v7.13.0Added moduleBlocks
v7.12.0Added classStaticBlock, moduleStringNames
v7.11.0Added decimal
v7.10.0Added privateIn
v7.9.0Added recordAndTuple
v7.7.0Added topLevelAwait
v7.4.0Added partialApplication
v7.2.0Added classPrivateMethods
NameCode Example
asyncDoExpressions (proposal)async do { await requestAPI().json() }
decimal (proposal)0.3m
decorators (proposal)
decorators-legacy		@a class A {}
decoratorAutoAccessors (proposal)class Example { @reactive accessor myBool = false; }
deferredImportEvaluation (proposal)import defer * as ns from "dep";
deprecatedImportAssert (legacy syntax of import attributes)
importAssertions (⚠️ deprecated)		import json from "./foo.json" assert { type: "json" };
destructuringPrivate (proposal)class Example { #x = 1; method() { const { #x: x } = this; } }
doExpressions (proposal)var a = do { if (true) { 'hi'; } };
explicitResourceManagement (proposal)using reader = getReader()
exportDefaultFrom (proposal)export v from "mod"
functionBind (proposal)a::b, ::console.log
functionSent (proposal)function.sent
importReflection (proposal)import module foo from "./foo.wasm";
moduleBlocks (proposal)let m = module { export let y = 1; };
optionalChainingAssign (proposal)x?.prop = 2
partialApplication (proposal)f(?, a)
pipelineOperator (proposal)a |> b
recordAndTuple (proposal)#{x: 1}, #[1, 2]
sourcePhaseImports (proposal)import source x from "./x"
throwExpressions (proposal)() => throw new Error("")

Latest ECMAScript features​

The following features are already enabled on the latest version of @babel/parser, and cannot be disabled because they are part of the language. You should enable these features only if you are using an older version.

NameCode Example
asyncGenerators (proposal)async function*() {}, for await (let a of b) {}
bigInt (proposal)100n
classProperties (proposal)class A { b = 1; }
classPrivateProperties (proposal)class A { #b = 1; }
classPrivateMethods (proposal)class A { #c() {} }
classStaticBlock (proposal)class A { static {} }
dynamicImport (proposal)import('./guy').then(a)
exportNamespaceFrom (proposal)export * as ns from "mod"
logicalAssignment (proposal)a &&= b
moduleStringNames (proposal)import { "😄" as smile } from "emoji";
nullishCoalescingOperator (proposal)a ?? b
numericSeparator (proposal)1_000_000
objectRestSpread (proposal)var a = { b, ...c };
optionalCatchBinding (proposal)try {throw 0;} catch{do();}
optionalChaining (proposal)a?.b
privateIn (proposal)#p in obj
regexpUnicodeSets (proposal)/[\p{Decimal_Number}--[0-9]]/v;
topLevelAwait (proposal)await promise in modules
importAttributes (proposal)import json from "./foo.json" with { type: "json" };

Plugins options​

History
VersionChanges
7.21.0The default behavior of the decorators' decoratorsBeforeExport option is to allow decorators either before or after the export keyword.
7.19.0The syntaxType option of the recordAndTuple plugin defaults to hash; added allowCallParenthesized option for the decorators plugin.
7.17.0Added @@ and ^^ to the topicToken option of the hack pipeline operator
7.16.0Added disallowAmbiguousJSXLike for typescript plugin. Added ^ to the topicToken option of the hack pipeline operators
7.14.0Added dts for typescript plugin
备注

When a plugin is specified multiple times, only the first options are considered.

  • decorators:

    • allowCallParenthesized (boolean, defaults to true)

      When false, disallow decorators in the @(...)() form in favor of @(...()). The stage 3 decorators proposal uses allowCallParenthesized: false.

    • decoratorsBeforeExport (boolean)

      By default decorators on exported classes can be placed either before or after the export keyword. When this option is set, decorators will only be allowed in the specified position.

      JavaScript
      // decoratorsBeforeExport: true
      @dec
      export class C {}

      // decoratorsBeforeExport: false
      export @dec class C {}
      警告

      This option is deprecated and will be removed in a future version. Code that is valid when this option is explicitly set to true or false is also valid when this option is not set.

  • optionalChainingAssign:

    • version (required, accepted values: 2023-07) This proposal is still at Stage 1, and thus it's likely that it will be affected by breaking changes. You must specify which version of the proposal you are using to ensure that Babel will continue to parse your code in a compatible way.

  • pipelineOperator:

    • proposal (required, accepted values: fsharp, hack, minimal, smart (deprecated)) There are several different proposals for the pipeline operator. This option chooses which proposal to use. See plugin-proposal-pipeline-operator for more information, including a table comparing their behavior.
    • proposal (required, accepted values: fsharp, hack) There are several different proposals for the pipeline operator. This option chooses which proposal to use. See plugin-proposal-pipeline-operator for more information, including a table comparing their behavior.
    • topicToken (required when proposal is hack, accepted values: %, #, ^, @@, ^^) The hack proposal uses a “topic” placeholder in its pipe. There are two different choices for this topic placeholder. This option chooses what token to use to refer to the topic. topicToken: "#" is incompatible with recordAndTuple with syntaxType: "hash". See plugin-proposal-pipeline-operator for more information.

  • recordAndTuple:

    • syntaxType (hash or bar, defaults to hash) There are two syntax variants for recordAndTuple. They share exactly same runtime semantics.
      SyntaxTypeRecord ExampleTuple Example
      "hash"#{ a: 1 }#[1, 2]
      "bar"{| a: 1 |}[|1, 2|]
      See Ergonomics of #{}/#[] for more information.

  • flow:

    • all (boolean, default: false) Some code has different meaning in Flow and in vanilla JavaScript. For example, foo<T>(x) is parsed as a call expression with a type argument in Flow, but as a comparison (foo < T > x) accordingly to the ECMAScript specification. By default, babel-parser parses those ambiguous constructs as Flow types only if the file starts with a // @flow pragma. Set this option to true to always parse files as if // @flow was specified.

  • typescript

  • importAttributes:

    • deprecatedAssertSyntax (boolean, defaults to false)

      When true, allow parsing an old version of the import attributes, which used the assert keyword instead of with.

      This matches the syntax originally supported by the importAssertions parser plugin.

Error codes​

History
VersionChanges
v7.14.0Added error codes

Error codes are useful for handling the errors thrown by @babel/parser.

There are two error codes, code and reasonCode.

  • code
    • Rough classification of errors (e.g. BABEL_PARSER_SYNTAX_ERROR, BABEL_PARSER_SOURCETYPE_MODULE_REQUIRED).
  • reasonCode
    • Detailed classification of errors (e.g. MissingSemicolon, VarRedeclaration).

Example of using error codes with errorRecovery:

JavaScript
const { parse } = require("@babel/parser");

const ast = parse(`a b`, { errorRecovery: true });

console.log(ast.errors[0].code); // BABEL_PARSER_SYNTAX_ERROR
console.log(ast.errors[0].reasonCode); // MissingSemicolon

FAQ​

Will the Babel parser support a plugin system?​

Previous issues: #1351, #6694.

We currently aren't willing to commit to supporting the API for plugins or the resulting ecosystem (there is already enough work maintaining Babel's own plugin system). It's not clear how to make that API effective, and it would limit our ability to refactor and optimize the codebase.

Our current recommendation for those that want to create their own custom syntax is for users to fork the parser.

To consume your custom parser, you can add a plugin to your options to call the parser via its npm package name or require it if using JavaScript,

JavaScript
const parse = require("custom-fork-of-babel-parser-on-npm-here");

module.exports = {
  plugins: [
    {
      parserOverride(code, opts) {
        return parse(code, opts);
      },
    },
  ],
};