esbuild-loader

Speed up your Webpack build withesbuild!🔥

esbuildis a JavaScript bundler written in Go that supports blazing fast ESNext & TypeScript transpilation andJS minification.

esbuild-loaderlets you harness the speed of esbuild in your Webpack build by offering faster alternatives for transpilation (eg.babel-loader/ts-loader) and minification (eg. Terser)!

Tip

Are you using TypeScript with Node.js?

Supercharge your Node.js with TypeScript support usingtsx!

tsxis a simple, lightweight, and blazing fast alternative to ts-node.

→ Learn more abouttsx

^{Already a sponsor?Join the discussion in theDevelopment repo!}

🚀 Install

npm i -D esbuild-loader

🚦 Quick Setup

To leverageesbuild-loaderin your Webpack configuration, add a new rule foresbuild-loadermatching the files you want to transform, such as.js,.jsx,.ts,or.tsx.Make sure to remove any other loaders you were using before (e.g.babel-loader/ts-loader).

Here's an example of how to set it up in yourwebpack.config.js:

module.exports = {
module: {
rules: [
-// Transpile JavaScript
-{
-test: /\.js$/,
-use: 'babel-loader'
-},
-
-// Compile TypeScript
-{
-test: /\.tsx?$/,
-use: 'ts-loader'
-},
+// Use esbuild to compile JavaScript & TypeScript
+{
+// Match `.js`, `.jsx`, `.ts` or `.tsx` files
+test: /\.[jt]sx?$/,
+loader: 'esbuild-loader',
+options: {
+// JavaScript version to compile to
+target: 'es2015'
+}
+},

// Other rules...
],
},
}

In this setup, esbuild will automatically determine how to handle each file based on its extension:

• .jsfiles will be treated as JS (no JSX allowed)
• .jsxas JSX
• .tsas TS (no TSX allowed)
• .tsxas TSX

If you want to force a specific loader on different file extensions (e.g. to allow JSX in.jsfiles), you can use theloaderoption:

{
test: /\.js$/,
loader: 'esbuild-loader',
options: {
+// Treat `.js` files as `.jsx` files
+loader: 'jsx',

// JavaScript version to transpile to
target: 'es2015'
}
}

Loader

JavaScript

esbuild-loadercan be used in-place ofbabel-loaderto transpile new JavaScript syntax into code compatible with older JavaScript engines.

While this ensures your code can run smoothly across various environments, note that it can bloat your output code (like Babel).

The default target isesnext,which means it doesn't perform any transpilations.

To specify a target JavaScript engine that only supports ES2015, use the following configuration in yourwebpack.config.js:

{
test: /\.jsx?$/,
loader: 'esbuild-loader',
options: {
+target: 'es2015',
},
}

For a detailed list of supported transpilations and versions, refer tothe esbuild documentation.

TypeScript

esbuild-loadercan be used in-place ofts-loaderto compile TypeScript.

{
// `.ts` or `.tsx` files
test:/\.tsx?$/,
loader:'esbuild-loader',
}

Important

It's possible to useloader: 'tsx'for both.tsand.tsxfiles, but this could lead to unexpected behavior as TypeScript and TSX do not have compatible syntaxes.

→ Read more

tsconfig.json

If you have atsconfig.jsonfile in your project,esbuild-loaderwill automatically load it.

If it's under a custom name, you can pass in the path viatsconfigoption:

{
test: /\.tsx?$/,
loader: 'esbuild-loader',
options: {
+tsconfig: './tsconfig.custom.json',
},
},

Behind the scenes:get-tsconfigis used to load the tsconfig, and to also resolve theextendsproperty if it exists.

ThetsconfigRawoption can be used to pass in a rawtsconfigobject, but it will not resolve theextendsproperty.

Caveats

• esbuild only supports a subset oftsconfigoptions(seeTransformOptionsinterface).

• EnableisolatedModulesto avoid mis-compilation with features like re-exporting types.

• EnableesModuleInteropto make TypeScript's type system compatible with ESM imports.

• Features that require type interpretation, such asemitDecoratorMetadataand declaration, are not supported.

→ Read more about TypeScript Caveats

tsconfig.jsonPaths

Usetsconfig-paths-webpack-pluginto add support fortsconfig.json#paths.

Sinceesbuild-loaderonly transforms code, it cannot aid Webpack with resolving paths.

Type-checking

esbuilddoes nottype check your code. And according to theesbuild FAQ,it will not be supported.

Consider these type-checking alternatives:

• Using an IDEs likeVSCodeorWebStormthat has live type-checking built in
• Runningtsc --noEmitto type check
• Integrating type-checking to your Webpack build as a separate process usingfork-ts-checker-webpack-plugin

EsbuildPlugin

Minification

Esbuild supports JavaScript minification, offering a faster alternative to traditional JS minifiers like Terser or UglifyJs. Minification is crucial for reducing file size and improving load times in web development. For a comparative analysis of its performance, refer to theseminification benchmarks.

Inwebpack.config.js:

+const { EsbuildPlugin } = require('esbuild-loader')

module.exports = {
...,

+optimization: {
+minimizer: [
+new EsbuildPlugin({
+target: 'es2015' // Syntax to transpile to (see options below for possible values)
+})
+]
+},
}

Tip

Utilizing thetargetoption allows for the use of newer JavaScript syntax, enhancing minification effectiveness.

Defining constants

Webpack'sDefinePlugincan replaced withEsbuildPluginto define global constants. This could speed up the build by removing the parsing costs associated with theDefinePlugin.

Inwebpack.config.js:

-const { DefinePlugin } = require('webpack')
+const { EsbuildPlugin } = require('esbuild-loader')

module.exports = {
//...,

plugins:[
-new DefinePlugin({
-'process.env.NODE_ENV': JSON.stringify(process.env.NODE_ENV),
-})
+new EsbuildPlugin({
+define: {
+'process.env.NODE_ENV': JSON.stringify(process.env.NODE_ENV),
+},
+}),
]
}

Transpilation

If your project does not use TypeScript, JSX, or any other syntax that requires additional configuration beyond what Webpack provides, you can useEsbuildPluginfor transpilation instead of the loader.

It will be faster because there's fewer files to process, and will produce a smaller output because polyfills will only be added once for the entire build as opposed to per file.

To utilize esbuild for transpilation, simply set thetargetoption on the plugin to specify which syntax support you want.

CSS Minification

Depending on your setup, there are two ways to minify CSS. You should already have CSS loading setup usingcss-loader.

CSS assets

If the CSS is extracted and emitted as.cssfile, you can replace CSS minification plugins likecss-minimizer-webpack-pluginwith theEsbuildPlugin.

Assuming the CSS is extracted using something likeMiniCssExtractPlugin,inwebpack.config.js:

const { EsbuildPlugin } = require('esbuild-loader')
const MiniCssExtractPlugin = require('mini-css-extract-plugin');

module.exports = {
//...,

optimization: {
minimizer: [
new EsbuildPlugin({
target: 'es2015',
+css: true // Apply minification to CSS assets
})
]
},

module: {
rules: [
{
test: /\.css$/i,
use: [
MiniCssExtractPlugin.loader,
'css-loader'
]
}
],
},

plugins: [
new MiniCssExtractPlugin()
]
}

CSS in JS

If your CSS is not emitted as a.cssfile, but rather injected with JavaScript using something likestyle-loader,you can use the loader for minification.

Inwebpack.config.js:

module.exports = {
//...,

module: {
rules: [
{
test: /\.css$/i,
use: [
'style-loader',
'css-loader',
+{
+loader: 'esbuild-loader',
+options: {
+minify: true,
+},
+},
],
},
],
},
}

Bring your own esbuild (Advanced)

esbuild-loader comes with a version of esbuild it has been tested to work with. However,esbuild has a frequent release cadence,and while we try to keep up with the important releases, it can get outdated.

To work around this, you can use theimplementationoption in the loader or the plugin to pass in your own version of esbuild (eg. a newer one).

Warning

⚠esbuild is not stable yet and can have dramatic differences across releases. Using a different version of esbuild is not guaranteed to work.

+const esbuild = require('esbuild')

module.exports = {
//...,

module: {
rules: [
{
test:...,
loader: 'esbuild-loader',
options: {
//...,
+implementation: esbuild,
},
},
],
},
}

Setup examples

If you'd like to see working Webpack builds that use esbuild-loader for basic JS, React, TypeScript, Next.js, etc. check out the examples repo:

→ esbuild-loader examples

⚙️ Options

Loader

The loader supportsall Transform options from esbuild.

Note:

• Source-maps are automatically configured for you viadevtool.sourcemap/sourcefileoptions are ignored.
• The roottsconfig.jsonis automatically detected for you. You don't need to pass intsconfigRawunless it's in a different path.

Here are some common configurations and custom options:

tsconfig

Type:string

Pass in the file path to acustomtsconfig file. If the file name istsconfig.json,it will automatically detect it.

target

Type:string | Array<string>

Default:'es2015'

The target environment (e.g.es2016,chrome80,esnext).

Read more about it in theesbuild docs.

loader

Type:'js' | 'jsx' | 'ts' | 'tsx' | 'css' | 'json' | 'text' | 'base64' | 'file' | 'dataurl' | 'binary' | 'default'

Default:'default'

The loader to use to handle the file. See the type forpossible values.

By default, it automatically detects the loader based on the file extension.

Read more about it in theesbuild docs.

jsxFactory

Type:string

Default:React.createElement

Customize the JSX factory function name to use.

Read more about it in theesbuild docs.

jsxFragment

Type:string

Default:React.Fragment

Customize the JSX fragment function name to use.

Read more about it in theesbuild docs.

implementation

Type:{ transform: Function }

Custom esbuild-loader option.

Use it to pass in adifferent esbuild version.

EsbuildPlugin

The loader supportsall Transform options from esbuild.

target

Type:string | Array<string>

Default:'esnext'

Target environment (e.g.'es2016',['chrome80', 'esnext'])

Read more about it in theesbuild docs.

Here are some common configurations and custom options:

format

Type:'iife' | 'cjs' | 'esm'

Default:

• iifeif both of these conditions are met:
  • Webpack'stargetis set toweb
  • esbuild'stargetis notesnext
• undefined(no format conversion) otherwise

The default isiifewhen esbuild is configured to support a low target, because esbuild injects helper functions at the top of the code. On the web, having functions declared at the top of a script can pollute the global scope. In some cases, this can lead to a variable collision error. By settingformat: 'iife',esbuild wraps the helper functions in anIIFEto prevent them from polluting the global.

Read more about it in theesbuild docs.

minify

Type:boolean

Default:true

Enable JS minification. Enables allminify*flags below.

To have nuanced control over minification, disable this and enable the specific minification you want below.

Read more about it in theesbuild docs.

minifyWhitespace

Type:boolean

Minify JS by removing whitespace.

minifyIdentifiers

Type:boolean

Minify JS by shortening identifiers.

minifySyntax

Type:boolean

Minify JS using equivalent but shorter syntax.

legalComments

Type:'none' | 'inline' | 'eof' | 'external'

Default:'inline'

Read more about it in theesbuild docs.

css

Type:boolean

Default:false

Whether to minify CSS files.

include

Type:string | RegExp | Array<string | RegExp>

To only apply the plugin to certain assets, pass in filters include

exclude

Type:string | RegExp | Array<string | RegExp>

To prevent the plugin from applying to certain assets, pass in filters to exclude

implementation

Type:{ transform: Function }

Use it to pass in adifferent esbuild version.

💡 Support

For personalized assistance, take advantage of myPriority Supportservice.

Whether it's about Webpack configuration, esbuild, or TypeScript, I'm here to guide you every step of the way!

🙋‍♀️ FAQ

Is it possible to use esbuild plugins?

No. esbuild plugins areonly available in the build API.And esbuild-loader uses the transform API instead of the build API for two reasons:

1. The build API is for creating JS bundles, which is what Webpack does. If you want to use esbuild's build API, consider using esbuild directly instead of Webpack.

2. The build API reads directly from the file-system, but Webpack loaders operate in-memory. Webpack loaders are essentially just functions that are called with the source-code as the input. Not reading from the file-system allows loaders to be chainable. For example, usingvue-loaderto compile Single File Components (.vuefiles), then usingesbuild-loaderto transpile just the JS part of the SFC.

Is it possible to use esbuild'sinjectoption?

No. Theinjectoption is only available in the build API. And esbuild-loader uses the transform API.

However, you can use the Webpack equivalentProvidePlugininstead.

If you're using React, check outthis exampleon how to auto-import React in your components.

Is it possible to use Babel plugins?

No. If you really need them, consider porting them over to a Webpack loader.

And please don't chainbabel-loaderandesbuild-loader.The speed gains come from replacingbabel-loader.

Why am I not getting a100x speed improvementas advertised?

Running esbuild as a standalone bundler vs esbuild-loader + Webpack are completely different:

• esbuild is highly optimized, written in Go, and compiled to native code. Read more about ithere.
• esbuild-loader is handled by Webpack in a JS runtime, which applies esbuild transforms per file. On top of that, there's likely other loaders & plugins in a Webpack config that slow it down.

Using a JS runtime introduces a bottleneck that makes reaching those speeds impossible. However, esbuild-loader can still speed up your build by removing the bottlenecks created bybabel-loader,ts-loader,Terser, etc.

💞 Related projects

tsx

Node.js enhanced with esbuild to run TypeScript and ESM.

instant-mocha

Webpack-integrated Mocha test-runner with Webpack 5 support.

webpack-localize-assets-plugin

Localize/i18nalize your Webpack build. Optimized for multiple locales!

Sponsors