@esbuild/openbsd-x64
0.28.2 · 8 Aug 2026MIT11.9M / weekRepositoryHomepagenpmAtom feed
113 stable releases, newest first, by release line. Notes are quoted as the maintainers published them.
- 0.28.x · latest line
0.28.2
8 Aug 2026Fix tree shaking bug due to TypeScript import alias
This release fixes a bug that could cause esbuild to incorrectly tree-shake imports that are used in a TypeScript type alias under certain circumstances. Affected code uses a TypeScript-specific
importassignment and looks something like this:import Base from './dep.js'; import Alias = Base.SomeType;
Fix CSS minification bug involving
&This release fixes a bug where esbuild's CSS minifier incorrectly removed a
&when it was unsafe to do so. Here is an example:/* Original code */ .a .b { & .b:not(& .c) { color: red; } } /* Old output (with --minify) */ .a .b{.b:not(& .c){color:red}} /* New output (with --minify) */ .a .b{& .b:not(& .c){color:red}}This should match
<span class="a"><span class="b"><span class="b">yes</span></span></span>but not<span class="a"><span class="b">no</span></span>. The old output incorrectly matched both.Avoid overwriting input files without
--allow-overwriteFor example:
esbuild input.js --outfile=input.jstells esbuild to overwriteinput.jswith the output of running esbuild on it. This was supposed to already be prevented by default, but it accidentally regressed in version 0.17.0 and apparently didn't have any test coverage. The error message was being printed but the input file was still being overwritten. Oops.This release puts the original behavior back. With this release, esbuild should now actually avoid overwriting input files unless
--allow-overwriteis explicitly present. This is done by not writing out any files when a build error is encountered.
Fix tree shaking bug due to TypeScript import alias
This release fixes a bug that could cause esbuild to incorrectly tree-shake imports that are used in a TypeScript type alias under certain circumstances. Affected code uses a TypeScript-specific
importassignment and looks something like this:import Base from './dep.js'; import Alias = Base.SomeType;
Fix CSS minification bug involving
&This release fixes a bug where esbuild's CSS minifier incorrectly removed a
&when it was unsafe to do so. Here is an example:/* Original code */ .a .b { & .b:not(& .c) { color: red; } } /* Old output (with --minify) */ .a .b{.b:not(& .c){color:red}} /* New output (with --minify) */ .a .b{& .b:not(& .c){color:red}}This should match
<span class="a"><span class="b"><span class="b">yes</span></span></span>but not<span class="a"><span class="b">no</span></span>. The old output incorrectly matched both.Avoid overwriting input files without
--allow-overwriteFor example:
esbuild input.js --outfile=input.jstells esbuild to overwriteinput.jswith the output of running esbuild on it. This was supposed to already be prevented by default, but it accidentally regressed in version 0.17.0 and apparently didn't have any test coverage. The error message was being printed but the input file was still being overwritten. Oops.This release puts the original behavior back. With this release, esbuild should now actually avoid overwriting input files unless
--allow-overwriteis explicitly present. This is done by not writing out any files when a build error is encountered.Fix incorrect code generated when using top-level await
Previously esbuild could generate code containing a syntax error in complex scenarios involving top-level await used in a dependency cycle. The problem was a missing
asyncon one or more module wrapper closures. With this release, esbuild now uses a fixed-point iteration algorithm to correctly annotate all dependencies in the cycle as needing anasyncmodule wrapper.Fix a minification bug with lowered logical assignment operators
This release fixes a bug that could cause esbuild to generate incorrect code for logical assignment operators when lowering them to an older target environment. Specifically the lowering process requires duplicating the left-hand side, but esbuild incorrectly failed to count the duplicate as a new usage when the left-hand side is an identifier. That then caused the minifier to believe that the left-hand side was only used once and could attempt to incorrectly inline an initializer into the first usage. This bug has now been fixed:
// Original code function foo() { let x bar(x ||= {}) } // Old output (with --minify-syntax --target=es6) function foo() { bar(void 0 || (x = {})); } // New output (with --minify-syntax --target=es6) function foo() { let x; bar(x || (x = {})); }Fix a potential deadlock when the JavaScript API is used incorrectly (#4503, #4506)
The JavaScript API runs the native esbuild executable as a long-lived child process and communicates with it over stdin/stdout/stderr. Each API request is asynchronous and the executable stays open as long as it has work to do, which is as long as either stdin is still open (meaning there may be more API requests) or there are currently requests being processed.
Previously esbuild's tracking of outstanding API requests missed decrementing a reference count in an edge case where esbuild's JavaScript API was used incorrectly and the API request returned an error. This could in some cases cause esbuild's native executable to exit with an error message about a deadlock. This release fixes the reference counting bug.
This fix was submitted
Handle target collisions
It's possible to specify the same target engine multiple times, such as with
--target=chrome1,chrome99. This edge case wasn't anticipated and previously took the last version for the duplicated target engine instead of the minimum version (sochrome99in this case instead ofchrome1). With this release, esbuild will now pick the minimum version between all duplicated target engines.Force
.mp3files to use theaudio/mpegMIME typeMIME type detection for esbuild's data URLs uses Go's built-in MIME type detection, which is based on the MIME sniffing standard. This works correctly for MP3 files that start with the byte sequence
ID3, which is commonly the case. However, it's possible to construct valid MP3 files that do not start withID3, and that perhaps Go's built-in MIME type detection doesn't implement the "Signature for MP3 without ID3" part of the algorithm. This results in some.mp3files incorrectly using theapplication/octet-streamMIME type instead ofaudio/mpeg. With this release, esbuild will now always use theaudio/mpegMIME type for files ending in.mp3.Add a new TypeScript syntax warning
TypeScript 7 turned some previously-valid TypeScript syntax into a syntax error because it was confusing. TypeScript 6 accepts
1 + 2 as number * 3as valid syntax but confusingly converts it to(1 + 2) * 3instead of the more intuitive conversion to1 + (2 * 3). This syntax is now an error in TypeScript 7+. With this release, esbuild will now warn about the use of this syntax:▲ [WARNING] Operator "*" should not directly follow a TypeScript type cast after the "+" operator [confusing-typescript-cast] example.ts:1:28: 1 │ console.log(1 + 2 as number * 3) ╵ ^ This is a syntax error in newer versions of TypeScript because the type cast has unintuitive precedence in this case. Surround the inner expression in parentheses to silence this warning: example.ts:1:12: 1 │ console.log(1 + 2 as number * 3) │ ~~~~~~~~~~~~~~~ ╵ ( )See microsoft/TypeScript#63527 for more information.
Add support for formatting errors for Visual Studio
Visual Studio has a specific style that it expects log messages to be in for them to show up in the UI when esbuild is run as a custom build step. The current log style that esbuild uses doesn't conform to this specific style.
With this release, esbuild has a new log style for Visual Studio (and other tools in the MSBuild ecosystem) that can be enabled with
--log-style=visualstudio. Here is an example log message in this style:$ esbuild example.ts --log-style=visualstudio /Users/evan/dev/esbuild/example.ts(1,29): warning ES0010: Operator "*" should not directly follow a TypeScript type cast after the "+" operator
This log style is also available via the JS and Go APIs, and can now be used with the existing
formatMessagesAPI.Fix a bug with CSS gamut mapping
Due to a typo, the fallback colors generated for CSS colors outside of the sRGB gamut weren't correct. This release fixes the generated colors to use the intended algorithm.
This fix was submitted
0.28.1
11 Jun 2026- Security
Disallow
\in local development server HTTP requests (GHSA-g7r4-m6w7-qqqr)This release fixes a security issue where HTTP requests to esbuild's local development server could traverse outside of the serve directory on Windows using a
\backslash character. It happened due to the use of Go'spath.Clean()function, which only handles Unix-style/characters. HTTP requests with paths containing\are no longer allowed. - Security
Add integrity checks to the Deno API (GHSA-gv7w-rqvm-qjhr)
The previous release of esbuild added integrity checks to esbuild's npm install script. This release also adds integrity checks to esbuild's Deno install script. Now esbuild's Deno API will also fail with an error if the downloaded esbuild binary contains something other than the expected content.
Note that esbuild's Deno API installs from
registry.npmjs.orgby default, but allows theNPM_CONFIG_REGISTRYenvironment variable to override this with a custom package registry. This change means that the esbuild executable served byNPM_CONFIG_REGISTRYmust now match the expected content. Avoid inlining
usingandawait usingdeclarationsPreviously esbuild's minifier sometimes incorrectly inlined
usingandawait usingdeclarations into subsequent uses of that declaration, which then fails to dispose of the resource correctly. This bug happened because inlining was done forletandconstdeclarations by avoiding doing it forvardeclarations, which no longer worked when more declaration types were added. Here's an example:// Original code { using x = new Resource() x.activate() } // Old output (with --minify) new Resource().activate(); // New output (with --minify) {using e=new Resource;e.activate()}
- Security
Disallow
\in local development server HTTP requests (GHSA-g7r4-m6w7-qqqr)This release fixes a security issue where HTTP requests to esbuild's local development server could traverse outside of the serve directory on Windows using a
\backslash character. It happened due to the use of Go'spath.Clean()function, which only handles Unix-style/characters. HTTP requests with paths containing\are no longer allowed. - Security
Add integrity checks to the Deno API (GHSA-gv7w-rqvm-qjhr)
The previous release of esbuild added integrity checks to esbuild's npm install script. This release also adds integrity checks to esbuild's Deno install script. Now esbuild's Deno API will also fail with an error if the downloaded esbuild binary contains something other than the expected content.
Note that esbuild's Deno API installs from
registry.npmjs.orgby default, but allows theNPM_CONFIG_REGISTRYenvironment variable to override this with a custom package registry. This change means that the esbuild executable served byNPM_CONFIG_REGISTRYmust now match the expected content. Avoid inlining
usingandawait usingdeclarationsPreviously esbuild's minifier sometimes incorrectly inlined
usingandawait usingdeclarations into subsequent uses of that declaration, which then fails to dispose of the resource correctly. This bug happened because inlining was done forletandconstdeclarations by avoiding doing it forvardeclarations, which no longer worked when more declaration types were added. Here's an example:// Original code { using x = new Resource() x.activate() } // Old output (with --minify) new Resource().activate(); // New output (with --minify) {using e=new Resource;e.activate()}Fix module evaluation when an error is thrown (#4461, #4467)
If an error is thrown during module evaluation, esbuild previously didn't preserve the state of the module for subsequent module references. This was observable if
import()orrequire()is used to import a module multiple times. The thrown error is supposed to be thrown by every call toimport()orrequire(), not just the first. With this release, esbuild will now throw the same error every time you callimport()orrequire()on a module that throws during its evaluation.Fix some edge cases around the
newoperatorPreviously esbuild incorrectly printed certain edge cases involving complex expressions inside the target of a
newexpression (specifically an optional chain and/or a tagged template literal). The generated code for thenewtarget was not correctly wrapped with parentheses, and either contained a syntax error or had different semantics. These edge cases have been fixed so that they now correctly wrap thenewtarget in parentheses. Here is an example of some affected code:// Original code new (foo()`bar`)() new (foo()?.bar)() // Old output new foo()`bar`(); new (foo())?.bar(); // New output new (foo())`bar`(); new (foo()?.bar)();
Fix renaming of nested
vardeclarationsThis release fixes a bug where
vardeclarations in nested scopes that are hoisted up to module scope were not correctly being renamed during bundling. That could previously lead to name collisions when minification was disabled, which could potentially cause a behavior change. The bug has been fixed so that these hoisted declarations are now considered to be module-level symbols during the name collision avoidance pass.Emit
varinstead ofconstfor certain TypeScript-only constructs for ES5While esbuild doesn't generally support converting
consttovarfor ES5 due to nested scoping rules (which is currently a build-time error), esbuild previously incorrectly converted TypeScript-onlyimportassignment constructs into aconstdeclaration even when targeting ES5. With this release, esbuild will now usevarfor this case instead:// Original code import x = require('y') // Old output (with --target=es5) const x = require("y"); // New output (with --target=es5) var x = require("y");
0.28.0
2 Apr 2026Add support for
with { type: 'text' }importsThe import text proposal has reached stage 3 in the TC39 process, which means that it's recommended for implementation. It has also already been implemented by Deno and Bun. So with this release, esbuild also adds support for it. This behaves exactly the same as esbuild's existing
textloader. Here's an example:import string from './example.txt' with { type: 'text' } console.log(string)Add integrity checks to fallback download path
Installing esbuild via npm is somewhat complicated with several different edge cases (see esbuild's documentation for details). If the regular installation of esbuild's platform-specific package fails, esbuild's install script attempts to download the platform-specific package itself (first with the
npmcommand, and then with a HTTP request toregistry.npmjs.orgas a last resort).This last resort path previously didn't have any integrity checks. With this release, esbuild will now verify that the hash of the downloaded binary matches the expected hash for the current release. This means the hashes for all of esbuild's platform-specific binary packages will now be embedded in the top-level
esbuildpackage. Hopefully this should work without any problems. But just in case, this change is being done as a breaking change release.Update the Go compiler from 1.25.7 to 1.26.1
This upgrade should not affect anything. However, there have been some significant internal changes to the Go compiler, so esbuild could potentially behave differently in certain edge cases:
You can read the Go 1.26 release notes for more information.
- 0.27.x
0.27.7
2 Apr 2026Fix lowering of define semantics for TypeScript parameter properties
The previous release incorrectly generated class fields for TypeScript parameter properties even when the configured target environment does not support class fields. With this release, the generated class fields will now be correctly lowered in this case:
// Original code class Foo { constructor(public x = 1) {} y = 2 } // Old output (with --loader=ts --target=es2021) class Foo { constructor(x = 1) { this.x = x; __publicField(this, "y", 2); } x; } // New output (with --loader=ts --target=es2021) class Foo { constructor(x = 1) { __publicField(this, "x", x); __publicField(this, "y", 2); } }
0.27.6
2 Apr 20260.27.5
2 Apr 2026Fix for an async generator edge case (#4401, #4417)
Support for transforming async generators into the equivalent state machine was added in version 0.19.0. However, the generated state machine didn't work correctly when polling async generators concurrently, such as in the following code:
async function* inner() { yield 1; yield 2 } async function* outer() { yield* inner() } let gen = outer() for await (let x of [gen.next(), gen.next()]) console.log(x)Previously esbuild's output of the above code behaved incorrectly when async generators were transformed (such as with
--supported:async-generator=false). The transformation should be fixed starting with this release.This fix was contributed
Fix a regression when
metafileis enabled (#4420, #4418)This release fixes a regression introduced by the previous release. When
metafile: truewas enabled in esbuild's JavaScript API, builds with build errors were incorrectly throwing an error about an empty JSON string instead of an object containing the build errors.Use define semantics for TypeScript parameter properties
Parameter properties are a TypeScript-specific code generation feature that converts constructor parameters into class fields when they are prefixed by certain keywords. When
"useDefineForClassFields": trueis present intsconfig.json, the TypeScript compiler automatically generates class field declarations for parameter properties. Previously esbuild didn't do this, but esbuild will now do this starting with this release:// Original code class Foo { constructor(public x: number) {} } // Old output (with --loader=ts) class Foo { constructor(x) { this.x = x; } } // New output (with --loader=ts) class Foo { constructor(x) { this.x = x; } x; }
Fix for an async generator edge case (#4401, #4417)
Support for transforming async generators into the equivalent state machine was added in version 0.19.0. However, the generated state machine didn't work correctly when polling async generators concurrently, such as in the following code:
async function* inner() { yield 1; yield 2 } async function* outer() { yield* inner() } let gen = outer() for await (let x of [gen.next(), gen.next()]) console.log(x)Previously esbuild's output of the above code behaved incorrectly when async generators were transformed (such as with
--supported:async-generator=false). The transformation should be fixed starting with this release.This fix was contributed
Fix a regression when
metafileis enabled (#4420, #4418)This release fixes a regression introduced by the previous release. When
metafile: truewas enabled in esbuild's JavaScript API, builds with build errors were incorrectly throwing an error about an empty JSON string instead of an object containing the build errors.Use define semantics for TypeScript parameter properties
Parameter properties are a TypeScript-specific code generation feature that converts constructor parameters into class fields when they are prefixed by certain keywords. When
"useDefineForClassFields": trueis present intsconfig.json, the TypeScript compiler automatically generates class field declarations for parameter properties. Previously esbuild didn't do this, but esbuild will now do this starting with this release:// Original code class Foo { constructor(public x: number) {} } // Old output (with --loader=ts) class Foo { constructor(x) { this.x = x; } } // New output (with --loader=ts) class Foo { constructor(x) { this.x = x; } x; }Allow
es2025as a target intsconfig.jsonTypeScript recently added
es2025as a compilation target, so esbuild now supports this in thetargetfield oftsconfig.jsonfiles, such as in the following configuration file:{ "compilerOptions": { "target": "ES2025" } }As a reminder, the only thing that esbuild uses this field for is determining whether or not to use legacy TypeScript behavior for class fields. You can read more in the documentation.
0.27.4
12 Mar 2026Fix a regression with CSS media queries (#4395, #4405, #4406)
Version 0.25.11 of esbuild introduced support for parsing media queries. This unintentionally introduced a regression with printing media queries that use the
<media-type> and <media-condition-without-or>grammar. Specifically, esbuild was failing to wrap anorclause with parentheses when inside<media-condition-without-or>. This release fixes the regression.Here is an example:
/* Original code */ @media only screen and ((min-width: 10px) or (min-height: 10px)) { a { color: red } } /* Old output (incorrect) */ @media only screen and (min-width: 10px) or (min-height: 10px) { a { color: red; } } /* New output (correct) */ @media only screen and ((min-width: 10px) or (min-height: 10px)) { a { color: red; } }Fix an edge case with the
injectfeatureThis release fixes an edge case where esbuild's
injectfeature could not be used with arbitrary module namespace names exported using anexport {} fromstatement with bundling disabled and a target environment where arbitrary module namespace names is unsupported.With the fix, the following
injectfile:import jquery from 'jquery'; export { jquery as 'window.jQuery' };Can now always be rewritten as this without esbuild sometimes incorrectly generating an error:
export { default as 'window.jQuery' } from 'jquery';Attempt to improve API handling of huge metafiles (#4329, #4415)
This release contains a few changes that attempt to improve the behavior of esbuild's JavaScript API with huge metafiles (esbuild's name for the build metadata, formatted as a JSON object). The JavaScript API is designed to return the metafile JSON as a JavaScript object in memory, which makes it easy to access from within a JavaScript-based plugin. Multiple people have encountered issues where this API breaks down with a pathologically-large metafile.
The primary issue is that V8 has an implementation-specific maximum string length, so using the
JSON.parseAPI with large enough strings is impossible. This release will now attempt to use a fallback JavaScript-based JSON parser that operates directly on the UTF8-encoded JSON bytes instead of usingJSON.parsewhen the JSON metafile is too big to fit in a JavaScript string. The new fallback path has not yet been heavily-tested. The metafile will also now be generated with whitespace removed if the bundle is significantly large, which will reduce the size of the metafile JSON slightly.However, hitting this case is potentially a sign that something else is wrong. Ideally you wouldn't be building something so enormous that the build metadata can't even fit inside a JavaScript string. You may want to consider optimizing your project, or breaking up your project into multiple parts that are built independently. Another option could potentially be to use esbuild's command-line API instead of its JavaScript API, which is more efficient (although of course then you can't use JavaScript plugins, so it may not be an option).
0.27.3
5 Feb 2026Preserve URL fragments in data URLs
Consider the following HTML, CSS, and SVG:
The CSS uses a URL fragment (the
#x) to reference theclipPathelement in the SVG file. Previously esbuild's CSS bundler didn't preserve the URL fragment when bundling the SVG using thedataurlloader, which broke the bundled CSS. With this release, esbuild will now preserve the URL fragment in the bundled CSS:/* icons.css */ .triangle { width: 10px; height: 10px; background: currentColor; clip-path: url('data:image/svg+xml,<svg xmlns="http://www.w3.org/2000/svg"><defs><clipPath id="x"><path d="M0 0H10V10Z"/></clipPath></defs></svg>#x'); }Parse and print CSS
@scoperulesThis release includes dedicated support for parsing
@scoperules in CSS. These rules include optional "start" and "end" selector lists. One important consequence of this is that the local/global status of names in selector lists is now respected, which improves the correctness of esbuild's support for CSS modules. Minification of selectors inside@scoperules has also improved slightly.Here's an example:
/* Original code */ @scope (:global(.foo)) to (:local(.bar)) { .bar { color: red; } } /* Old output (with --loader=local-css --minify) */ @scope (:global(.foo)) to (:local(.bar)){.o{color:red}} /* New output (with --loader=local-css --minify) */ @scope(.foo)to (.o){.o{color:red}}Fix a minification bug with lowering of
for await(#4378, #4385)This release fixes a bug where the minifier would incorrectly strip the variable in the automatically-generated
catchclause of loweredfor awaitloops. The code that generated the loop previously failed to mark the internal variable references as used.
Preserve URL fragments in data URLs
Consider the following HTML, CSS, and SVG:
index.html:<!DOCTYPE html> <html> <head><link rel="stylesheet" href="icons.css"></head> <body><div class="triangle"></div></body> </html>
icons.css:.triangle { width: 10px; height: 10px; background: currentColor; clip-path: url(./triangle.svg#x); }triangle.svg:<svg xmlns="http://www.w3.org/2000/svg"> <defs> <clipPath id="x"> <path d="M0 0H10V10Z"/> </clipPath> </defs> </svg>
The CSS uses a URL fragment (the
#x) to reference theclipPathelement in the SVG file. Previously esbuild's CSS bundler didn't preserve the URL fragment when bundling the SVG using thedataurlloader, which broke the bundled CSS. With this release, esbuild will now preserve the URL fragment in the bundled CSS:/* icons.css */ .triangle { width: 10px; height: 10px; background: currentColor; clip-path: url('data:image/svg+xml,<svg xmlns="http://www.w3.org/2000/svg"><defs><clipPath id="x"><path d="M0 0H10V10Z"/></clipPath></defs></svg>#x'); }Parse and print CSS
@scoperulesThis release includes dedicated support for parsing
@scoperules in CSS. These rules include optional "start" and "end" selector lists. One important consequence of this is that the local/global status of names in selector lists is now respected, which improves the correctness of esbuild's support for CSS modules. Minification of selectors inside@scoperules has also improved slightly.Here's an example:
/* Original code */ @scope (:global(.foo)) to (:local(.bar)) { .bar { color: red; } } /* Old output (with --loader=local-css --minify) */ @scope (:global(.foo)) to (:local(.bar)){.o{color:red}} /* New output (with --loader=local-css --minify) */ @scope(.foo)to (.o){.o{color:red}}Fix a minification bug with lowering of
for await(#4378, #4385)This release fixes a bug where the minifier would incorrectly strip the variable in the automatically-generated
catchclause of loweredfor awaitloops. The code that generated the loop previously failed to mark the internal variable references as used.Update the Go compiler from v1.25.5 to v1.25.7 (#4383, #4388)
This PR was contributed
0.27.2
17 Dec 2025Allow import path specifiers starting with
#/Previously the specification for
package.jsondisallowed import path specifiers starting with#/, but this restriction has recently been relaxed and support for it is being added across the JavaScript ecosystem. One use case is using it for a wildcard pattern such as mapping#/*to./src/*(previously you had to use another character such as#_*instead, which was more confusing). There is some more context in nodejs/node#49182.This change was contributed
Automatically add the
-webkit-maskprefix (#4357, #4358)This release automatically adds the
-webkit-vendor prefix for themaskCSS shorthand property:/* Original code */ main { mask: url(x.png) center/5rem no-repeat } /* Old output (with --target=chrome110) */ main { mask: url(x.png) center/5rem no-repeat; } /* New output (with --target=chrome110) */ main { -webkit-mask: url(x.png) center/5rem no-repeat; mask: url(x.png) center/5rem no-repeat; }This change was contributed
Additional minification of
switchstatements (#4176, #4359)This release contains additional minification patterns for reducing
switchstatements. Here is an example:// Original code switch (x) { case 0: foo() break case 1: default: bar() } // Old output (with --minify) switch(x){case 0:foo();break;case 1:default:bar()} // New output (with --minify) x===0?foo():bar();
Allow import path specifiers starting with
#/Previously the specification for
package.jsondisallowed import path specifiers starting with#/, but this restriction has recently been relaxed and support for it is being added across the JavaScript ecosystem. One use case is using it for a wildcard pattern such as mapping#/*to./src/*(previously you had to use another character such as#_*instead, which was more confusing). There is some more context in nodejs/node#49182.This change was contributed
Automatically add the
-webkit-maskprefix (#4357, #4358)This release automatically adds the
-webkit-vendor prefix for themaskCSS shorthand property:/* Original code */ main { mask: url(x.png) center/5rem no-repeat } /* Old output (with --target=chrome110) */ main { mask: url(x.png) center/5rem no-repeat; } /* New output (with --target=chrome110) */ main { -webkit-mask: url(x.png) center/5rem no-repeat; mask: url(x.png) center/5rem no-repeat; }This change was contributed
Additional minification of
switchstatements (#4176, #4359)This release contains additional minification patterns for reducing
switchstatements. Here is an example:// Original code switch (x) { case 0: foo() break case 1: default: bar() } // Old output (with --minify) switch(x){case 0:foo();break;case 1:default:bar()} // New output (with --minify) x===0?foo():bar();Forbid
usingdeclarations insideswitchclausesThis is a rare change to remove something that was previously possible. The Explicit Resource Management proposal introduced
usingdeclarations. These were previously allowed insidecaseanddefaultclauses inswitchstatements. This had well-defined semantics and was already widely implemented (by V8, SpiderMonkey, TypeScript, esbuild, and others). However, it was considered to be too confusing because of how scope works in switch statements, so it has been removed from the specification. This edge case will now be a syntax error. See tc39/proposal-explicit-resource-management#215 and rbuckton/ecma262#14 for details.Here is an example of code that is no longer allowed:
switch (mode) { case 'read': using readLock = db.read() return readAll(readLock) case 'write': using writeLock = db.write() return writeAll(writeLock) }That code will now have to be modified to look like this instead (note the additional
{and}block statements around each case body):switch (mode) { case 'read': { using readLock = db.read() return readAll(readLock) } case 'write': { using writeLock = db.write() return writeAll(writeLock) } }This is not being released in one of esbuild's breaking change releases since this feature hasn't been finalized yet, and esbuild always tracks the current state of the specification (so esbuild's previous behavior was arguably incorrect).
0.27.1
3 Dec 2025Fix bundler bug with
varnested insideifThis release fixes a bug with the bundler that happens when importing an ES module using
require(which causes it to be wrapped) and there's a top-levelvarinside anifstatement without being wrapped in a{ ... }block (and a few other conditions). The bundling transform needed to hoist thesevardeclarations outside of the lazy ES module wrapper for correctness. See the issue for details.Fix minifier bug with
forinsidetryinside labelThis fixes an old regression from version v0.21.4. Some code was introduced to move the label inside the
trystatement to address a problem with transforming labeledfor awaitloops to avoid theawait(the transformation involves converting thefor awaitloop into aforloop and wrapping it in atrystatement). However, it introduces problems for cross-compiled JVM code that uses all three of these features heavily. This release restricts this transform to only apply toforloops that esbuild itself generates internally as part of thefor awaittransform. Here is an example of some affected code:// Original code d: { e: { try { while (1) { break d } } catch { break e; } } } // Old output (with --minify) a:try{e:for(;;)break a}catch{break e} // New output (with --minify) a:e:try{for(;;)break a}catch{break e}Inline IIFEs containing a single expression
Previously inlining of IIFEs (immediately-invoked function expressions) only worked if the body contained a single
returnstatement. Now it should also work if the body contains a single expression statement instead:// Original code const foo = () => { const cb = () => { console.log(x()) } return cb() } // Old output (with --minify) const foo=()=>(()=>{console.log(x())})(); // New output (with --minify) const foo=()=>{console.log(x())};
Fix bundler bug with
varnested insideifThis release fixes a bug with the bundler that happens when importing an ES module using
require(which causes it to be wrapped) and there's a top-levelvarinside anifstatement without being wrapped in a{ ... }block (and a few other conditions). The bundling transform needed to hoist thesevardeclarations outside of the lazy ES module wrapper for correctness. See the issue for details.Fix minifier bug with
forinsidetryinside labelThis fixes an old regression from version v0.21.4. Some code was introduced to move the label inside the
trystatement to address a problem with transforming labeledfor awaitloops to avoid theawait(the transformation involves converting thefor awaitloop into aforloop and wrapping it in atrystatement). However, it introduces problems for cross-compiled JVM code that uses all three of these features heavily. This release restricts this transform to only apply toforloops that esbuild itself generates internally as part of thefor awaittransform. Here is an example of some affected code:// Original code d: { e: { try { while (1) { break d } } catch { break e; } } } // Old output (with --minify) a:try{e:for(;;)break a}catch{break e} // New output (with --minify) a:e:try{for(;;)break a}catch{break e}Inline IIFEs containing a single expression
Previously inlining of IIFEs (immediately-invoked function expressions) only worked if the body contained a single
returnstatement. Now it should also work if the body contains a single expression statement instead:// Original code const foo = () => { const cb = () => { console.log(x()) } return cb() } // Old output (with --minify) const foo=()=>(()=>{console.log(x())})(); // New output (with --minify) const foo=()=>{console.log(x())};The minifier now strips empty
finallyclausesThis improvement means that
finallyclauses containing dead code can potentially cause the associatedtrystatement to be removed from the output entirely in minified builds:// Original code function foo(callback) { if (DEBUG) stack.push(callback.name); try { callback(); } finally { if (DEBUG) stack.pop(); } } // Old output (with --minify --define:DEBUG=false) function foo(a){try{a()}finally{}} // New output (with --minify --define:DEBUG=false) function foo(a){a()}Allow tree-shaking of the
SymbolconstructorWith this release, calling
Symbolis now considered to be side-effect free when the argument is known to be a primitive value. This means esbuild can now tree-shake module-level symbol variables:// Original code const a = Symbol('foo') const b = Symbol(bar) // Old output (with --tree-shaking=true) const a = Symbol("foo"); const b = Symbol(bar); // New output (with --tree-shaking=true) const b = Symbol(bar);
0.27.0
9 Nov 2025Use
Uint8Array.fromBase64if availableWith this release, esbuild's
binaryloader will now use the newUint8Array.fromBase64function unless it's unavailable in the configured target environment. If it's unavailable, esbuild's previous code for this will be used as a fallback. Note that this means you may now need to specifytargetwhen using this feature with Node (for example--target=node22) unless you're using Node v25+.
This release deliberately contains backwards-incompatible changes. To avoid automatically picking up releases like this, you should either be pinning the exact version of
esbuildin yourpackage.jsonfile (recommended) or be using a version range syntax that only accepts patch upgrades such as^0.26.0or~0.26.0. See npm's documentation about semver for more information.Use
Uint8Array.fromBase64if availableWith this release, esbuild's
binaryloader will now use the newUint8Array.fromBase64function unless it's unavailable in the configured target environment. If it's unavailable, esbuild's previous code for this will be used as a fallback. Note that this means you may now need to specifytargetwhen using this feature with Node (for example--target=node22) unless you're using Node v25+.Update the Go compiler from v1.23.12 to v1.25.4 (#4208, #4311)
This raises the operating system requirements for running esbuild:
Linux: now requires a kernel version of 3.2 or later
macOS: now requires macOS 12 (Monterey) or later
- 0.26.x
0.26.0
9 Nov 2025Enable trusted publishing
GitHub and npm are recommending that maintainers for packages such as esbuild switch to trusted publishing. With this release, a VM on GitHub will now build and publish all of esbuild's packages to npm instead of me. In theory.
Unfortunately there isn't really a way to test that this works other than to do it live. So this release is that live test. Hopefully this release is uneventful and is exactly the same as the previous one (well, except for the green provenance attestation checkmark on npm that happens with trusted publishing).
- 0.25.x
0.25.12
1 Nov 2025Fix a minification regression with CSS media queries
The previous release introduced support for parsing media queries which unintentionally introduced a regression with the removal of duplicate media rules during minification. Specifically the grammar for
@media <media-type> and <media-condition-without-or> { ... }was missing an equality check for the<media-condition-without-or>part, so rules with different suffix clauses in this position would incorrectly compare equal and be deduplicated. This release fixes the regression.Update the list of known JavaScript globals
This release updates esbuild's internal list of known JavaScript globals. These are globals that are known to not have side-effects when the property is accessed. For example, accessing the global
Arrayproperty is considered to be side-effect free but accessing the globalscrollYproperty can trigger a layout, which is a side-effect. This is used by esbuild's tree-shaking to safely remove unused code that is known to be side-effect free. This update adds the following global properties:From ES2017:
From ES2020:
From ES2021:
From ES2025:
Note that this does not indicate that constructing any of these objects is side-effect free, just that accessing the identifier is side-effect free. For example, this now allows esbuild to tree-shake classes that extend from
Iterator:// This can now be tree-shaken by esbuild: class ExampleIterator extends Iterator {}Add support for the new
@view-transitionCSS ruleWith this release, esbuild now has improved support for pretty-printing and minifying the new
@view-transitionrule (which esbuild was previously unaware of):/* Original code */ @view-transition { navigation: auto; types: check; } /* Old output */ @view-transition { navigation: auto; types: check; } /* New output */ @view-transition { navigation: auto; types: check; }The new view transition feature provides a mechanism for creating animated transitions between documents in a multi-page app. You can read more about view transition rules here.
This change was contributed
Fix a minification regression with CSS media queries
The previous release introduced support for parsing media queries which unintentionally introduced a regression with the removal of duplicate media rules during minification. Specifically the grammar for
@media <media-type> and <media-condition-without-or> { ... }was missing an equality check for the<media-condition-without-or>part, so rules with different suffix clauses in this position would incorrectly compare equal and be deduplicated. This release fixes the regression.Update the list of known JavaScript globals
This release updates esbuild's internal list of known JavaScript globals. These are globals that are known to not have side-effects when the property is accessed. For example, accessing the global
Arrayproperty is considered to be side-effect free but accessing the globalscrollYproperty can trigger a layout, which is a side-effect. This is used by esbuild's tree-shaking to safely remove unused code that is known to be side-effect free. This update adds the following global properties:From ES2017:
AtomicsSharedArrayBuffer
From ES2020:
BigInt64ArrayBigUint64Array
From ES2021:
FinalizationRegistryWeakRef
From ES2025:
Float16ArrayIterator
Note that this does not indicate that constructing any of these objects is side-effect free, just that accessing the identifier is side-effect free. For example, this now allows esbuild to tree-shake classes that extend from
Iterator:// This can now be tree-shaken by esbuild: class ExampleIterator extends Iterator {}Add support for the new
@view-transitionCSS ruleWith this release, esbuild now has improved support for pretty-printing and minifying the new
@view-transitionrule (which esbuild was previously unaware of):/* Original code */ @view-transition { navigation: auto; types: check; } /* Old output */ @view-transition { navigation: auto; types: check; } /* New output */ @view-transition { navigation: auto; types: check; }The new view transition feature provides a mechanism for creating animated transitions between documents in a multi-page app. You can read more about view transition rules here.
This change was contributed
Trim CSS rules that will never match
The CSS minifier will now remove rules whose selectors contain
:is()and:where()as those selectors will never match. These selectors can currently be automatically generated by esbuild when you give esbuild nonsensical input such as the following:/* Original code */ div:before { color: green; &.foo { color: red; } } /* Old output (with --supported:nesting=false --minify) */ div:before{color:green}:is().foo{color:red} /* New output (with --supported:nesting=false --minify) */ div:before{color:green}This input is nonsensical because CSS nesting is (unfortunately) not supported inside of pseudo-elements such as
:before. Currently esbuild generates a rule containing:is()in this case when you tell esbuild to transform nested CSS into non-nested CSS. I think it's reasonable to do that as it sort of helps explain what's going on (or at least indicates that something is wrong in the output). It shouldn't be present in minified code, however, so this release now strips it out.
0.25.11
15 Oct 2025Add support for
with { type: 'bytes' }importsThe import bytes proposal has reached stage 2.7 in the TC39 process, which means that although it isn't quite recommended for implementation, it's generally approved and ready for validation. Furthermore it has already been implemented by Deno and Webpack. So with this release, esbuild will also add support for this. It behaves exactly the same as esbuild's existing
binaryloader. Here's an example:import data from './image.png' with { type: 'bytes' } const view = new DataView(data.buffer, 0, 24) const width = view.getInt32(16) const height = view.getInt32(20) console.log('size:', width + '\xD7' + height)Lower CSS media query range syntax (#3748, #4293)
With this release, esbuild will now transform CSS media query range syntax into equivalent syntax using
min-/max-prefixes for older browsers. For example, the following CSS:@media (640px <= width <= 960px) { main { display: flex; } }will be transformed like this with a target such as
--target=chrome100(or more specifically with--supported:media-range=falseif desired):@media (min-width: 640px) and (max-width: 960px) { main { display: flex; } }
0.25.10
17 Sep 2025Fix a panic in a minification edge case
This release fixes a panic due to a null pointer that could happen when esbuild inlines a doubly-nested identity function and the final result is empty. It was fixed by emitting the value
undefinedin this case, which avoids the panic. This case must be rare since it hasn't come up until now. Here is an example of code that previously triggered the panic (which only happened when minifying):function identity(x) { return x } identity({ y: identity(123) })Fix
@supportsnested inside pseudo-elementWhen transforming nested CSS to non-nested CSS, esbuild is supposed to filter out pseudo-elements such as
::placeholderfor correctness. The CSS nesting specification says the following:The nesting selector cannot represent pseudo-elements (identical to the behavior of the ':is()' pseudo-class). We’d like to relax this restriction, but need to do so simultaneously for both ':is()' and '&', since they’re intentionally built on the same underlying mechanisms.
However, it seems like this behavior is different for nested at-rules such as
@supports, which do work with pseudo-elements. So this release modifies esbuild's behavior to now take that into account:/* Original code */ ::placeholder { color: red; body & { color: green } @supports (color: blue) { color: blue } } /* Old output (with --supported:nesting=false) */ ::placeholder { color: red; } body :is() { color: green; } @supports (color: blue) { { color: blue; } } /* New output (with --supported:nesting=false) */ ::placeholder { color: red; } body :is() { color: green; } @supports (color: blue) { ::placeholder { color: blue; } }
0.25.9
12 Aug 2025Better support building projects that use Yarn on Windows (#3131, #3663)
With this release, you can now use esbuild to bundle projects that use Yarn Plug'n'Play on Windows on drives other than the
C:drive. The problem was as follows:Yarn works around this edge case by pretending Windows-style paths beginning with
C:\are actually Unix-style paths beginning with/C:/, so the../..path segments are able to navigate across drives inside Yarn's implementation. This was broken for a long time in esbuild but I finally got access to a Windows machine and was able to debug and fix this edge case. So you should now be able to bundle these projects with esbuild.Preserve parentheses around function expressions
The V8 JavaScript VM uses parentheses around function expressions as an optimization hint to immediately compile the function. Otherwise the function would be lazily-compiled, which has additional overhead if that function is always called immediately as lazy compilation involves parsing the function twice. You can read V8's blog post about this for more details.
Previously esbuild did not represent parentheses around functions in the AST so they were lost during compilation. With this change, esbuild will now preserve parentheses around function expressions when they are present in the original source code. This means these optimization hints will not be lost when bundling with esbuild. In addition, esbuild will now automatically add this optimization hint to immediately-invoked function expressions. Here's an example:
// Original code const fn0 = () => 0 const fn1 = (() => 1) console.log(fn0, function() { return fn1() }()) // Old output const fn0 = () => 0; const fn1 = () => 1; console.log(fn0, function() { return fn1(); }()); // New output const fn0 = () => 0; const fn1 = (() => 1); console.log(fn0, (function() { return fn1(); })());Note that you do not want to wrap all function expressions in parentheses. This optimization hint should only be used for functions that are called on initial load. Using this hint for functions that are not called on initial load will unnecessarily delay the initial load. Again, see V8's blog post linked above for details.
Update Go from 1.23.10 to 1.23.12 (#4257, #4258)
This should have no effect on existing code as this version change does not change Go's operating system support. It may remove certain false positive reports (specifically CVE-2025-4674 and CVE-2025-47907) from vulnerability scanners that only detect which version of the Go compiler esbuild uses.
0.25.8
19 Jul 2025Fix another TypeScript parsing edge case
This fixes a regression with a change in the previous release that tries to more accurately parse TypeScript arrow functions inside the
?:operator. The regression specifically involves parsing an arrow function containing a#privateidentifier inside the middle of a?:ternary operator inside a class body. This was fixed by propagating private identifier state into the parser clone used to speculatively parse the arrow function body. Here is an example of some affected code:class CachedDict { #has = (a: string) => dict.has(a); has = window ? (word: string): boolean => this.#has(word) : this.#has; }Fix a regression with the parsing of source phase imports
The change in the previous release to parse source phase imports failed to properly handle the following cases:
import source from 'bar' import source from from 'bar' import source type foo from 'bar'
Parsing for these cases should now be fixed. The first case was incorrectly treated as a syntax error because esbuild was expecting the second case. And the last case was previously allowed but is now forbidden. TypeScript hasn't added this feature yet so it remains to be seen whether the last case will be allowed, but it's safer to disallow it for now. At least Babel doesn't allow the last case when parsing TypeScript, and Babel was involved with the source phase import specification.
0.25.7
18 Jul 2025Parse and print JavaScript imports with an explicit phase
This release adds basic syntax support for the
deferandsourceimport phases in JavaScript:This change only adds support for this syntax. These imports cannot currently be bundled by esbuild. To use these new features with esbuild's bundler, the imported paths must be external to the bundle and the output format must be set to
esm.Support optionally emitting absolute paths instead of relative paths (#338, #2082, #3023)
This release introduces the
--abs-paths=feature which takes a comma-separated list of situations where esbuild should use absolute paths instead of relative paths. There are currently three supported situations:code(comments and string literals),log(log message text and location info), andmetafile(the JSON build metadata).Using absolute paths instead of relative paths is not the default behavior because it means that the build results are no longer machine-independent (which means builds are no longer reproducible). Absolute paths can be useful when used with certain terminal emulators that allow you to click on absolute paths in the terminal text and/or when esbuild is being automatically invoked from several different directories within the same script.
Fix a TypeScript parsing edge case
This release fixes an edge case with parsing an arrow function in TypeScript with a return type that's in the middle of a
?:ternary operator. For example:x = a ? (b) : c => d; y = a ? (b) : c => d : e;
The
:token in the value assigned toxpairs with the?token, so it's not the start of a return type annotation. However, the first:token in the value assigned toyis the start of a return type annotation because after parsing the arrow function body, it turns out there's another:token that can be used to pair with the?token. This case is notable as it's the first TypeScript edge case that esbuild has needed a backtracking parser to parse. It has been addressed by a quick hack (cloning the whole parser) as it's a rare edge case and esbuild doesn't otherwise need a backtracking parser. Hopefully this is sufficient and doesn't cause any issues.
Parse and print JavaScript imports with an explicit phase
This release adds basic syntax support for the
deferandsourceimport phases in JavaScript:deferThis is a stage 3 proposal for an upcoming JavaScript feature that will provide one way to eagerly load but lazily initialize imported modules. The imported module is automatically initialized on first use. Support for this syntax will also be part of the upcoming release of TypeScript 5.9. The syntax looks like this:
import defer * as foo from "<specifier>"; const bar = await import.defer("<specifier>");Note that this feature deliberately cannot be used with the syntax
import defer foo from "<specifier>"orimport defer { foo } from "<specifier>".sourceThis is a stage 3 proposal for an upcoming JavaScript feature that will provide another way to eagerly load but lazily initialize imported modules. The imported module is returned in an uninitialized state. Support for this syntax may or may not be a part of TypeScript 5.9 (see this issue for details). The syntax looks like this:
import source foo from "<specifier>"; const bar = await import.source("<specifier>");Note that this feature deliberately cannot be used with the syntax
import defer * as foo from "<specifier>"orimport defer { foo } from "<specifier>".
This change only adds support for this syntax. These imports cannot currently be bundled by esbuild. To use these new features with esbuild's bundler, the imported paths must be external to the bundle and the output format must be set to
esm.Support optionally emitting absolute paths instead of relative paths (#338, #2082, #3023)
This release introduces the
--abs-paths=feature which takes a comma-separated list of situations where esbuild should use absolute paths instead of relative paths. There are currently three supported situations:code(comments and string literals),log(log message text and location info), andmetafile(the JSON build metadata).Using absolute paths instead of relative paths is not the default behavior because it means that the build results are no longer machine-independent (which means builds are no longer reproducible). Absolute paths can be useful when used with certain terminal emulators that allow you to click on absolute paths in the terminal text and/or when esbuild is being automatically invoked from several different directories within the same script.
Fix a TypeScript parsing edge case
This release fixes an edge case with parsing an arrow function in TypeScript with a return type that's in the middle of a
?:ternary operator. For example:x = a ? (b) : c => d; y = a ? (b) : c => d : e;
The
:token in the value assigned toxpairs with the?token, so it's not the start of a return type annotation. However, the first:token in the value assigned toyis the start of a return type annotation because after parsing the arrow function body, it turns out there's another:token that can be used to pair with the?token. This case is notable as it's the first TypeScript edge case that esbuild has needed a backtracking parser to parse. It has been addressed by a quick hack (cloning the whole parser) as it's a rare edge case and esbuild doesn't otherwise need a backtracking parser. Hopefully this is sufficient and doesn't cause any issues.Inline small constant strings when minifying
Previously esbuild's minifier didn't inline string constants because strings can be arbitrarily long, and this isn't necessarily a size win if the string is used more than once. Starting with this release, esbuild will now inline string constants when the length of the string is three code units or less. For example:
// Original code const foo = 'foo' console.log({ [foo]: true }) // Old output (with --minify --bundle --format=esm) var o="foo";console.log({[o]:!0}); // New output (with --minify --bundle --format=esm) console.log({foo:!0});Note that esbuild's constant inlining only happens in very restrictive scenarios to avoid issues with TDZ handling. This change doesn't change when esbuild's constant inlining happens. It only expands the scope of it to include certain string literals in addition to numeric and boolean literals.
0.25.6
7 Jul 2025Fix a memory leak when
cancel()is used on a build contextCalling
rebuild()followed bycancel()in rapid succession could previously leak memory. The bundler uses a producer/consumer model internally, and the resource leak was caused by the consumer being termianted while there were still remaining unreceived results from a producer. To avoid the leak, the consumer now waits for all producers to finish before terminating.Support empty
:is()and:where()syntax in CSSPreviously using these selectors with esbuild would generate a warning. That warning has been removed in this release for these cases.
Improve tree-shaking of
trystatements in dead codeWith this release, esbuild will now remove certain
trystatements if esbuild considers them to be within dead code (i.e. code that is known to not ever be evaluated). For example:// Original code return 'foo' try { return 'bar' } catch {} // Old output (with --minify) return"foo";try{return"bar"}catch{} // New output (with --minify) return"foo";
Fix a memory leak when
cancel()is used on a build contextCalling
rebuild()followed bycancel()in rapid succession could previously leak memory. The bundler uses a producer/consumer model internally, and the resource leak was caused by the consumer being termianted while there were still remaining unreceived results from a producer. To avoid the leak, the consumer now waits for all producers to finish before terminating.Support empty
:is()and:where()syntax in CSSPreviously using these selectors with esbuild would generate a warning. That warning has been removed in this release for these cases.
Improve tree-shaking of
trystatements in dead codeWith this release, esbuild will now remove certain
trystatements if esbuild considers them to be within dead code (i.e. code that is known to not ever be evaluated). For example:// Original code return 'foo' try { return 'bar' } catch {} // Old output (with --minify) return"foo";try{return"bar"}catch{} // New output (with --minify) return"foo";Consider negated bigints to have no side effects
While esbuild currently considers
1,-1, and1nto all have no side effects, it didn't previously consider-1nto have no side effects. This is because esbuild does constant folding with numbers but not bigints. However, it meant that unused negative bigint constants were not tree-shaken. With this release, esbuild will now consider these expressions to also be side-effect free:// Original code let a = 1, b = -1, c = 1n, d = -1n // Old output (with --bundle --minify) (()=>{var n=-1n;})(); // New output (with --bundle --minify) (()=>{})();Support a configurable delay in watch mode before rebuilding (#3476, #4178)
The
watch()API now takes adelayoption that lets you add a delay (in milliseconds) before rebuilding when a change is detected in watch mode. If you use a tool that regenerates multiple source files very slowly, this should make it more likely that esbuild's watch mode won't generate a broken intermediate build before the successful final build. This option is also available via the CLI using the--watch-delay=flag.This should also help avoid confusion about the
watch()API's options argument. It was previously empty to allow for future API expansion, which caused some people to think that the documentation was missing. It's no longer empty now that thewatch()API has an option.Allow mixed array for
entryPointsAPI optionThe TypeScript type definitions now allow you to pass a mixed array of both string literals and object literals to the
entryPointsAPI option, such as['foo.js', { out: 'lib', in: 'bar.js' }]. This was always possible to do in JavaScript but the TypeScript type definitions were previously too restrictive.Update Go from 1.23.8 to 1.23.10 (#4204, #4207)
This should have no effect on existing code as this version change does not change Go's operating system support. It may remove certain false positive reports (specifically CVE-2025-4673 and CVE-2025-22874) from vulnerability scanners that only detect which version of the Go compiler esbuild uses.
Experimental support for esbuild on OpenHarmony
With this release, esbuild now publishes the
@esbuild/openharmony-arm64npm package for OpenHarmony. It contains a WebAssembly binary instead of a native binary because Go doesn't currently support OpenHarmony. Node does support it, however, so in theory esbuild should now work on OpenHarmony through WebAssembly.This change was contributed
0.25.5
27 May 2025Fix a regression with
browserinpackage.jsonThe fix to #4144 in version 0.25.3 introduced a regression that caused
browseroverrides specified inpackage.jsonto fail to override relative path names that end in a trailing slash. That behavior change affected theaxios@0.30.0package. This regression has been fixed, and now has test coverage.Add support for certain keywords as TypeScript tuple labels
Previously esbuild could incorrectly fail to parse certain keywords as TypeScript tuple labels that are parsed by the official TypeScript compiler if they were followed by a
?modifier. These labels includedfunction,import,infer,new,readonly, andtypeof. With this release, these keywords will now be parsed correctly. Here's an example of some affected code:type Foo = [ value: any, readonly?: boolean, // This is now parsed correctly ]
Add CSS prefixes for the
stretchsizing valueThis release adds support for prefixing CSS declarations such as
div { width: stretch }. That CSS is now transformed into this depending on what the--target=setting includes:div { width: -webkit-fill-available; width: -moz-available; width: stretch; }
0.25.4
6 May 2025Add simple support for CORS to esbuild's development server
Starting with version 0.25.0, esbuild's development server is no longer configured to serve cross-origin requests. This was a deliberate change to prevent any website you visit from accessing your running esbuild development server. However, this change prevented (by design) certain use cases such as "debugging in production" by having your production website load code from
localhostwhere the esbuild development server is running.To enable this use case, esbuild is adding a feature to allow Cross-Origin Resource Sharing (a.k.a. CORS) for simple requests. Specifically, passing your origin to the new
corsoption will now set theAccess-Control-Allow-Originresponse header when the request has a matchingOriginheader. Note that this currently only works for requests that don't send a preflightOPTIONSrequest, as esbuild's development server doesn't currently supportOPTIONSrequests.Some examples:
The special origin
*can be used to allow any origin to access esbuild's development server. Note that this means any website you visit will be able to read everything served by esbuild.Pass through invalid URLs in source maps unmodified
This fixes a regression in version 0.25.0 where
sourcesin source maps that form invalid URLs were not being passed through to the output. Version 0.25.0 changed the interpretation ofsourcesfrom file paths to URLs, which means that URL parsing can now fail. Previously URLs that couldn't be parsed were replaced with the empty string. With this release, invalid URLs insourcesshould now be passed through unmodified.Handle exports named
__proto__in ES modules (#4162, #4163)In JavaScript, the special property name
__proto__sets the prototype when used inside an object literal. Previously esbuild's ESM-to-CommonJS conversion didn't special-case the property name of exports named__proto__so the exported getter accidentally became the prototype of the object literal. It's unclear what this affects, if anything, but it's better practice to avoid this by using a computed property name in this case.This fix was contributed
0.25.3
23 Apr 2025Fix lowered
asyncarrow functions beforesuper()(#4141, #4142)This change makes it possible to call an
asyncarrow function in a constructor before callingsuper()when targeting environments withoutasyncsupport, as long as the function body doesn't referencethis. Here's an example (notice the change fromthistonull):// Original code class Foo extends Object { constructor() { (async () => await foo())() super() } } // Old output (with --target=es2016) class Foo extends Object { constructor() { (() => __async(this, null, function* () { return yield foo(); }))(); super(); } } // New output (with --target=es2016) class Foo extends Object { constructor() { (() => __async(null, null, function* () { return yield foo(); }))(); super(); } }Some background: Arrow functions with the
asynckeyword are transformed into generator functions for older language targets such as--target=es2016. Since arrow functions capturethis, the generated code forwardsthisinto the body of the generator function. However, JavaScript class syntax forbids usingthisin a constructor before callingsuper(), and this forwarding was problematic since previously happened even when the function body doesn't usethis. Starting with this release, esbuild will now only forwardthisif it's used within the function body.This fix was contributed
Fix memory leak with
--watch=true(#4131, #4132)This release fixes a memory leak with esbuild when
--watch=trueis used instead of--watch. Previously using--watch=truecaused esbuild to continue to use more and more memory for every rebuild, but--watch=trueshould now behave like--watchand not leak memory.This bug happened because esbuild disables the garbage collector when it's not run as a long-lived process for extra speed, but esbuild's checks for which arguments cause esbuild to be a long-lived process weren't updated for the new
--watch=truestyle of boolean command-line flags. This has been an issue since this boolean flag syntax was added in version 0.14.24 in 2022. These checks are unfortunately separate from the regular argument parser because of how esbuild's internals are organized (the command-line interface is exposed as a separate Go API so you can build your own custom esbuild CLI).This fix was contributed
More concise output for repeated legal comments
Some libraries have many files and also use the same legal comment text in all files. Previously esbuild would copy each legal comment to the output file. Starting with this release, legal comments duplicated across separate files will now be grouped in the output file by unique comment content.
Fix lowered
asyncarrow functions beforesuper()(#4141, #4142)This change makes it possible to call an
asyncarrow function in a constructor before callingsuper()when targeting environments withoutasyncsupport, as long as the function body doesn't referencethis. Here's an example (notice the change fromthistonull):// Original code class Foo extends Object { constructor() { (async () => await foo())() super() } } // Old output (with --target=es2016) class Foo extends Object { constructor() { (() => __async(this, null, function* () { return yield foo(); }))(); super(); } } // New output (with --target=es2016) class Foo extends Object { constructor() { (() => __async(null, null, function* () { return yield foo(); }))(); super(); } }Some background: Arrow functions with the
asynckeyword are transformed into generator functions for older language targets such as--target=es2016. Since arrow functions capturethis, the generated code forwardsthisinto the body of the generator function. However, JavaScript class syntax forbids usingthisin a constructor before callingsuper(), and this forwarding was problematic since previously happened even when the function body doesn't usethis. Starting with this release, esbuild will now only forwardthisif it's used within the function body.This fix was contributed
Fix memory leak with
--watch=true(#4131, #4132)This release fixes a memory leak with esbuild when
--watch=trueis used instead of--watch. Previously using--watch=truecaused esbuild to continue to use more and more memory for every rebuild, but--watch=trueshould now behave like--watchand not leak memory.This bug happened because esbuild disables the garbage collector when it's not run as a long-lived process for extra speed, but esbuild's checks for which arguments cause esbuild to be a long-lived process weren't updated for the new
--watch=truestyle of boolean command-line flags. This has been an issue since this boolean flag syntax was added in version 0.14.24 in 2022. These checks are unfortunately separate from the regular argument parser because of how esbuild's internals are organized (the command-line interface is exposed as a separate Go API so you can build your own custom esbuild CLI).This fix was contributed
More concise output for repeated legal comments
Some libraries have many files and also use the same legal comment text in all files. Previously esbuild would copy each legal comment to the output file. Starting with this release, legal comments duplicated across separate files will now be grouped in the output file by unique comment content.
Allow a custom host with the development server
With this release, you can now use a custom non-IP
hostwith esbuild's local development server (either with--serve=for the CLI or with theserve()call for the API). This was previously possible, but was intentionally broken in version 0.25.0 to fix a security issue. This change adds the functionality back except that it's now opt-in and only for a single domain name that you provide.For example, if you add a mapping in your
/etc/hostsfile fromlocal.example.comto127.0.0.1and then useesbuild --serve=local.example.com:8000, you will now be able to visit local.example.com in your browser and successfully connect to esbuild's development server (doing that would previously have been blocked by the browser). This should also work with HTTPS if it's enabled (see esbuild's documentation for how to do that).Add a limit to CSS nesting expansion
With this release, esbuild will now fail with an error if there is too much CSS nesting expansion. This can happen when nested CSS is converted to CSS without nesting for older browsers as expanding CSS nesting is inherently exponential due to the resulting combinatorial explosion. The expansion limit is currently hard-coded and cannot be changed, but is extremely unlikely to trigger for real code. It exists to prevent esbuild from using too much time and/or memory. Here's an example:
a,b{a,b{a,b{a,b{a,b{a,b{a,b{a,b{a,b{a,b{a,b{a,b{a,b{a,b{a,b{a,b{a,b{a,b{a,b{a,b{color:red}}}}}}}}}}}}}}}}}}}}Previously, transforming this file with
--target=safari1took 5 seconds and generated 40mb of CSS. Trying to do that will now generate the following error instead:✘ [ERROR] CSS nesting is causing too much expansion example.css:1:60: 1 │ a,b{a,b{a,b{a,b{a,b{a,b{a,b{a,b{a,b{a,b{a,b{a,b{a,b{a,b{a,b{a,b{a,b{a,b{a,b{a,b{color:red}}}}}}}}}}}}}}}}}}}} ╵ ^ CSS nesting expansion was terminated because a rule was generated with 65536 selectors. This limit exists to prevent esbuild from using too much time and/or memory. Please change your CSS to use fewer levels of nesting.Fix path resolution edge case
This fixes an edge case where esbuild's path resolution algorithm could deviate from node's path resolution algorithm. It involves a confusing situation where a directory shares the same file name as a file (but without the file extension). See the linked issue for specific details. This appears to be a case where esbuild is correctly following node's published resolution algorithm but where node itself is doing something different. Specifically the step
LOAD_AS_FILEappears to be skipped when the input ends with... This release changes esbuild's behavior for this edge case to match node's behavior.Update Go from 1.23.7 to 1.23.8 (#4133, #4134)
This should have no effect on existing code as this version change does not change Go's operating system support. It may remove certain reports from vulnerability scanners that detect which version of the Go compiler esbuild uses, such as for CVE-2025-22871.
As a reminder, esbuild's development server is intended for development, not for production, so I do not consider most networking-related vulnerabilities in Go to be vulnerabilities in esbuild. Please do not use esbuild's development server in production.
0.25.2
30 Mar 2025Support flags in regular expressions for the API
The JavaScript plugin API for esbuild takes JavaScript regular expression objects for the
filteroption. Internally these are translated into Go regular expressions. However, this translation previously ignored theflagsproperty of the regular expression. With this release, esbuild will now translate JavaScript regular expression flags into Go regular expression flags. Specifically the JavaScript regular expression/\.[jt]sx?$/iis turned into the Go regular expression`(?i)\.[jt]sx?$`internally inside of esbuild's API. This should make it possible to use JavaScript regular expressions with theiflag. Note that JavaScript and Go don't support all of the same regular expression features, so this mapping is only approximate.Fix node-specific annotations for string literal export names
When node instantiates a CommonJS module, it scans the AST to look for names to expose via ESM named exports. This is a heuristic that looks for certain patterns such as
exports.NAME = ...ormodule.exports = { ... }. This behavior is used by esbuild to "annotate" CommonJS code that was converted from ESM with the original ESM export names. For example, when converting the fileexport let foo, barfrom ESM to CommonJS, esbuild appends this to the end of the file:// Annotate the CommonJS export names for ESM import in node: 0 && (module.exports = { bar, foo });However, this feature previously didn't work correctly for export names that are not valid identifiers, which can be constructed using string literal export names. The generated code contained a syntax error. That problem is fixed in this release:
// Original code let foo export { foo as "foo!" } // Old output (with --format=cjs --platform=node) ... 0 && (module.exports = { "foo!" }); // New output (with --format=cjs --platform=node) ... 0 && (module.exports = { "foo!": null });Basic support for index source maps (#3439, #4109)
The source map specification has an optional mode called index source maps that makes it easier for tools to create an aggregate JavaScript file by concatenating many smaller JavaScript files with source maps, and then generate an aggregate source map by simply providing the original source maps along with some offset information. My understanding is that this is rarely used in practice. I'm only aware of two uses of it in the wild: ClojureScript and Turbopack.
This release provides basic support for indexed source maps. However, the implementation has not been tested on a real app (just on very simple test input). If you are using index source maps in a real app, please try this out and report back if anything isn't working for you.
Note that this is also not a complete implementation. For example, index source maps technically allows nesting source maps to an arbitrary depth, while esbuild's implementation in this release only supports a single level of nesting. It's unclear whether supporting more than one level of nesting is important or not given the lack of available test cases.
This feature was contributed
0.25.1
10 Mar 2025Fix incorrect paths in inline source maps (#4070, #4075, #4105)
This fixes a regression from version 0.25.0 where esbuild didn't correctly resolve relative paths contained within source maps in inline
sourceMappingURLdata URLs. The paths were incorrectly being passed through as-is instead of being resolved relative to the source file containing thesourceMappingURLcomment, which was due to the data URL not being a file URL. This regression has been fixed, and this case now has test coverage.Fix invalid generated source maps (#4080, #4082, #4104, #4107)
This release fixes a regression from version 0.24.1 that could cause esbuild to generate invalid source maps. Specifically under certain conditions, esbuild could generate a mapping with an out-of-bounds source index. It was introduced by code that attempted to improve esbuild's handling of "null" entries in source maps (i.e. mappings with a generated position but no original position). This regression has been fixed.
This fix was contributed
Fix a regression with non-file source map paths
The format of paths in source maps that aren't in the
filenamespace was unintentionally changed in version 0.25.0. Path namespaces is an esbuild-specific concept that is optionally available for plugins to use to distinguish paths fromfilepaths and from paths meant for other plugins. Previously the namespace was prepended to the path joined with a:character, but version 0.25.0 unintentionally failed to prepend the namespace. The previous behavior has been restored.
Fix incorrect paths in inline source maps (#4070, #4075, #4105)
This fixes a regression from version 0.25.0 where esbuild didn't correctly resolve relative paths contained within source maps in inline
sourceMappingURLdata URLs. The paths were incorrectly being passed through as-is instead of being resolved relative to the source file containing thesourceMappingURLcomment, which was due to the data URL not being a file URL. This regression has been fixed, and this case now has test coverage.Fix invalid generated source maps (#4080, #4082, #4104, #4107)
This release fixes a regression from version 0.24.1 that could cause esbuild to generate invalid source maps. Specifically under certain conditions, esbuild could generate a mapping with an out-of-bounds source index. It was introduced by code that attempted to improve esbuild's handling of "null" entries in source maps (i.e. mappings with a generated position but no original position). This regression has been fixed.
This fix was contributed
Fix a regression with non-file source map paths
The format of paths in source maps that aren't in the
filenamespace was unintentionally changed in version 0.25.0. Path namespaces is an esbuild-specific concept that is optionally available for plugins to use to distinguish paths fromfilepaths and from paths meant for other plugins. Previously the namespace was prepended to the path joined with a:character, but version 0.25.0 unintentionally failed to prepend the namespace. The previous behavior has been restored.Fix a crash with
switchoptimizationThe new code in the previous release to optimize dead code in switch statements accidentally introduced a crash in the edge case where one or more switch case values include a function expression. This is because esbuild now visits the case values first to determine whether any cases are dead code, and then visits the case bodies once the dead code status is known. That triggered some internal asserts that guard against traversing the AST in an unexpected order. This crash has been fixed by changing esbuild to expect the new traversal ordering. Here's an example of affected code:
switch (x) { case '': return y.map(z => z.value) case y.map(z => z.key).join(','): return [] }Update Go from 1.23.5 to 1.23.7 (#4076, #4077)
This should have no effect on existing code as this version change does not change Go's operating system support. It may remove certain reports from vulnerability scanners that detect which version of the Go compiler esbuild uses.
This PR was contributed
0.25.0
8 Feb 2025- Security
Restrict access to esbuild's development server (GHSA-67mh-4wv8-2f99)
This change addresses esbuild's first security vulnerability report. Previously esbuild set the
Access-Control-Allow-Originheader to*to allow esbuild's development server to be flexible in how it's used for development. However, this allows the websites you visit to make HTTP requests to esbuild's local development server, which gives read-only access to your source code if the website were to fetch your source code's specific URL. You can read more information in the report.Starting with this release, CORS will now be disabled, and requests will now be denied if the host does not match the one provided to
--serve=. The default host is0.0.0.0, which refers to all of the IP addresses that represent the local machine (e.g. both127.0.0.1and192.168.0.1). If you want to customize anything about esbuild's development server, you can put a proxy in front of esbuild and modify the incoming and/or outgoing requests.In addition, the
serve()API call has been changed to return an array ofhostsinstead of a singlehoststring. This makes it possible to determine all of the hosts that esbuild's development server will accept. Delete output files when a build fails in watch mode
It has been requested for esbuild to delete files when a build fails in watch mode. Previously esbuild left the old files in place, which could cause people to not immediately realize that the most recent build failed. With this release, esbuild will now delete all output files if a rebuild fails. Fixing the build error and triggering another rebuild will restore all output files again.
This release deliberately contains backwards-incompatible changes. To avoid automatically picking up releases like this, you should either be pinning the exact version of
esbuildin yourpackage.jsonfile (recommended) or be using a version range syntax that only accepts patch upgrades such as^0.24.0or~0.24.0. See npm's documentation about semver for more information.- Security
Restrict access to esbuild's development server (GHSA-67mh-4wv8-2f99)
This change addresses esbuild's first security vulnerability report. Previously esbuild set the
Access-Control-Allow-Originheader to*to allow esbuild's development server to be flexible in how it's used for development. However, this allows the websites you visit to make HTTP requests to esbuild's local development server, which gives read-only access to your source code if the website were to fetch your source code's specific URL. You can read more information in the report.Starting with this release, CORS will now be disabled, and requests will now be denied if the host does not match the one provided to
--serve=. The default host is0.0.0.0, which refers to all of the IP addresses that represent the local machine (e.g. both127.0.0.1and192.168.0.1). If you want to customize anything about esbuild's development server, you can put a proxy in front of esbuild and modify the incoming and/or outgoing requests.In addition, the
serve()API call has been changed to return an array ofhostsinstead of a singlehoststring. This makes it possible to determine all of the hosts that esbuild's development server will accept. Delete output files when a build fails in watch mode
It has been requested for esbuild to delete files when a build fails in watch mode. Previously esbuild left the old files in place, which could cause people to not immediately realize that the most recent build failed. With this release, esbuild will now delete all output files if a rebuild fails. Fixing the build error and triggering another rebuild will restore all output files again.
Fix correctness issues with the CSS nesting transform (#3620, #3877, #3933, #3997, #4005, #4037, #4038)
This release fixes the following problems:
Naive expansion of CSS nesting can result in an exponential blow-up of generated CSS if each nesting level has multiple selectors. Previously esbuild sometimes collapsed individual nesting levels using
:is()to limit expansion. However, this collapsing wasn't correct in some cases, so it has been removed to fix correctness issues./* Original code */ .parent { > .a, > .b1 > .b2 { color: red; } } /* Old output (with --supported:nesting=false) */ .parent > :is(.a, .b1 > .b2) { color: red; } /* New output (with --supported:nesting=false) */ .parent > .a, .parent > .b1 > .b2 { color: red; }The
&CSS nesting selector can be repeated multiple times to increase CSS specificity. Previously esbuild ignored this possibility and incorrectly considered&&to have the same specificity as&. With this release, this should now work correctly:/* Original code (color should be red) */ div { && { color: red } & { color: blue } } /* Old output (with --supported:nesting=false) */ div { color: red; } div { color: blue; } /* New output (with --supported:nesting=false) */ div:is(div) { color: red; } div { color: blue; }Previously transforming nested CSS incorrectly removed leading combinators from within pseudoclass selectors such as
:where(). This edge case has been fixed and how has test coverage./* Original code */ a b:has(> span) { a & { color: green; } } /* Old output (with --supported:nesting=false) */ a :is(a b:has(span)) { color: green; } /* New output (with --supported:nesting=false) */ a :is(a b:has(> span)) { color: green; }This fix was contributed
The CSS minifier contains logic to remove the
&selector when it can be implied, which happens when there is only one and it's the leading token. However, this logic was incorrectly also applied to selector lists inside of pseudo-class selectors such as:where(). With this release, the minifier will now avoid applying this logic in this edge case:/* Original code */ .a { & .b { color: red } :where(& .b) { color: blue } } /* Old output (with --minify) */ .a{.b{color:red}:where(.b){color:#00f}} /* New output (with --minify) */ .a{.b{color:red}:where(& .b){color:#00f}}
Fix some correctness issues with source maps (#1745, #3183, #3613, #3982)
Previously esbuild incorrectly treated source map path references as file paths instead of as URLs. With this release, esbuild will now treat source map path references as URLs. This fixes the following problems with source maps:
File names in
sourceMappingURLthat contained a space previously did not encode the space as%20, which resulted in JavaScript tools (including esbuild) failing to read that path back in when consuming the generated output file. This should now be fixed.Absolute URLs in
sourceMappingURLthat use thefile://scheme previously attempted to read from a folder calledfile:. These URLs should now be recognized and parsed correctly.Entries in the
sourcesarray in the source map are now treated as URLs instead of file paths. The correct behavior for this is much more clear now that source maps has a formal specification. Many thanks to those who worked on the specification.
Fix incorrect package for
@esbuild/netbsd-arm64Due to a copy+paste typo, the binary published to
@esbuild/netbsd-arm64was not actually forarm64, and didn't run in that environment. This release should fix running esbuild in that environment (NetBSD on 64-bit ARM). Sorry about the mistake.Fix a minification bug with bitwise operators and bigints
This change removes an incorrect assumption in esbuild that all bitwise operators result in a numeric integer. That assumption was correct up until the introduction of bigints in ES2020, but is no longer correct because almost all bitwise operators now operate on both numbers and bigints. Here's an example of the incorrect minification:
// Original code if ((a & b) !== 0) found = true // Old output (with --minify) a&b&&(found=!0); // New output (with --minify) (a&b)!==0&&(found=!0);
Fix esbuild incorrectly rejecting valid TypeScript edge case
The following TypeScript code is valid:
export function open(async?: boolean): void { console.log(async as boolean) }Before this version, esbuild would fail to parse this with a syntax error as it expected the token sequence
async as ...to be the start of an async arrow function expressionasync as => .... This edge case should be parsed correctly by esbuild starting with this release.Transform BigInt values into constructor calls when unsupported
Previously esbuild would refuse to compile the BigInt literals (such as
123n) if they are unsupported in the configured target environment (such as with--target=es6). The rationale was that they cannot be polyfilled effectively because they change the behavior of JavaScript's arithmetic operators and JavaScript doesn't have operator overloading.However, this prevents using esbuild with certain libraries that would otherwise work if BigInt literals were ignored, such as with old versions of the
bufferlibrary before the library fixed support for running in environments without BigInt support. So with this release, esbuild will now turn BigInt literals into BigInt constructor calls (so123nbecomesBigInt(123)) and generate a warning in this case. You can turn off the warning with--log-override:bigint=silentor restore the warning to an error with--log-override:bigint=errorif needed.Change how
consoleAPI dropping worksPreviously the
--drop:consolefeature replaced all method calls off of theconsoleglobal withundefinedregardless of how long the property access chain was (so it applied toconsole.log()andconsole.log.call(console)andconsole.log.not.a.method()). However, it was pointed out that this breaks uses ofconsole.log.bind(console). That's also incompatible with Terser's implementation of the feature, which is where this feature originally came from (it does supportbind). So with this release, using this feature with esbuild will now only replace one level of method call (unless extended bycallorapply) and will replace the method being called with an empty function in complex cases:// Original code const x = console.log('x') const y = console.log.call(console, 'y') const z = console.log.bind(console)('z') // Old output (with --drop-console) const x = void 0; const y = void 0; const z = (void 0)("z"); // New output (with --drop-console) const x = void 0; const y = void 0; const z = (() => { }).bind(console)("z");This should more closely match Terser's existing behavior.
Allow BigInt literals as
definevaluesWith this release, you can now use BigInt literals as define values, such as with
--define:FOO=123n. Previously trying to do this resulted in a syntax error.Fix a bug with resolve extensions in
node_modulesThe
--resolve-extensions=option lets you specify the order in which to try resolving implicit file extensions. For complicated reasons, esbuild reorders TypeScript file extensions after JavaScript ones inside ofnode_modulesso that JavaScript source code is always preferred to TypeScript source code inside of dependencies. However, this reordering had a bug that could accidentally change the relative order of TypeScript file extensions if one of them was a prefix of the other. That bug has been fixed in this release. You can see the issue for details.Better minification of statically-determined
switchcasesWith this release, esbuild will now try to trim unused code within
switchstatements when the test expression andcaseexpressions are primitive literals. This can arise when the test expression is an identifier that is substituted for a primitive literal at compile time. For example:// Original code switch (MODE) { case 'dev': installDevToolsConsole() break case 'prod': return default: throw new Error } // Old output (with --minify '--define:MODE="prod"') switch("prod"){case"dev":installDevToolsConsole();break;case"prod":return;default:throw new Error} // New output (with --minify '--define:MODE="prod"') return;Emit
/* @__KEY__ */for string literals derived from property namesProperty name mangling is an advanced feature that shortens certain property names for better minification (I say "advanced feature" because it's very easy to break your code with it). Sometimes you need to store a property name in a string, such as
obj.get('foo')instead ofobj.foo. JavaScript minifiers such as esbuild and Terser have a convention where a/* @__KEY__ */comment before the string makes it behave like a property name. Soobj.get(/* @__KEY__ */ 'foo')allows the contents of the string'foo'to be shortened.However, esbuild sometimes itself generates string literals containing property names when transforming code, such as when lowering class fields to ES6 or when transforming TypeScript decorators. Previously esbuild didn't generate its own
/* @__KEY__ */comments in this case, which means that minifying your code by running esbuild again on its own output wouldn't work correctly (this does not affect people that both minify and transform their code in a single step).With this release, esbuild will now generate
/* @__KEY__ */comments for property names in generated string literals. To avoid lots of unnecessary output for people that don't use this advanced feature, the generated comments will only be present when the feature is active. If you want to generate the comments but not actually mangle any property names, you can use a flag that has no effect such as--reserve-props=., which tells esbuild to not mangle any property names (but still activates this feature).The
textloader now strips the UTF-8 BOM if presentSome software (such as Notepad on Windows) can create text files that start with the three bytes
0xEF 0xBB 0xBF, which is referred to as the "byte order mark". This prefix is intended to be removed before using the text. Previously esbuild'stextloader included this byte sequence in the string, which turns into a prefix of\uFEFFin a JavaScript string when decoded from UTF-8. With this release, esbuild'stextloader will now remove these bytes when they occur at the start of the file.Omit legal comment output files when empty
Previously configuring esbuild with
--legal-comment=externalor--legal-comment=linkedwould always generate a.LEGAL.txtoutput file even if it was empty. Starting with this release, esbuild will now only do this if the file will be non-empty. This should result in a more organized output directory in some cases.Update Go from 1.23.1 to 1.23.5 (#4056, #4057)
This should have no effect on existing code as this version change does not change Go's operating system support. It may remove certain reports from vulnerability scanners that detect which version of the Go compiler esbuild uses.
This PR was contributed
Allow passing a port of 0 to the development server
Unix sockets interpret a port of 0 to mean "pick a random unused port in the ephemeral port range". However, esbuild's default behavior when the port is not specified is to pick the first unused port starting from 8000 and upward. This is more convenient because port 8000 is typically free, so you can for example restart the development server and reload your app in the browser without needing to change the port in the URL. Since esbuild is written in Go (which does not have optional fields like JavaScript), not specifying the port in Go means it defaults to 0, so previously passing a port of 0 to esbuild caused port 8000 to be picked.
Starting with this release, passing a port of 0 to esbuild when using the CLI or the JS API will now pass port 0 to the OS, which will pick a random ephemeral port. To make this possible, the
Portoption in the Go API has been changed fromuint16toint(to allow for additional sentinel values) and passing a port of -1 in Go now picks a random port. Both the CLI and JS APIs now remap an explicitly-provided port of 0 into -1 for the internal Go API.Another option would have been to change
Portin Go fromuint16to*uint16(Go's closest equivalent ofnumber | undefined). However, that would make the common case of providing an explicit port in Go very awkward as Go doesn't support taking the address of integer constants. This tradeoff isn't worth it as picking a random ephemeral port is a rare use case. So the CLI and JS APIs should now match standard Unix behavior when the port is 0, but you need to use -1 instead with Go API.Minification now avoids inlining constants with direct
evalDirect
evalcan be used to introduce a new variable like this:const variable = false ;(function () { eval("var variable = true") console.log(variable) })()Previously esbuild inlined
variablehere (which becamefalse), which changed the behavior of the code. This inlining is now avoided, but please keep in mind that directevalbreaks many assumptions that JavaScript tools hold about normal code (especially when bundling) and I do not recommend using it. There are usually better alternatives that have a more localized impact on your code. You can read more about this here: esbuild.github.io/link/direct-eval/
- 0.24.x
0.24.2
20 Dec 2024Fix regression with
--defineandimport.meta(#4010, #4012, #4013)The previous change in version 0.24.1 to use a more expression-like parser for
definevalues to allow quoted property names introduced a regression that removed the ability to use--define:import.meta=.... Even thoughimportis normally a keyword that can't be used as an identifier, ES modules special-case theimport.metaexpression to behave like an identifier anyway. This change fixes the regression.This fix was contributed
0.24.1
20 Dec 2024Allow
es2024as a target intsconfig.jsonTypeScript recently added
es2024as a compilation target, so esbuild now supports this in thetargetfield oftsconfig.jsonfiles, such as in the following configuration file:{ "compilerOptions": { "target": "ES2024" } }As a reminder, the only thing that esbuild uses this field for is determining whether or not to use legacy TypeScript behavior for class fields. You can read more in the documentation.
This fix was contributed
Allow automatic semicolon insertion after
get/setThis change fixes a grammar bug in the parser that incorrectly treated the following code as a syntax error:
class Foo { get *x() {} set *y() {} }The above code will be considered valid starting with this release. This change to esbuild follows a similar change to TypeScript which will allow this syntax starting with TypeScript 5.7.
Allow quoted property names in
--defineand--pureThe
defineandpureAPI options now accept identifier expressions containing quoted property names. Previously all identifiers in the identifier expression had to be bare identifiers. This change now makes--defineand--pureconsistent with--global-name, which already supported quoted property names. For example, the following is now possible:// The following code now transforms to "return true;\n" console.log(esbuild.transformSync( `return process.env['SOME-TEST-VAR']`, { define: { 'process.env["SOME-TEST-VAR"]': 'true' } }, ))Note that if you're passing values like this on the command line using esbuild's
--defineflag, then you'll need to know how to escape quote characters for your shell. You may find esbuild's JavaScript API more ergonomic and portable than writing shell code.
Allow
es2024as a target intsconfig.jsonTypeScript recently added
es2024as a compilation target, so esbuild now supports this in thetargetfield oftsconfig.jsonfiles, such as in the following configuration file:{ "compilerOptions": { "target": "ES2024" } }As a reminder, the only thing that esbuild uses this field for is determining whether or not to use legacy TypeScript behavior for class fields. You can read more in the documentation.
This fix was contributed
Allow automatic semicolon insertion after
get/setThis change fixes a grammar bug in the parser that incorrectly treated the following code as a syntax error:
class Foo { get *x() {} set *y() {} }The above code will be considered valid starting with this release. This change to esbuild follows a similar change to TypeScript which will allow this syntax starting with TypeScript 5.7.
Allow quoted property names in
--defineand--pureThe
defineandpureAPI options now accept identifier expressions containing quoted property names. Previously all identifiers in the identifier expression had to be bare identifiers. This change now makes--defineand--pureconsistent with--global-name, which already supported quoted property names. For example, the following is now possible:// The following code now transforms to "return true;\n" console.log(esbuild.transformSync( `return process.env['SOME-TEST-VAR']`, { define: { 'process.env["SOME-TEST-VAR"]': 'true' } }, ))Note that if you're passing values like this on the command line using esbuild's
--defineflag, then you'll need to know how to escape quote characters for your shell. You may find esbuild's JavaScript API more ergonomic and portable than writing shell code.Minify empty
try/catch/finallyblocksWith this release, esbuild will now attempt to minify empty
tryblocks:// Original code try {} catch { foo() } finally { bar() } // Old output (with --minify) try{}catch{foo()}finally{bar()} // New output (with --minify) bar();This can sometimes expose additional minification opportunities.
Include
entryPointmetadata for thecopyloaderAlmost all entry points already include a
entryPointfield in theoutputsmap in esbuild's build metadata. However, this wasn't the case for thecopyloader as that loader is a special-case that doesn't behave like other loaders. This release adds theentryPointfield in this case.Source mappings may now contain
nullentries (#3310, #3878)With this change, sources that result in an empty source map may now emit a
nullsource mapping (i.e. one with a generated position but without a source index or original position). This change improves source map accuracy by fixing a problem where minified code from a source without any source mappings could potentially still be associated with a mapping from another source file earlier in the generated output on the same minified line. It manifests as nonsensical files in source mapped stack traces. Now thenullmapping "resets" the source map so that any lookups into the minified code without any mappings resolves tonull(which appears as the output file in stack traces) instead of the incorrect source file.This change shouldn't affect anything in most situations. I'm only mentioning it in the release notes in case it introduces a bug with source mapping. It's part of a work-in-progress future feature that will let you omit certain unimportant files from the generated source map to reduce source map size.
Avoid using the parent directory name for determinism
To make generated code more readable, esbuild includes the name of the source file when generating certain variable names within the file. Specifically bundling a CommonJS file generates a variable to store the lazily-evaluated module initializer. However, if a file is named
index.js(or with a different extension), esbuild will use the name of the parent directory instead for a better name (since many packages have files all namedindex.jsbut have unique directory names).This is problematic when the bundle entry point is named
index.jsand the parent directory name is non-deterministic (e.g. a temporary directory created by a build script). To avoid non-determinism in esbuild's output, esbuild will now useindexinstead of the parent directory in this case. Specifically this will happen if the parent directory is equal to esbuild'soutbaseAPI option, which defaults to the lowest common ancestor of all user-specified entry point paths.Experimental support for esbuild on NetBSD
With this release, esbuild now has a published binary executable for NetBSD in the
@esbuild/netbsd-arm64npm package, and esbuild's installer has been modified to attempt to use it when on NetBSD. Hopefully this makes installing esbuild via npm work on NetBSD. This change was contributed⚠️ Note: NetBSD is not one of Node's supported platforms, so installing esbuild may or may not work on NetBSD depending on how Node has been patched. This is not a problem with esbuild. ⚠️
0.24.0
22 Sep 2024- Removed
Drop support for older platforms
This release drops support for the following operating system:
This is because the Go programming language dropped support for this operating system version in Go 1.23, and this release updates esbuild from Go 1.22 to Go 1.23. Go 1.23 now requires macOS 11 Big Sur or later.
Note that this only affects the binary esbuild executables that are published to the esbuild npm package. It's still possible to compile esbuild's source code for these older operating systems. If you need to, you can compile esbuild for yourself using an older version of the Go compiler (before Go version 1.23). That might look something like this:
git clone https://github.com/evanw/esbuild.git cd esbuild go build ./cmd/esbuild ./esbuild --version
Fix class field decorators in TypeScript if
useDefineForClassFieldsisfalseSetting the
useDefineForClassFieldsflag tofalseintsconfig.jsonmeans class fields use the legacy TypeScript behavior instead of the standard JavaScript behavior. Specifically they use assign semantics instead of define semantics (e.g. setters are triggered) and fields without an initializer are not initialized at all. However, when this legacy behavior is combined with standard JavaScript decorators, TypeScript switches to always initializing all fields, even those without initializers. Previously esbuild incorrectly continued to omit field initializers for this edge case. These field initializers in this case should now be emitted starting with this release.Avoid incorrect cycle warning with
tsconfig.jsonmultiple inheritanceTypeScript 5.0 introduced multiple inheritance for
tsconfig.jsonfiles whereextendscan be an array of file paths. Previously esbuild would incorrectly treat files encountered more than once when processing separate subtrees of the multiple inheritance hierarchy as an inheritance cycle. With this release,tsconfig.jsonfiles containing this edge case should work correctly without generating a warning.
This release deliberately contains backwards-incompatible changes. To avoid automatically picking up releases like this, you should either be pinning the exact version of
esbuildin yourpackage.jsonfile (recommended) or be using a version range syntax that only accepts patch upgrades such as^0.23.0or~0.23.0. See npm's documentation about semver for more information.- Removed
Drop support for older platforms
This release drops support for the following operating system:
macOS 10.15 Catalina
This is because the Go programming language dropped support for this operating system version in Go 1.23, and this release updates esbuild from Go 1.22 to Go 1.23. Go 1.23 now requires macOS 11 Big Sur or later.
Note that this only affects the binary esbuild executables that are published to the esbuild npm package. It's still possible to compile esbuild's source code for these older operating systems. If you need to, you can compile esbuild for yourself using an older version of the Go compiler (before Go version 1.23). That might look something like this:
git clone https://github.com/evanw/esbuild.git cd esbuild go build ./cmd/esbuild ./esbuild --version
Fix class field decorators in TypeScript if
useDefineForClassFieldsisfalseSetting the
useDefineForClassFieldsflag tofalseintsconfig.jsonmeans class fields use the legacy TypeScript behavior instead of the standard JavaScript behavior. Specifically they use assign semantics instead of define semantics (e.g. setters are triggered) and fields without an initializer are not initialized at all. However, when this legacy behavior is combined with standard JavaScript decorators, TypeScript switches to always initializing all fields, even those without initializers. Previously esbuild incorrectly continued to omit field initializers for this edge case. These field initializers in this case should now be emitted starting with this release.Avoid incorrect cycle warning with
tsconfig.jsonmultiple inheritanceTypeScript 5.0 introduced multiple inheritance for
tsconfig.jsonfiles whereextendscan be an array of file paths. Previously esbuild would incorrectly treat files encountered more than once when processing separate subtrees of the multiple inheritance hierarchy as an inheritance cycle. With this release,tsconfig.jsonfiles containing this edge case should work correctly without generating a warning.Handle Yarn Plug'n'Play stack overflow with
tsconfig.jsonPreviously a
tsconfig.jsonfile thatextendsanother file in a package with anexportsmap could cause a stack overflow when Yarn's Plug'n'Play resolution was active. This edge case should work now starting with this release.Work around more issues with Deno 1.31+
This version of Deno broke the
stdinandstdoutproperties on command objects for inherited streams, which matters when you run esbuild's Deno module as the entry point (i.e. whenimport.meta.mainistrue). Previously esbuild would crash in Deno 1.31+ if you ran esbuild like that. This should be fixed starting with this release.This fix was contributed
- 0.23.x
0.23.1
16 Aug 2024Allow using the
node:import prefix withes*targetsThe
node:prefix on imports is an alternate way to import built-in node modules. For example,import fs from "fs"can also be writtenimport fs from "node:fs". This only works with certain newer versions of node, so esbuild removes it when you target older versions of node such as with--target=node14so that your code still works. With the way esbuild's platform-specific feature compatibility table works, this was added by saying that only newer versions of node support this feature. However, that means that a target such as--target=node18,es2022removes thenode:prefix because none of thees*targets are known to support this feature. This release adds the support for thenode:flag to esbuild's internal compatibility table fores*to allow you to use compound targets like this:// Original code import fs from 'node:fs' fs.open // Old output (with --bundle --format=esm --platform=node --target=node18,es2022) import fs from "fs"; fs.open; // New output (with --bundle --format=esm --platform=node --target=node18,es2022) import fs from "node:fs"; fs.open;
Fix a panic when using the CLI with invalid build flags if
--analyzeis presentPreviously esbuild's CLI could crash if it was invoked with flags that aren't valid for a "build" API call and the
--analyzeflag is present. This was caused by esbuild's internals attempting to add a Go plugin (which is how--analyzeis implemented) to a null build object. The panic has been fixed in this release.Fix incorrect location of certain error messages
This release fixes a regression that caused certain errors relating to variable declarations to be reported at an incorrect location. The regression was introduced in version 0.18.7 of esbuild.
Allow using the
node:import prefix withes*targetsThe
node:prefix on imports is an alternate way to import built-in node modules. For example,import fs from "fs"can also be writtenimport fs from "node:fs". This only works with certain newer versions of node, so esbuild removes it when you target older versions of node such as with--target=node14so that your code still works. With the way esbuild's platform-specific feature compatibility table works, this was added by saying that only newer versions of node support this feature. However, that means that a target such as--target=node18,es2022removes thenode:prefix because none of thees*targets are known to support this feature. This release adds the support for thenode:flag to esbuild's internal compatibility table fores*to allow you to use compound targets like this:// Original code import fs from 'node:fs' fs.open // Old output (with --bundle --format=esm --platform=node --target=node18,es2022) import fs from "fs"; fs.open; // New output (with --bundle --format=esm --platform=node --target=node18,es2022) import fs from "node:fs"; fs.open;
Fix a panic when using the CLI with invalid build flags if
--analyzeis presentPreviously esbuild's CLI could crash if it was invoked with flags that aren't valid for a "build" API call and the
--analyzeflag is present. This was caused by esbuild's internals attempting to add a Go plugin (which is how--analyzeis implemented) to a null build object. The panic has been fixed in this release.Fix incorrect location of certain error messages
This release fixes a regression that caused certain errors relating to variable declarations to be reported at an incorrect location. The regression was introduced in version 0.18.7 of esbuild.
Print comments before case clauses in switch statements
With this release, esbuild will attempt to print comments that come before case clauses in switch statements. This is similar to what esbuild already does for comments inside of certain types of expressions. Note that these types of comments are not printed if minification is enabled (specifically whitespace minification).
Fix a memory leak with
pluginDataWith this release, the build context's internal
pluginDatacache will now be cleared when starting a new build. This should fix a leak of memory from plugins that returnpluginDataobjects fromonResolveand/oronLoadcallbacks.
0.23.0
2 Jul 2024Revert the recent change to avoid bundling dependencies for node
This release reverts the recent change in version 0.22.0 that made
--packages=externalthe default behavior with--platform=node. The default is now back to--packages=bundle.I've just been made aware that Amazon doesn't pin their dependencies in their "AWS CDK" product, which means that whenever esbuild publishes a new release, many people (potentially everyone?) using their SDK around the world instantly starts using it without Amazon checking that it works first. This change in version 0.22.0 happened to break their SDK. I'm amazed that things haven't broken before this point. This revert attempts to avoid these problems for Amazon's customers. Hopefully Amazon will pin their dependencies in the future.
In addition, this is probably a sign that esbuild is used widely enough that it now needs to switch to a more complicated release model. I may have esbuild use a beta channel model for further development.
Fix preserving collapsed JSX whitespace
When transformed, certain whitespace inside JSX elements is ignored completely if it collapses to an empty string. However, the whitespace should only be ignored if the JSX is being transformed, not if it's being preserved. This release fixes a bug where esbuild was previously incorrectly ignoring collapsed whitespace with
--jsx=preserve. Here is an example:// Original code <Foo> <Bar /> </Foo> // Old output (with --jsx=preserve) <Foo><Bar /></Foo>; // New output (with --jsx=preserve) <Foo> <Bar /> </Foo>;
This release deliberately contains backwards-incompatible changes. To avoid automatically picking up releases like this, you should either be pinning the exact version of
esbuildin yourpackage.jsonfile (recommended) or be using a version range syntax that only accepts patch upgrades such as^0.22.0or~0.22.0. See npm's documentation about semver for more information.Revert the recent change to avoid bundling dependencies for node
This release reverts the recent change in version 0.22.0 that made
--packages=externalthe default behavior with--platform=node. The default is now back to--packages=bundle.I've just been made aware that Amazon doesn't pin their dependencies in their "AWS CDK" product, which means that whenever esbuild publishes a new release, many people (potentially everyone?) using their SDK around the world instantly starts using it without Amazon checking that it works first. This change in version 0.22.0 happened to break their SDK. I'm amazed that things haven't broken before this point. This revert attempts to avoid these problems for Amazon's customers. Hopefully Amazon will pin their dependencies in the future.
In addition, this is probably a sign that esbuild is used widely enough that it now needs to switch to a more complicated release model. I may have esbuild use a beta channel model for further development.
Fix preserving collapsed JSX whitespace
When transformed, certain whitespace inside JSX elements is ignored completely if it collapses to an empty string. However, the whitespace should only be ignored if the JSX is being transformed, not if it's being preserved. This release fixes a bug where esbuild was previously incorrectly ignoring collapsed whitespace with
--jsx=preserve. Here is an example:// Original code <Foo> <Bar /> </Foo> // Old output (with --jsx=preserve) <Foo><Bar /></Foo>; // New output (with --jsx=preserve) <Foo> <Bar /> </Foo>;
- 0.22.x
0.22.0
30 Jun 2024- Removed
Drop support for older platforms
This release drops support for the following operating systems:
This is because the Go programming language dropped support for these operating system versions in Go 1.21, and this release updates esbuild from Go 1.20 to Go 1.22.
Note that this only affects the binary esbuild executables that are published to the
esbuildnpm package. It's still possible to compile esbuild's source code for these older operating systems. If you need to, you can compile esbuild for yourself using an older version of the Go compiler (before Go version 1.21). That might look something like this:git clone https://github.com/evanw/esbuild.git cd esbuild go build ./cmd/esbuild ./esbuild.exe --version
In addition, this release increases the minimum required node version for esbuild's JavaScript API from node 12 to node 18. Node 18 is the oldest version of node that is still being supported (see node's release schedule for more information). This increase is because of an incompatibility between the JavaScript that the Go compiler generates for the
esbuild-wasmpackage and versions of node before node 17.4 (specifically thecrypto.getRandomValuesfunction). Omit packages from bundles by default when targeting node (#1874, #2830, #2846, #2915, #3145, #3294, #3323, #3582, #3809, #3815)
This breaking change is an experiment. People are commonly confused when using esbuild to bundle code for node (i.e. for
--platform=node) because some packages may not be intended for bundlers, and may use node-specific features that don't work with a bundler. Even though esbuild's "getting started" instructions say to use--packages=externalto work around this problem, many people don't read the documentation and don't do this, and are then confused when it doesn't work. So arguably this is a bad default behavior for esbuild to have if people keep tripping over this.With this release, esbuild will now omit packages from the bundle by default when the platform is
node(i.e. the previous behavior of--packages=externalis now the default in this case). Note that your dependencies must now be present on the file system when your bundle is run. If you don't want this behavior, you can do--packages=bundleto allow packages to be included in the bundle (i.e. the previous default behavior). Note that--packages=bundledoesn't mean all packages are bundled, just that packages are allowed to be bundled. You can still exclude individual packages from the bundle using--external:even when--packages=bundleis present.The
--packages=setting considers all import paths that "look like" package imports in the original source code to be package imports. Specifically import paths that don't start with a path segment of/or.or..are considered to be package imports. The only two exceptions to this rule are subpath imports (which start with a#character) and TypeScript path remappings viapathsand/orbaseUrlintsconfig.json(which are applied first).Update
await usingbehavior to match TypeScriptTypeScript 5.5 subtly changes the way
await usingbehaves. This release updates esbuild to match these changes in TypeScript. You can read more about these changes in microsoft/TypeScript#58624.
This release deliberately contains backwards-incompatible changes. To avoid automatically picking up releases like this, you should either be pinning the exact version of
esbuildin yourpackage.jsonfile (recommended) or be using a version range syntax that only accepts patch upgrades such as^0.21.0or~0.21.0. See npm's documentation about semver for more information.Omit packages from bundles by default when targeting node (#1874, #2830, #2846, #2915, #3145, #3294, #3323, #3582, #3809, #3815)
This breaking change is an experiment. People are commonly confused when using esbuild to bundle code for node (i.e. for
--platform=node) because some packages may not be intended for bundlers, and may use node-specific features that don't work with a bundler. Even though esbuild's "getting started" instructions say to use--packages=externalto work around this problem, many people don't read the documentation and don't do this, and are then confused when it doesn't work. So arguably this is a bad default behavior for esbuild to have if people keep tripping over this.With this release, esbuild will now omit packages from the bundle by default when the platform is
node(i.e. the previous behavior of--packages=externalis now the default in this case). Note that your dependencies must now be present on the file system when your bundle is run. If you don't want this behavior, you can do--packages=bundleto allow packages to be included in the bundle (i.e. the previous default behavior). Note that--packages=bundledoesn't mean all packages are bundled, just that packages are allowed to be bundled. You can still exclude individual packages from the bundle using--external:even when--packages=bundleis present.The
--packages=setting considers all import paths that "look like" package imports in the original source code to be package imports. Specifically import paths that don't start with a path segment of/or.or..are considered to be package imports. The only two exceptions to this rule are subpath imports (which start with a#character) and TypeScript path remappings viapathsand/orbaseUrlintsconfig.json(which are applied first).- Removed
Drop support for older platforms
This release drops support for the following operating systems:
Windows 7
Windows 8
Windows Server 2008
Windows Server 2012
This is because the Go programming language dropped support for these operating system versions in Go 1.21, and this release updates esbuild from Go 1.20 to Go 1.22.
Note that this only affects the binary esbuild executables that are published to the
esbuildnpm package. It's still possible to compile esbuild's source code for these older operating systems. If you need to, you can compile esbuild for yourself using an older version of the Go compiler (before Go version 1.21). That might look something like this:git clone https://github.com/evanw/esbuild.git cd esbuild go build ./cmd/esbuild ./esbuild.exe --version
In addition, this release increases the minimum required node version for esbuild's JavaScript API from node 12 to node 18. Node 18 is the oldest version of node that is still being supported (see node's release schedule for more information). This increase is because of an incompatibility between the JavaScript that the Go compiler generates for the
esbuild-wasmpackage and versions of node before node 17.4 (specifically thecrypto.getRandomValuesfunction). Update
await usingbehavior to match TypeScriptTypeScript 5.5 subtly changes the way
await usingbehaves. This release updates esbuild to match these changes in TypeScript. You can read more about these changes in microsoft/TypeScript#58624.Allow
es2024as a target environmentThe ECMAScript 2024 specification was just approved, so it has been added to esbuild as a possible compilation target. You can read more about the features that it adds here: 2ality.com/2024/06/ecmascript-2024.html. The only addition that's relevant for esbuild is the regular expression
/vflag. With--target=es2024, regular expressions that use the/vflag will now be passed through untransformed instead of being transformed into a call tonew RegExp.Publish binaries for OpenBSD on 64-bit ARM (#3665, #3674)
With this release, you should now be able to install the
esbuildnpm package in OpenBSD on 64-bit ARM, such as on an Apple device with an M1 chip.This was contributed
Publish binaries for WASI (WebAssembly System Interface) preview 1 (#3300, #3779)
The upcoming WASI (WebAssembly System Interface) standard is going to be a way to run WebAssembly outside of a JavaScript host environment. In this scenario you only need a
.wasmfile without any supporting JavaScript code. Instead of JavaScript providing the APIs for the host environment, the WASI standard specifies a "system interface" that WebAssembly code can access directly (e.g. for file system access).Development versions of the WASI specification are being released using preview numbers. The people behind WASI are currently working on preview 2 but the Go compiler has released support for preview 1, which from what I understand is now considered an unsupported legacy release. However, some people have requested that esbuild publish binary executables that support WASI preview 1 so they can experiment with them.
This release publishes esbuild precompiled for WASI preview 1 to the
@esbuild/wasi-preview1package on npm (specifically the file@esbuild/wasi-preview1/esbuild.wasm). This binary executable has not been tested and won't be officially supported, as it's for an old preview release of a specification that has since moved in another direction. If it works for you, great! If not, then you'll likely have to wait for the ecosystem to evolve before using esbuild with WASI. For example, it sounds like perhaps WASI preview 1 doesn't include support for opening network sockets so esbuild's local development server is unlikely to work with WASI preview 1.Warn about
onResolveplugins not setting a pathPlugins that return values from
onResolvewithout resolving the path (i.e. without setting eitherpathorexternal: true) will now cause a warning. This is because esbuild only uses return values fromonResolveif it successfully resolves the path, and it's not good for invalid input to be silently ignored.Add a new Go API for running the CLI with plugins
With esbuild's Go API, you can now call
cli.RunWithPlugins(args, plugins)to pass an array of esbuild plugins to be used during the build process. This allows you to create a CLI that behaves similarly to esbuild's CLI but with additional Go plugins enabled.This was contributed
- 0.21.x
0.21.5
9 Jun 2024Fix
Symbol.metadataon classes without a class decoratorThis release fixes a bug with esbuild's support for the decorator metadata proposal. Previously esbuild only added the
Symbol.metadataproperty to decorated classes if there was a decorator on the class element itself. However, the proposal says that theSymbol.metadataproperty should be present on all classes that have any decorators at all, not just those with a decorator on the class element itself.Allow unknown import attributes to be used with the
copyloaderImport attributes (the
withkeyword onimportstatements) are allowed to alter how that path is loaded. For example, esbuild cannot assume that it knows how to load./bagel.jsas typebagel:// This is an error with "--bundle" without also using "--external:./bagel.js" import tasty from "./bagel.js" with { type: "bagel" }Because of that, bundling this code with esbuild is an error unless the file
./bagel.jsis external to the bundle (such as with--bundle --external:./bagel.js).However, there is an additional case where it's ok for esbuild to allow this: if the file is loaded using the
copyloader. That's because thecopyloader behaves similarly to--externalin that the file is left external to the bundle. The difference is that thecopyloader copies the file into the output folder and rewrites the import path while--externaldoesn't. That means the following will now work with thecopyloader (such as with--bundle --loader:.bagel=copy):// This is no longer an error with "--bundle" and "--loader:.bagel=copy" import tasty from "./tasty.bagel" with { type: "bagel" }Support import attributes with glob-style imports
This release adds support for import attributes (the
withoption) to glob-style imports (dynamic imports with certain string literal patterns as paths). These imports previously didn't support import attributes due to an oversight. So code like this will now work correctly:async function loadLocale(locale: string): Locale { const data = await import(`./locales/${locale}.data`, { with: { type: 'json' } }) return unpackLocale(locale, data) }Previously this didn't work even though esbuild normally supports forcing the JSON loader using an import attribute. Attempting to do this used to result in the following error:
✘ [ERROR] No loader is configured for ".data" files: locales/en-US.data example.ts:2:28: 2 │ const data = await import(`./locales/${locale}.data`, { with: { type: 'json' } }) ╵ ~~~~~~~~~~~~~~~~~~~~~~~~~~In addition, this change means plugins can now access the contents of
withfor glob-style imports.
Fix
Symbol.metadataon classes without a class decoratorThis release fixes a bug with esbuild's support for the decorator metadata proposal. Previously esbuild only added the
Symbol.metadataproperty to decorated classes if there was a decorator on the class element itself. However, the proposal says that theSymbol.metadataproperty should be present on all classes that have any decorators at all, not just those with a decorator on the class element itself.Allow unknown import attributes to be used with the
copyloaderImport attributes (the
withkeyword onimportstatements) are allowed to alter how that path is loaded. For example, esbuild cannot assume that it knows how to load./bagel.jsas typebagel:// This is an error with "--bundle" without also using "--external:./bagel.js" import tasty from "./bagel.js" with { type: "bagel" }Because of that, bundling this code with esbuild is an error unless the file
./bagel.jsis external to the bundle (such as with--bundle --external:./bagel.js).However, there is an additional case where it's ok for esbuild to allow this: if the file is loaded using the
copyloader. That's because thecopyloader behaves similarly to--externalin that the file is left external to the bundle. The difference is that thecopyloader copies the file into the output folder and rewrites the import path while--externaldoesn't. That means the following will now work with thecopyloader (such as with--bundle --loader:.bagel=copy):// This is no longer an error with "--bundle" and "--loader:.bagel=copy" import tasty from "./tasty.bagel" with { type: "bagel" }Support import attributes with glob-style imports
This release adds support for import attributes (the
withoption) to glob-style imports (dynamic imports with certain string literal patterns as paths). These imports previously didn't support import attributes due to an oversight. So code like this will now work correctly:async function loadLocale(locale: string): Locale { const data = await import(`./locales/${locale}.data`, { with: { type: 'json' } }) return unpackLocale(locale, data) }Previously this didn't work even though esbuild normally supports forcing the JSON loader using an import attribute. Attempting to do this used to result in the following error:
✘ [ERROR] No loader is configured for ".data" files: locales/en-US.data example.ts:2:28: 2 │ const data = await import(`./locales/${locale}.data`, { with: { type: 'json' } }) ╵ ~~~~~~~~~~~~~~~~~~~~~~~~~~In addition, this change means plugins can now access the contents of
withfor glob-style imports.Support
${configDir}intsconfig.jsonfilesThis adds support for a new feature from the upcoming TypeScript 5.5 release. The character sequence
${configDir}is now respected at the start ofbaseUrlandpathsvalues, which are used by esbuild during bundling to correctly map import paths to file system paths. This feature lets basetsconfig.jsonfiles specified viaextendsrefer to the directory of the top-leveltsconfig.jsonfile. Here is an example:{ "compilerOptions": { "paths": { "js/*": ["${configDir}/dist/js/*"] } } }You can read more in TypeScript's blog post about their upcoming 5.5 release. Note that this feature does not make use of template literals (you need to use
"${configDir}/dist/js/*"not`${configDir}/dist/js/*`). The syntax fortsconfig.jsonis still just JSON with comments, and JSON syntax does not allow template literals. This feature only recognizes${configDir}in strings for certain path-like properties, and only at the beginning of the string.Fix internal error with
--supported:object-accessors=falseThis release fixes a regression in 0.21.0 where some code that was added to esbuild's internal runtime library of helper functions for JavaScript decorators fails to parse when you configure esbuild with
--supported:object-accessors=false. The reason is that esbuild introduced code that does{ get [name]() {} }which uses both theobject-extensionsfeature for the[name]and theobject-accessorsfeature for theget, but esbuild was incorrectly only checking forobject-extensionsand not forobject-accessors. Additional tests have been added to avoid this type of issue in the future. A workaround for this issue in earlier releases is to also add--supported:object-extensions=false.
0.21.4
25 May 2024Update support for import assertions and import attributes in node
Import assertions (the
assertkeyword) have been removed from node starting in v22.0.0. So esbuild will now strip them and generate a warning with--target=node22or above:▲ [WARNING] The "assert" keyword is not supported in the configured target environment ("node22") [assert-to-with] example.mjs:1:40: 1 │ import json from "esbuild/package.json" assert { type: "json" } │ ~~~~~~ ╵ with Did you mean to use "with" instead of "assert"?Import attributes (the
withkeyword) have been backported to node 18 starting in v18.20.0. So esbuild will no longer strip them with--target=node18.NifNis 20 or greater.Fix
for awaittransform when a label is presentThis release fixes a bug where the
for awaittransform, which wraps the loop in atrystatement, previously failed to also move the loop's label into thetrystatement. This bug only affects code that uses both of these features in combination. Here's an example of some affected code:// Original code async function test() { outer: for await (const x of [Promise.resolve([0, 1])]) { for (const y of x) if (y) break outer throw 'fail' } } // Old output (with --target=es6) function test() { return __async(this, null, function* () { outer: try { for (var iter = __forAwait([Promise.resolve([0, 1])]), more, temp, error; more = !(temp = yield iter.next()).done; more = false) { const x = temp.value; for (const y of x) if (y) break outer; throw "fail"; } } catch (temp) { error = [temp]; } finally { try { more && (temp = iter.return) && (yield temp.call(iter)); } finally { if (error) throw error[0]; } } }); } // New output (with --target=es6) function test() { return __async(this, null, function* () { try { outer: for (var iter = __forAwait([Promise.resolve([0, 1])]), more, temp, error; more = !(temp = yield iter.next()).done; more = false) { const x = temp.value; for (const y of x) if (y) break outer; throw "fail"; } } catch (temp) { error = [temp]; } finally { try { more && (temp = iter.return) && (yield temp.call(iter)); } finally { if (error) throw error[0]; } } }); }Do additional constant folding after cross-module enum inlining (#3416, #3425)
This release adds a few more cases where esbuild does constant folding after cross-module enum inlining.
// Original code: enum.ts export enum Platform { WINDOWS = 'windows', MACOS = 'macos', LINUX = 'linux', } // Original code: main.ts import { Platform } from './enum'; declare const PLATFORM: string; export function logPlatform() { if (PLATFORM == Platform.WINDOWS) console.log('Windows'); else if (PLATFORM == Platform.MACOS) console.log('macOS'); else if (PLATFORM == Platform.LINUX) console.log('Linux'); else console.log('Other'); } // Old output (with --bundle '--define:PLATFORM="macos"' --minify --format=esm) function n(){"windows"=="macos"?console.log("Windows"):"macos"=="macos"?console.log("macOS"):"linux"=="macos"?console.log("Linux"):console.log("Other")}export{n as logPlatform}; // New output (with --bundle '--define:PLATFORM="macos"' --minify --format=esm) function n(){console.log("macOS")}export{n as logPlatform};
Update support for import assertions and import attributes in node
Import assertions (the
assertkeyword) have been removed from node starting in v22.0.0. So esbuild will now strip them and generate a warning with--target=node22or above:▲ [WARNING] The "assert" keyword is not supported in the configured target environment ("node22") [assert-to-with] example.mjs:1:40: 1 │ import json from "esbuild/package.json" assert { type: "json" } │ ~~~~~~ ╵ with Did you mean to use "with" instead of "assert"?Import attributes (the
withkeyword) have been backported to node 18 starting in v18.20.0. So esbuild will no longer strip them with--target=node18.NifNis 20 or greater.Fix
for awaittransform when a label is presentThis release fixes a bug where the
for awaittransform, which wraps the loop in atrystatement, previously failed to also move the loop's label into thetrystatement. This bug only affects code that uses both of these features in combination. Here's an example of some affected code:// Original code async function test() { outer: for await (const x of [Promise.resolve([0, 1])]) { for (const y of x) if (y) break outer throw 'fail' } } // Old output (with --target=es6) function test() { return __async(this, null, function* () { outer: try { for (var iter = __forAwait([Promise.resolve([0, 1])]), more, temp, error; more = !(temp = yield iter.next()).done; more = false) { const x = temp.value; for (const y of x) if (y) break outer; throw "fail"; } } catch (temp) { error = [temp]; } finally { try { more && (temp = iter.return) && (yield temp.call(iter)); } finally { if (error) throw error[0]; } } }); } // New output (with --target=es6) function test() { return __async(this, null, function* () { try { outer: for (var iter = __forAwait([Promise.resolve([0, 1])]), more, temp, error; more = !(temp = yield iter.next()).done; more = false) { const x = temp.value; for (const y of x) if (y) break outer; throw "fail"; } } catch (temp) { error = [temp]; } finally { try { more && (temp = iter.return) && (yield temp.call(iter)); } finally { if (error) throw error[0]; } } }); }Do additional constant folding after cross-module enum inlining (#3416, #3425)
This release adds a few more cases where esbuild does constant folding after cross-module enum inlining.
// Original code: enum.ts export enum Platform { WINDOWS = 'windows', MACOS = 'macos', LINUX = 'linux', } // Original code: main.ts import { Platform } from './enum'; declare const PLATFORM: string; export function logPlatform() { if (PLATFORM == Platform.WINDOWS) console.log('Windows'); else if (PLATFORM == Platform.MACOS) console.log('macOS'); else if (PLATFORM == Platform.LINUX) console.log('Linux'); else console.log('Other'); } // Old output (with --bundle '--define:PLATFORM="macos"' --minify --format=esm) function n(){"windows"=="macos"?console.log("Windows"):"macos"=="macos"?console.log("macOS"):"linux"=="macos"?console.log("Linux"):console.log("Other")}export{n as logPlatform}; // New output (with --bundle '--define:PLATFORM="macos"' --minify --format=esm) function n(){console.log("macOS")}export{n as logPlatform};Pass import attributes to on-resolve plugins (#3384, #3639, #3646)
With this release, on-resolve plugins will now have access to the import attributes on the import via the
withproperty of the arguments object. This mirrors thewithproperty of the arguments object that's already passed to on-load plugins. In addition, you can now passwithto theresolve()API call which will then forward that value on to all relevant plugins. Here's an example of a plugin that can now be written:const examplePlugin = { name: 'Example plugin', setup(build) { build.onResolve({ filter: /.*/ }, args => { if (args.with.type === 'external') return { external: true } }) } } require('esbuild').build({ stdin: { contents: ` import foo from "./foo" with { type: "external" } foo() `, }, bundle: true, format: 'esm', write: false, plugins: [examplePlugin], }).then(result => { console.log(result.outputFiles[0].text) })Formatting support for the
@position-tryruleChrome shipped this new CSS at-rule in version 125 as part of the CSS anchor positioning API. With this release, esbuild now knows to expect a declaration list inside of the
@position-trybody block and will format it appropriately.Always allow internal string import and export aliases
Import and export names can be string literals in ES2022+. Previously esbuild forbid any usage of these aliases when the target was below ES2022. Starting with this release, esbuild will only forbid such usage when the alias would otherwise end up in output as a string literal. String literal aliases that are only used internally in the bundle and are "compiled away" are no longer errors. This makes it possible to use string literal aliases with esbuild's
injectfeature even when the target is earlier than ES2022.
0.21.3
15 May 2024Implement the decorator metadata proposal
This release implements the decorator metadata proposal, which is a sub-proposal of the decorators proposal. Microsoft shipped the decorators proposal in TypeScript 5.0 and the decorator metadata proposal in TypeScript 5.2, so it's important that esbuild also supports both of these features. Here's a quick example:
// Shim the "Symbol.metadata" symbol Symbol.metadata ??= Symbol('Symbol.metadata') const track = (_, context) => { (context.metadata.names ||= []).push(context.name) } class Foo { @track foo = 1 @track bar = 2 } // Prints ["foo", "bar"] console.log(Foo[Symbol.metadata].names)⚠️ WARNING ⚠️
This proposal has been marked as "stage 3" which means "recommended for implementation". However, it's still a work in progress and isn't a part of JavaScript yet, so keep in mind that any code that uses JavaScript decorator metadata may need to be updated as the feature continues to evolve. If/when that happens, I will update esbuild's implementation to match the specification. I will not be supporting old versions of the specification.
Fix bundled decorators in derived classes
In certain cases, bundling code that uses decorators in a derived class with a class body that references its own class name could previously generate code that crashes at run-time due to an incorrect variable name. This problem has been fixed. Here is an example of code that was compiled incorrectly before this fix:
class Foo extends Object { @(x => x) foo() { return Foo } } console.log(new Foo().foo())Fix
tsconfig.jsonfiles inside symlinked directoriesThis release fixes an issue with a scenario involving a
tsconfig.jsonfile thatextendsanother file from within a symlinked directory that uses thepathsfeature. In that case, the implicitbaseURLvalue should be based on the real path (i.e. after expanding all symbolic links) instead of the original path. This was already done for other files that esbuild resolves but was not yet done fortsconfig.jsonbecause it's special-cased (the regular path resolver can't be used because the information insidetsconfig.jsonis involved in path resolution). Note that this fix no longer applies if the--preserve-symlinkssetting is enabled.
0.21.2
12 May 2024Correct
thisin field and accessor decoratorsThis release changes the value of
thisin initializers for class field and accessor decorators from the module-levelthisvalue to the appropriatethisvalue for the decorated element (either the class or the instance). It was previously incorrect due to lack of test coverage. Here's an example of a decorator that doesn't work without this change:const dec = () => function() { this.bar = true } class Foo { @dec static foo } console.log(Foo.bar) // Should be "true"Allow
es2023as a target environmentTypeScript recently added
es2023as a compilation target, so esbuild now supports this too. There is no difference between a target ofes2022andes2023as far as esbuild is concerned since the 2023 edition of JavaScript doesn't introduce any new syntax features.
0.21.1
7 May 2024Fix a regression with
--keep-namesThe previous release introduced a regression with the
--keep-namessetting and object literals withget/setaccessor methods, in which case the generated code contained syntax errors. This release fixes the regression:// Original code x = { get y() {} } // Output from version 0.21.0 (with --keep-names) x = { get y: /* @__PURE__ */ __name(function() { }, "y") }; // Output from this version (with --keep-names) x = { get y() { } };
0.21.0
7 May 2024Implement the JavaScript decorators proposal
With this release, esbuild now contains an implementation of the upcoming JavaScript decorators proposal. This is the same feature that shipped in TypeScript 5.0 and has been highly-requested on esbuild's issue tracker. You can read more about them in that blog post and in this other (now slightly outdated) extensive blog post here: 2ality.com/2022/10/javascript-decorators.html. Here's a quick example:
const log = (fn, context) => function() { console.log(`before ${context.name}`) const it = fn.apply(this, arguments) console.log(`after ${context.name}`) return it } class Foo { @log static foo() { console.log('in foo') } } // Logs "before foo", "in foo", "after foo" Foo.foo()Note that this feature is different than the existing "TypeScript experimental decorators" feature that esbuild already implements. It uses similar syntax but behaves very differently, and the two are not compatible (although it's sometimes possible to write decorators that work with both). TypeScript experimental decorators will still be supported by esbuild going forward as they have been around for a long time, are very widely used, and let you do certain things that are not possible with JavaScript decorators (such as decorating function parameters). By default esbuild will parse and transform JavaScript decorators, but you can tell esbuild to parse and transform TypeScript experimental decorators instead by setting
"experimentalDecorators": truein yourtsconfig.jsonfile.Probably at least half of the work for this feature went into creating a test suite that exercises many of the proposal's edge cases: github.com/evanw/decorator-tests. It has given me a reasonable level of confidence that esbuild's initial implementation is acceptable. However, I don't have access to a significant sample of real code that uses JavaScript decorators. If you're currently using JavaScript decorators in a real code base, please try out esbuild's implementation and let me know if anything seems off.
⚠️ WARNING ⚠️
This proposal has been in the works for a very long time (work began around 10 years ago in 2014) and it is finally getting close to becoming part of the JavaScript language. However, it's still a work in progress and isn't a part of JavaScript yet, so keep in mind that any code that uses JavaScript decorators may need to be updated as the feature continues to evolve. The decorators proposal is pretty close to its final form but it can and likely will undergo some small behavioral adjustments before it ends up becoming a part of the standard. If/when that happens, I will update esbuild's implementation to match the specification. I will not be supporting old versions of the specification.
Optimize the generated code for private methods
Previously when lowering private methods for old browsers, esbuild would generate one
WeakSetfor each private method. This mirrors similar logic for generating oneWeakSetfor each private field. Using a separateWeakMapfor private fields is necessary as their assignment can be observable:let it class Bar { constructor() { it = this } } class Foo extends Bar { #x = 1 #y = null.foo static check() { console.log(#x in it, #y in it) } } try { new Foo } catch {} Foo.check()This prints
true falsebecause this partially-initialized instance has#xbut not#y. In other words, it's not true that all class instances will always have all of their private fields. However, the assignment of private methods to a class instance is not observable. In other words, it's true that all class instances will always have all of their private methods. This means esbuild can lower private methods into code where all methods share a singleWeakSet, which is smaller, faster, and uses less memory. Other JavaScript processing tools such as the TypeScript compiler already make this optimization. Here's what this change looks like:// Original code class Foo { #x() { return this.#x() } #y() { return this.#y() } #z() { return this.#z() } } // Old output (--supported:class-private-method=false) var _x, x_fn, _y, y_fn, _z, z_fn; class Foo { constructor() { __privateAdd(this, _x); __privateAdd(this, _y); __privateAdd(this, _z); } } _x = new WeakSet(); x_fn = function() { return __privateMethod(this, _x, x_fn).call(this); }; _y = new WeakSet(); y_fn = function() { return __privateMethod(this, _y, y_fn).call(this); }; _z = new WeakSet(); z_fn = function() { return __privateMethod(this, _z, z_fn).call(this); }; // New output (--supported:class-private-method=false) var _Foo_instances, x_fn, y_fn, z_fn; class Foo { constructor() { __privateAdd(this, _Foo_instances); } } _Foo_instances = new WeakSet(); x_fn = function() { return __privateMethod(this, _Foo_instances, x_fn).call(this); }; y_fn = function() { return __privateMethod(this, _Foo_instances, y_fn).call(this); }; z_fn = function() { return __privateMethod(this, _Foo_instances, z_fn).call(this); };Fix an obscure bug with lowering class members with computed property keys
When class members that use newer syntax features are transformed for older target environments, they sometimes need to be relocated. However, care must be taken to not reorder any side effects caused by computed property keys. For example, the following code must evaluate
a()thenb()thenc():class Foo { [a()]() {} [b()]; static { c() } }Previously esbuild did this by shifting the computed property key forward to the next spot in the evaluation order. Classes evaluate all computed keys first and then all static class elements, so if the last computed key needs to be shifted, esbuild previously inserted a static block at start of the class body, ensuring it came before all other static class elements:
var _a; class Foo { constructor() { __publicField(this, _a); } static { _a = b(); } [a()]() { } static { c(); } }However, this could cause esbuild to accidentally generate a syntax error if the computed property key contains code that isn't allowed in a static block, such as an
awaitexpression. With this release, esbuild fixes this problem by shifting the computed property key backward to the previous spot in the evaluation order instead, which may push it into theextendsclause or even before the class itself:// Original code class Foo { [a()]() {} [await b()]; static { c() } } // Old output (with --supported:class-field=false) var _a; class Foo { constructor() { __publicField(this, _a); } static { _a = await b(); } [a()]() { } static { c(); } } // New output (with --supported:class-field=false) var _a, _b; class Foo { constructor() { __publicField(this, _a); } [(_b = a(), _a = await b(), _b)]() { } static { c(); } }
This release doesn't contain any deliberately-breaking changes. However, it contains a very complex new feature and while all of esbuild's tests pass, I would not be surprised if an important edge case turns out to be broken. So I'm releasing this as a breaking change release to avoid causing any trouble. As usual, make sure to test your code when you upgrade.
Implement the JavaScript decorators proposal
With this release, esbuild now contains an implementation of the upcoming JavaScript decorators proposal. This is the same feature that shipped in TypeScript 5.0 and has been highly-requested on esbuild's issue tracker. You can read more about them in that blog post and in this other (now slightly outdated) extensive blog post here: 2ality.com/2022/10/javascript-decorators.html. Here's a quick example:
const log = (fn, context) => function() { console.log(`before ${context.name}`) const it = fn.apply(this, arguments) console.log(`after ${context.name}`) return it } class Foo { @log static foo() { console.log('in foo') } } // Logs "before foo", "in foo", "after foo" Foo.foo()Note that this feature is different than the existing "TypeScript experimental decorators" feature that esbuild already implements. It uses similar syntax but behaves very differently, and the two are not compatible (although it's sometimes possible to write decorators that work with both). TypeScript experimental decorators will still be supported by esbuild going forward as they have been around for a long time, are very widely used, and let you do certain things that are not possible with JavaScript decorators (such as decorating function parameters). By default esbuild will parse and transform JavaScript decorators, but you can tell esbuild to parse and transform TypeScript experimental decorators instead by setting
"experimentalDecorators": truein yourtsconfig.jsonfile.Probably at least half of the work for this feature went into creating a test suite that exercises many of the proposal's edge cases: github.com/evanw/decorator-tests. It has given me a reasonable level of confidence that esbuild's initial implementation is acceptable. However, I don't have access to a significant sample of real code that uses JavaScript decorators. If you're currently using JavaScript decorators in a real code base, please try out esbuild's implementation and let me know if anything seems off.
⚠️ WARNING ⚠️
This proposal has been in the works for a very long time (work began around 10 years ago in 2014) and it is finally getting close to becoming part of the JavaScript language. However, it's still a work in progress and isn't a part of JavaScript yet, so keep in mind that any code that uses JavaScript decorators may need to be updated as the feature continues to evolve. The decorators proposal is pretty close to its final form but it can and likely will undergo some small behavioral adjustments before it ends up becoming a part of the standard. If/when that happens, I will update esbuild's implementation to match the specification. I will not be supporting old versions of the specification.
Optimize the generated code for private methods
Previously when lowering private methods for old browsers, esbuild would generate one
WeakSetfor each private method. This mirrors similar logic for generating oneWeakSetfor each private field. Using a separateWeakMapfor private fields is necessary as their assignment can be observable:let it class Bar { constructor() { it = this } } class Foo extends Bar { #x = 1 #y = null.foo static check() { console.log(#x in it, #y in it) } } try { new Foo } catch {} Foo.check()This prints
true falsebecause this partially-initialized instance has#xbut not#y. In other words, it's not true that all class instances will always have all of their private fields. However, the assignment of private methods to a class instance is not observable. In other words, it's true that all class instances will always have all of their private methods. This means esbuild can lower private methods into code where all methods share a singleWeakSet, which is smaller, faster, and uses less memory. Other JavaScript processing tools such as the TypeScript compiler already make this optimization. Here's what this change looks like:// Original code class Foo { #x() { return this.#x() } #y() { return this.#y() } #z() { return this.#z() } } // Old output (--supported:class-private-method=false) var _x, x_fn, _y, y_fn, _z, z_fn; class Foo { constructor() { __privateAdd(this, _x); __privateAdd(this, _y); __privateAdd(this, _z); } } _x = new WeakSet(); x_fn = function() { return __privateMethod(this, _x, x_fn).call(this); }; _y = new WeakSet(); y_fn = function() { return __privateMethod(this, _y, y_fn).call(this); }; _z = new WeakSet(); z_fn = function() { return __privateMethod(this, _z, z_fn).call(this); }; // New output (--supported:class-private-method=false) var _Foo_instances, x_fn, y_fn, z_fn; class Foo { constructor() { __privateAdd(this, _Foo_instances); } } _Foo_instances = new WeakSet(); x_fn = function() { return __privateMethod(this, _Foo_instances, x_fn).call(this); }; y_fn = function() { return __privateMethod(this, _Foo_instances, y_fn).call(this); }; z_fn = function() { return __privateMethod(this, _Foo_instances, z_fn).call(this); };Fix an obscure bug with lowering class members with computed property keys
When class members that use newer syntax features are transformed for older target environments, they sometimes need to be relocated. However, care must be taken to not reorder any side effects caused by computed property keys. For example, the following code must evaluate
a()thenb()thenc():class Foo { [a()]() {} [b()]; static { c() } }Previously esbuild did this by shifting the computed property key forward to the next spot in the evaluation order. Classes evaluate all computed keys first and then all static class elements, so if the last computed key needs to be shifted, esbuild previously inserted a static block at start of the class body, ensuring it came before all other static class elements:
var _a; class Foo { constructor() { __publicField(this, _a); } static { _a = b(); } [a()]() { } static { c(); } }However, this could cause esbuild to accidentally generate a syntax error if the computed property key contains code that isn't allowed in a static block, such as an
awaitexpression. With this release, esbuild fixes this problem by shifting the computed property key backward to the previous spot in the evaluation order instead, which may push it into theextendsclause or even before the class itself:// Original code class Foo { [a()]() {} [await b()]; static { c() } } // Old output (with --supported:class-field=false) var _a; class Foo { constructor() { __publicField(this, _a); } static { _a = await b(); } [a()]() { } static { c(); } } // New output (with --supported:class-field=false) var _a, _b; class Foo { constructor() { __publicField(this, _a); } [(_b = a(), _a = await b(), _b)]() { } static { c(); } }Fix some
--keep-namesedge casesThe
NamedEvaluationsyntax-directed operation in the JavaScript specification gives certain anonymous expressions anameproperty depending on where they are in the syntax tree. For example, the following initializers convey anamevalue:var foo = function() {} var bar = class {} console.log(foo.name, bar.name)When you enable esbuild's
--keep-namessetting, esbuild generates additional code to represent thisNamedEvaluationoperation so that the value of thenameproperty persists even when the identifiers are renamed (e.g. due to minification).However, I recently learned that esbuild's implementation of
NamedEvaluationis missing a few cases. Specifically esbuild was missing property definitions, class initializers, logical-assignment operators. These cases should now all be handled:var obj = { foo: function() {} } class Foo0 { foo = function() {} } class Foo1 { static foo = function() {} } class Foo2 { accessor foo = function() {} } class Foo3 { static accessor foo = function() {} } foo ||= function() {} foo &&= function() {} foo ??= function() {}
- 0.20.x
0.20.2
14 Mar 2024Support TypeScript experimental decorators on
abstractclass fieldsWith this release, you can now use TypeScript experimental decorators on
abstractclass fields. This was silently compiled incorrectly in esbuild 0.19.7 and below, and was an error from esbuild 0.19.8 to esbuild 0.20.1. Code such as the following should now work correctly:// Original code const log = (x: any, y: string) => console.log(y) abstract class Foo { @log abstract foo: string } new class extends Foo { foo = '' } // Old output (with --loader=ts --tsconfig-raw={\"compilerOptions\":{\"experimentalDecorators\":true}}) const log = (x, y) => console.log(y); class Foo { } new class extends Foo { foo = ""; }(); // New output (with --loader=ts --tsconfig-raw={\"compilerOptions\":{\"experimentalDecorators\":true}}) const log = (x, y) => console.log(y); class Foo { } __decorateClass([ log ], Foo.prototype, "foo", 2); new class extends Foo { foo = ""; }();JSON loader now preserves
__proto__propertiesCopying JSON source code into a JavaScript file will change its meaning if a JSON object contains the
__proto__key. A literal__proto__property in a JavaScript object literal sets the prototype of the object instead of adding a property named__proto__, while a literal__proto__property in a JSON object literal just adds a property named__proto__. With this release, esbuild will now work around this problem by converting JSON to JavaScript with a computed property key in this case:// Original code import data from 'data:application/json,{"__proto__":{"fail":true}}' if (Object.getPrototypeOf(data)?.fail) throw 'fail' // Old output (with --bundle) (() => { // <data:application/json,{"__proto__":{"fail":true}}> var json_proto_fail_true_default = { __proto__: { fail: true } }; // entry.js if (Object.getPrototypeOf(json_proto_fail_true_default)?.fail) throw "fail"; })(); // New output (with --bundle) (() => { // <data:application/json,{"__proto__":{"fail":true}}> var json_proto_fail_true_default = { ["__proto__"]: { fail: true } }; // example.mjs if (Object.getPrototypeOf(json_proto_fail_true_default)?.fail) throw "fail"; })();Improve dead code removal of
switchstatementsWith this release, esbuild will now remove
switchstatements in branches when minifying if they are known to never be evaluated:// Original code if (true) foo(); else switch (bar) { case 1: baz(); break } // Old output (with --minify) if(1)foo();else switch(bar){case 1:} // New output (with --minify) foo();
Support TypeScript experimental decorators on
abstractclass fieldsWith this release, you can now use TypeScript experimental decorators on
abstractclass fields. This was silently compiled incorrectly in esbuild 0.19.7 and below, and was an error from esbuild 0.19.8 to esbuild 0.20.1. Code such as the following should now work correctly:// Original code const log = (x: any, y: string) => console.log(y) abstract class Foo { @log abstract foo: string } new class extends Foo { foo = '' } // Old output (with --loader=ts --tsconfig-raw={\"compilerOptions\":{\"experimentalDecorators\":true}}) const log = (x, y) => console.log(y); class Foo { } new class extends Foo { foo = ""; }(); // New output (with --loader=ts --tsconfig-raw={\"compilerOptions\":{\"experimentalDecorators\":true}}) const log = (x, y) => console.log(y); class Foo { } __decorateClass([ log ], Foo.prototype, "foo", 2); new class extends Foo { foo = ""; }();JSON loader now preserves
__proto__propertiesCopying JSON source code into a JavaScript file will change its meaning if a JSON object contains the
__proto__key. A literal__proto__property in a JavaScript object literal sets the prototype of the object instead of adding a property named__proto__, while a literal__proto__property in a JSON object literal just adds a property named__proto__. With this release, esbuild will now work around this problem by converting JSON to JavaScript with a computed property key in this case:// Original code import data from 'data:application/json,{"__proto__":{"fail":true}}' if (Object.getPrototypeOf(data)?.fail) throw 'fail' // Old output (with --bundle) (() => { // <data:application/json,{"__proto__":{"fail":true}}> var json_proto_fail_true_default = { __proto__: { fail: true } }; // entry.js if (Object.getPrototypeOf(json_proto_fail_true_default)?.fail) throw "fail"; })(); // New output (with --bundle) (() => { // <data:application/json,{"__proto__":{"fail":true}}> var json_proto_fail_true_default = { ["__proto__"]: { fail: true } }; // example.mjs if (Object.getPrototypeOf(json_proto_fail_true_default)?.fail) throw "fail"; })();Improve dead code removal of
switchstatementsWith this release, esbuild will now remove
switchstatements in branches when minifying if they are known to never be evaluated:// Original code if (true) foo(); else switch (bar) { case 1: baz(); break } // Old output (with --minify) if(1)foo();else switch(bar){case 1:} // New output (with --minify) foo();Empty enums should behave like an object literal
TypeScript allows you to create an empty enum and add properties to it at run time. While people usually use an empty object literal for this instead of a TypeScript enum, esbuild's enum transform didn't anticipate this use case and generated
undefinedinstead of{}for an empty enum. With this release, you can now use an empty enum to generate an empty object literal.// Original code enum Foo {} // Old output (with --loader=ts) var Foo = /* @__PURE__ */ ((Foo2) => { })(Foo || {}); // New output (with --loader=ts) var Foo = /* @__PURE__ */ ((Foo2) => { return Foo2; })(Foo || {});Handle Yarn Plug'n'Play edge case with
tsconfig.jsonPreviously a
tsconfig.jsonfile thatextendsanother file in a package with anexportsmap failed to work when Yarn's Plug'n'Play resolution was active. This edge case should work now starting with this release.Work around issues with Deno 1.31+
Version 0.20.0 of esbuild changed how the esbuild child process is run in esbuild's API for Deno. Previously it used
Deno.runbut that API is being removed in favor ofDeno.Command. As part of this change, esbuild is now calling the newunreffunction on esbuild's long-lived child process, which is supposed to allow Deno to exit when your code has finished running even though the child process is still around (previously you had to explicitly call esbuild'sstop()function to terminate the child process for Deno to be able to exit).However, this introduced a problem for Deno's testing API which now fails some tests that use esbuild with
error: Promise resolution is still pending but the event loop has already resolved. It's unclear to me why this is happening. The call tounrefwas recommended by someone on the Deno core team, and calling Node's equivalentunrefAPI has been working fine for esbuild in Node for a long time. It could be that I'm using it incorrectly, or that there's some reference counting and/or garbage collection bug in Deno's internals, or that Deno'sunrefjust works differently than Node'sunref. In any case, it's not good for Deno tests that use esbuild to be failing.In this release, I am removing the call to
unrefto fix this issue. This means that you will now have to call esbuild'sstop()function to allow Deno to exit, just like you did before esbuild version 0.20.0 when this regression was introduced.Note: This regression wasn't caught earlier because Deno doesn't seem to fail tests that have outstanding
setTimeoutcalls, which esbuild's test harness was using to enforce a maximum test runtime. Adding asetTimeoutwas allowing esbuild's Deno tests to succeed. So this regression doesn't necessarily apply to all people using tests in Deno.
0.20.1
19 Feb 2024Fix a bug with the CSS nesting transform
This release fixes a bug with the CSS nesting transform for older browsers where the generated CSS could be incorrect if a selector list contained a pseudo element followed by another selector. The bug was caused by incorrectly mutating the parent rule's selector list when filtering out pseudo elements for the child rules:
/* Original code */ .foo { &:after, & .bar { color: red; } } /* Old output (with --supported:nesting=false) */ .foo .bar, .foo .bar { color: red; } /* New output (with --supported:nesting=false) */ .foo:after, .foo .bar { color: red; }Constant folding for JavaScript inequality operators
This release introduces constant folding for the
< > <= >=operators. The minifier will now replace these operators withtrueorfalsewhen both sides are compile-time numeric or string constants:// Original code console.log(1 < 2, '🍕' > '🧀') // Old output (with --minify) console.log(1<2,"🍕">"🧀"); // New output (with --minify) console.log(!0,!1);
Better handling of
__proto__edge casesJavaScript object literal syntax contains a special case where a non-computed property with a key of
__proto__sets the prototype of the object. This does not apply to computed properties or to properties that use the shorthand property syntax introduced in ES6. Previously esbuild didn't correctly preserve the "sets the prototype" status of properties inside an object literal, meaning a property that sets the prototype could accidentally be transformed into one that doesn't and vice versa. This has now been fixed:// Original code function foo(__proto__) { return { __proto__: __proto__ } // Note: sets the prototype } function bar(__proto__, proto) { { let __proto__ = proto return { __proto__ } // Note: doesn't set the prototype } } // Old output function foo(__proto__) { return { __proto__ }; // Note: no longer sets the prototype (WRONG) } function bar(__proto__, proto) { { let __proto__2 = proto; return { __proto__: __proto__2 }; // Note: now sets the prototype (WRONG) } } // New output function foo(__proto__) { return { __proto__: __proto__ }; // Note: sets the prototype (correct) } function bar(__proto__, proto) { { let __proto__2 = proto; return { ["__proto__"]: __proto__2 }; // Note: doesn't set the prototype (correct) } }
Fix a bug with the CSS nesting transform
This release fixes a bug with the CSS nesting transform for older browsers where the generated CSS could be incorrect if a selector list contained a pseudo element followed by another selector. The bug was caused by incorrectly mutating the parent rule's selector list when filtering out pseudo elements for the child rules:
/* Original code */ .foo { &:after, & .bar { color: red; } } /* Old output (with --supported:nesting=false) */ .foo .bar, .foo .bar { color: red; } /* New output (with --supported:nesting=false) */ .foo:after, .foo .bar { color: red; }Constant folding for JavaScript inequality operators
This release introduces constant folding for the
< > <= >=operators. The minifier will now replace these operators withtrueorfalsewhen both sides are compile-time numeric or string constants:// Original code console.log(1 < 2, '🍕' > '🧀') // Old output (with --minify) console.log(1<2,"🍕">"🧀"); // New output (with --minify) console.log(!0,!1);
Better handling of
__proto__edge casesJavaScript object literal syntax contains a special case where a non-computed property with a key of
__proto__sets the prototype of the object. This does not apply to computed properties or to properties that use the shorthand property syntax introduced in ES6. Previously esbuild didn't correctly preserve the "sets the prototype" status of properties inside an object literal, meaning a property that sets the prototype could accidentally be transformed into one that doesn't and vice versa. This has now been fixed:// Original code function foo(__proto__) { return { __proto__: __proto__ } // Note: sets the prototype } function bar(__proto__, proto) { { let __proto__ = proto return { __proto__ } // Note: doesn't set the prototype } } // Old output function foo(__proto__) { return { __proto__ }; // Note: no longer sets the prototype (WRONG) } function bar(__proto__, proto) { { let __proto__2 = proto; return { __proto__: __proto__2 }; // Note: now sets the prototype (WRONG) } } // New output function foo(__proto__) { return { __proto__: __proto__ }; // Note: sets the prototype (correct) } function bar(__proto__, proto) { { let __proto__2 = proto; return { ["__proto__"]: __proto__2 }; // Note: doesn't set the prototype (correct) } }Fix cross-platform non-determinism with CSS color space transformations
The Go compiler takes advantage of "fused multiply and add" (FMA) instructions on certain processors which do the operation
x*y + zwithout intermediate rounding. This causes esbuild's CSS color space math to differ on different processors (currentlyppc64leands390x), which breaks esbuild's guarantee of deterministic output. To avoid this, esbuild's color space math now inserts afloat64()cast around every single math operation. This tells the Go compiler not to use the FMA optimization.Fix a crash when resolving a path from a directory that doesn't exist
This release fixes a regression where esbuild could crash when resolving an absolute path if the source directory for the path resolution operation doesn't exist. While this situation doesn't normally come up, it could come up when running esbuild concurrently with another operation that mutates the file system as esbuild is doing a build (such as using
gitto switch branches). The underlying problem was a regression that was introduced in version 0.18.0.
0.20.0
27 Jan 2024Work around API deprecations in Deno 1.40.x (#3609, #3611)
Deno 1.40.0 was just released and introduced run-time warnings about certain APIs that esbuild uses. With this release, esbuild will work around these run-time warnings by using newer APIs if they are present and falling back to the original APIs otherwise. This should avoid the warnings without breaking compatibility with older versions of Deno.
Unfortunately, doing this introduces a breaking change. The newer child process APIs lack a way to synchronously terminate esbuild's child process, so calling
esbuild.stop()from within a Deno test is no longer sufficient to prevent Deno from failing a test that uses esbuild's API (Deno fails tests that create a child process without killing it before the test ends). To work around this, esbuild'sstop()function has been changed to return a promise, and you now have to changeesbuild.stop()toawait esbuild.stop()in all of your Deno tests.Reorder implicit file extensions within
node_modules(#3341, #3608)In version 0.18.0, esbuild changed the behavior of implicit file extensions within
node_modulesdirectories (i.e. in published packages) to prefer.jsover.tseven when the--resolve-extensions=order prefers.tsover.js(which it does by default). However, doing that also accidentally made esbuild prefer.cssover.ts, which caused problems for people that published packages containing both TypeScript and CSS in files with the same name.With this release, esbuild will reorder TypeScript file extensions immediately after the last JavaScript file extensions in the implicit file extension order instead of putting them at the end of the order. Specifically the default implicit file extension order is
.tsx,.ts,.jsx,.js,.css,.jsonwhich used to become.jsx,.js,.css,.json,.tsx,.tsinnode_modulesdirectories. With this release it will now become.jsx,.js,.tsx,.ts,.css,.jsoninstead.Why even rewrite the implicit file extension order at all? One reason is because the
.jsfile is more likely to behave correctly than the.tsfile. The behavior of the.tsfile may depend ontsconfig.jsonand thetsconfig.jsonfile may not even be published, or may useextendsto refer to a basetsconfig.jsonfile that wasn't published. People can get into this situation when they forget to add all.tsfiles to their.npmignorefile before publishing to npm. Picking.jsover.tshelps make it more likely that resulting bundle will behave correctly.
This release deliberately contains backwards-incompatible changes. To avoid automatically picking up releases like this, you should either be pinning the exact version of
esbuildin yourpackage.jsonfile (recommended) or be using a version range syntax that only accepts patch upgrades such as^0.19.0or~0.19.0. See npm's documentation about semver for more information.This time there is only one breaking change, and it only matters for people using Deno. Deno tests that use esbuild will now fail unless you make the change described below.
Work around API deprecations in Deno 1.40.x (#3609, #3611)
Deno 1.40.0 was just released and introduced run-time warnings about certain APIs that esbuild uses. With this release, esbuild will work around these run-time warnings by using newer APIs if they are present and falling back to the original APIs otherwise. This should avoid the warnings without breaking compatibility with older versions of Deno.
Unfortunately, doing this introduces a breaking change. The newer child process APIs lack a way to synchronously terminate esbuild's child process, so calling
esbuild.stop()from within a Deno test is no longer sufficient to prevent Deno from failing a test that uses esbuild's API (Deno fails tests that create a child process without killing it before the test ends). To work around this, esbuild'sstop()function has been changed to return a promise, and you now have to changeesbuild.stop()toawait esbuild.stop()in all of your Deno tests.Reorder implicit file extensions within
node_modules(#3341, #3608)In version 0.18.0, esbuild changed the behavior of implicit file extensions within
node_modulesdirectories (i.e. in published packages) to prefer.jsover.tseven when the--resolve-extensions=order prefers.tsover.js(which it does by default). However, doing that also accidentally made esbuild prefer.cssover.ts, which caused problems for people that published packages containing both TypeScript and CSS in files with the same name.With this release, esbuild will reorder TypeScript file extensions immediately after the last JavaScript file extensions in the implicit file extension order instead of putting them at the end of the order. Specifically the default implicit file extension order is
.tsx,.ts,.jsx,.js,.css,.jsonwhich used to become.jsx,.js,.css,.json,.tsx,.tsinnode_modulesdirectories. With this release it will now become.jsx,.js,.tsx,.ts,.css,.jsoninstead.Why even rewrite the implicit file extension order at all? One reason is because the
.jsfile is more likely to behave correctly than the.tsfile. The behavior of the.tsfile may depend ontsconfig.jsonand thetsconfig.jsonfile may not even be published, or may useextendsto refer to a basetsconfig.jsonfile that wasn't published. People can get into this situation when they forget to add all.tsfiles to their.npmignorefile before publishing to npm. Picking.jsover.tshelps make it more likely that resulting bundle will behave correctly.
- 0.19.x
0.19.12
23 Jan 2024The "preserve" JSX mode now preserves JSX text verbatim
The JSX specification deliberately doesn't specify how JSX text is supposed to be interpreted and there is no canonical way to interpret JSX text. Two most popular interpretations are Babel and TypeScript. Yes they are different (esbuild deliberately follows TypeScript by the way).
Previously esbuild normalized text to the TypeScript interpretation when the "preserve" JSX mode is active. However, "preserve" should arguably reproduce the original JSX text verbatim so that whatever JSX transform runs after esbuild is free to interpret it however it wants. So with this release, esbuild will now pass JSX text through unmodified:
// Original code let el = <a href={'/'} title=''"'> some text {foo} more text </a> // Old output (with --loader=jsx --jsx=preserve) let el = <a href="/" title={`'"`}> {" some text"} {foo} {"more text "} </a>; // New output (with --loader=jsx --jsx=preserve) let el = <a href={"/"} title=''"'> some text {foo} more text </a>;Allow JSX elements as JSX attribute values
JSX has an obscure feature where you can use JSX elements in attribute position without surrounding them with
{...}. It looks like this:let el = <div data-ab=<><a/><b/></>/>;
I think I originally didn't implement it even though it's part of the JSX specification because it previously didn't work in TypeScript (and potentially also in Babel?). However, support for it was silently added in TypeScript 4.8 without me noticing and Babel has also since fixed their bugs regarding this feature. So I'm adding it to esbuild too now that I know it's widely supported.
Keep in mind that there is some ongoing discussion about removing this feature from JSX. I agree that the syntax seems out of place (it does away with the elegance of "JSX is basically just XML with
{...}escapes" for something arguably harder to read, which doesn't seem like a good trade-off), but it's in the specification and TypeScript and Babel both implement it so I'm going to have esbuild implement it too. However, I reserve the right to remove it from esbuild if it's ever removed from the specification in the future. So use it with caution.Fix a bug with TypeScript type parsing
This release fixes a bug with esbuild's TypeScript parser where a conditional type containing a union type that ends with an infer type that ends with a constraint could fail to parse. This was caused by the "don't parse a conditional type" flag not getting passed through the union type parser. Here's an example of valid TypeScript code that previously failed to parse correctly:
type InferUnion<T> = T extends { a: infer U extends number } | infer U extends number ? U : never
0.19.11
29 Dec 2023Fix TypeScript-specific class transform edge case
The previous release introduced an optimization that avoided transforming
super()in the class constructor for TypeScript code compiled withuseDefineForClassFieldsset tofalseif all class instance fields have no initializers. The rationale was that in this case, all class instance fields are omitted in the output so no changes to the constructor are needed. However, if all of this is the case and there are#privateinstance fields with initializers, those private instance field initializers were still being moved into the constructor. This was problematic because they were being inserted before the call tosuper()(sincesuper()is now no longer transformed in that case). This release introduces an additional optimization that avoids moving the private instance field initializers into the constructor in this edge case, which generates smaller code, matches the TypeScript compiler's output more closely, and avoids this bug:// Original code class Foo extends Bar { #private = 1; public: any; constructor() { super(); } } // Old output (with esbuild v0.19.9) class Foo extends Bar { constructor() { super(); this.#private = 1; } #private; } // Old output (with esbuild v0.19.10) class Foo extends Bar { constructor() { this.#private = 1; super(); } #private; } // New output class Foo extends Bar { #private = 1; constructor() { super(); } }Minifier: Allow reording a primitive past a side-effect
The minifier previously allowed reordering a side-effect past a primitive, but didn't handle the case of reordering a primitive past a side-effect. This additional case is now handled:
// Original code function f() { let x = false; let y = x; const boolean = y; let frag = $.template(`<p contenteditable="${boolean}">hello world</p>`); return frag; } // Old output (with --minify) function f(){const e=!1;return $.template(`<p contenteditable="${e}">hello world</p>`)} // New output (with --minify) function f(){return $.template('<p contenteditable="false">hello world</p>')}Minifier: Consider properties named using known
Symbolinstances to be side-effect freeMany things in JavaScript can have side effects including property accesses and ToString operations, so using a symbol such as
Symbol.iteratoras a computed property name is not obviously side-effect free. This release adds a special case for knownSymbolinstances so that they are considered side-effect free when used as property names. For example, this class declaration will now be considered side-effect free:class Foo { *[Symbol.iterator]() { } }
Fix TypeScript-specific class transform edge case
The previous release introduced an optimization that avoided transforming
super()in the class constructor for TypeScript code compiled withuseDefineForClassFieldsset tofalseif all class instance fields have no initializers. The rationale was that in this case, all class instance fields are omitted in the output so no changes to the constructor are needed. However, if all of this is the case and there are#privateinstance fields with initializers, those private instance field initializers were still being moved into the constructor. This was problematic because they were being inserted before the call tosuper()(sincesuper()is now no longer transformed in that case). This release introduces an additional optimization that avoids moving the private instance field initializers into the constructor in this edge case, which generates smaller code, matches the TypeScript compiler's output more closely, and avoids this bug:// Original code class Foo extends Bar { #private = 1; public: any; constructor() { super(); } } // Old output (with esbuild v0.19.9) class Foo extends Bar { constructor() { super(); this.#private = 1; } #private; } // Old output (with esbuild v0.19.10) class Foo extends Bar { constructor() { this.#private = 1; super(); } #private; } // New output class Foo extends Bar { #private = 1; constructor() { super(); } }Minifier: Allow reording a primitive past a side-effect
The minifier previously allowed reordering a side-effect past a primitive, but didn't handle the case of reordering a primitive past a side-effect. This additional case is now handled:
// Original code function f() { let x = false; let y = x; const boolean = y; let frag = $.template(`<p contenteditable="${boolean}">hello world</p>`); return frag; } // Old output (with --minify) function f(){const e=!1;return $.template(`<p contenteditable="${e}">hello world</p>`)} // New output (with --minify) function f(){return $.template('<p contenteditable="false">hello world</p>')}Minifier: Consider properties named using known
Symbolinstances to be side-effect freeMany things in JavaScript can have side effects including property accesses and ToString operations, so using a symbol such as
Symbol.iteratoras a computed property name is not obviously side-effect free. This release adds a special case for knownSymbolinstances so that they are considered side-effect free when used as property names. For example, this class declaration will now be considered side-effect free:class Foo { *[Symbol.iterator]() { } }Provide the
stop()API in node to exit esbuild's child processYou can now call
stop()in esbuild's node API to exit esbuild's child process to reclaim the resources used. It only makes sense to do this for a long-lived node process when you know you will no longer be making any more esbuild API calls. It is not necessary to call this to allow node to exit, and it's advantageous to not call this in between calls to esbuild's API as sharing a single long-lived esbuild child process is more efficient than re-creating a new esbuild child process for every API call. This API call used to exist but was removed in version 0.9.0. This release adds it back due to a user request.
0.19.10
19 Dec 2023Fix glob imports in TypeScript files
This release fixes a problem where bundling a TypeScript file containing a glob import could emit a call to a helper function that doesn't exist. The problem happened because esbuild's TypeScript transformation removes unused imports (which is required for correctness, as they may be type-only imports) and esbuild's glob import transformation wasn't correctly marking the imported helper function as used. This wasn't caught earlier because most of esbuild's glob import tests were written in JavaScript, not in TypeScript.
Fix
require()glob imports with bundling disabledPreviously
require()calls containing glob imports were incorrectly transformed when bundling was disabled. All glob imports should only be transformed when bundling is enabled. This bug has been fixed.Fix a panic when transforming optional chaining with
define(#3551, #3554)This release fixes a case where esbuild could crash with a panic, which was triggered by using
defineto replace an expression containing an optional chain. Here is an example:// Original code console.log(process?.env.SHELL) // Old output (with --define:process.env={}) /* panic: Internal error (while parsing "<stdin>") */ // New output (with --define:process.env={}) var define_process_env_default = {}; console.log(define_process_env_default.SHELL);This fix was contributed
Fix glob imports in TypeScript files
This release fixes a problem where bundling a TypeScript file containing a glob import could emit a call to a helper function that doesn't exist. The problem happened because esbuild's TypeScript transformation removes unused imports (which is required for correctness, as they may be type-only imports) and esbuild's glob import transformation wasn't correctly marking the imported helper function as used. This wasn't caught earlier because most of esbuild's glob import tests were written in JavaScript, not in TypeScript.
Fix
require()glob imports with bundling disabledPreviously
require()calls containing glob imports were incorrectly transformed when bundling was disabled. All glob imports should only be transformed when bundling is enabled. This bug has been fixed.Fix a panic when transforming optional chaining with
define(#3551, #3554)This release fixes a case where esbuild could crash with a panic, which was triggered by using
defineto replace an expression containing an optional chain. Here is an example:// Original code console.log(process?.env.SHELL) // Old output (with --define:process.env={}) /* panic: Internal error (while parsing "<stdin>") */ // New output (with --define:process.env={}) var define_process_env_default = {}; console.log(define_process_env_default.SHELL);This fix was contributed
Work around a bug in node's CommonJS export name detector
The export names of a CommonJS module are dynamically-determined at run time because CommonJS exports are properties on a mutable object. But the export names of an ES module are statically-determined at module instantiation time by using
importandexportsyntax and cannot be changed at run time.When you import a CommonJS module into an ES module in node, node scans over the source code to attempt to detect the set of export names that the CommonJS module will end up using. That statically-determined set of names is used as the set of names that the ES module is allowed to import at module instantiation time. However, this scan appears to have bugs (or at least, can cause false positives) because it doesn't appear to do any scope analysis. Node will incorrectly consider the module to export something even if the assignment is done to a local variable instead of to the module-level
exportsobject. For example:// confuseNode.js exports.confuseNode = function(exports) { // If this local is called "exports", node incorrectly // thinks this file has an export called "notAnExport". exports.notAnExport = function() { }; };You can see that node incorrectly thinks the file
confuseNode.jshas an export callednotAnExportwhen that file is loaded in an ES module context:$ node -e 'import("./confuseNode.js").then(console.log)' [Module: null prototype] { confuseNode: [Function (anonymous)], default: { confuseNode: [Function (anonymous)] }, notAnExport: undefined }To avoid this, esbuild will now rename local variables that use the names
exportsandmodulewhen generating CommonJS output for thenodeplatform.Fix the return value of esbuild's
super()shimSome people write
constructormethods that use the return value ofsuper()instead of usingthis. This isn't too common because TypeScript doesn't let you do that but it can come up when writing JavaScript. Previously esbuild's class lowering transform incorrectly transformed the return value ofsuper()intoundefined. With this release, the return value ofsuper()will now bethisinstead:// Original code class Foo extends Object { field constructor() { console.log(typeof super()) } } new Foo // Old output (with --target=es6) class Foo extends Object { constructor() { var __super = (...args) => { super(...args); __publicField(this, "field"); }; console.log(typeof __super()); } } new Foo(); // New output (with --target=es6) class Foo extends Object { constructor() { var __super = (...args) => { super(...args); __publicField(this, "field"); return this; }; console.log(typeof __super()); } } new Foo();Terminate the Go GC when esbuild's
stop()API is calledIf you use esbuild with WebAssembly and pass the
worker: falseflag toesbuild.initialize(), then esbuild will run the WebAssembly module on the main thread. If you do this within a Deno test and that test callsesbuild.stop()to clean up esbuild's resources, Deno may complain that asetTimeout()call lasted past the end of the test. This happens when the Go is in the middle of a garbage collection pass and has scheduled additional ongoing garbage collection work. Normally callingesbuild.stop()will terminate the web worker that the WebAssembly module runs in, which will terminate the Go GC, but that doesn't happen if you disable the web worker withworker: false.With this release, esbuild will now attempt to terminate the Go GC in this edge case by calling
clearTimeout()on these pending timeouts.Apply
/* @__NO_SIDE_EFFECTS__ */on tagged template literalsTagged template literals that reference functions annotated with a
@__NO_SIDE_EFFECTS__comment are now able to be removed via tree-shaking if the result is unused. This is a convention from Rollup. Here is an example:// Original code const html = /* @__NO_SIDE_EFFECTS__ */ (a, ...b) => ({ a, b }) html`<a>remove</a>` x = html`<b>keep</b>` // Old output (with --tree-shaking=true) const html = /* @__NO_SIDE_EFFECTS__ */ (a, ...b) => ({ a, b }); html`<a>remove</a>`; x = html`<b>keep</b>`; // New output (with --tree-shaking=true) const html = /* @__NO_SIDE_EFFECTS__ */ (a, ...b) => ({ a, b }); x = html`<b>keep</b>`;Note that this feature currently only works within a single file, so it's not especially useful. This feature does not yet work across separate files. I still recommend using
@__PURE__annotations instead of this feature, as they have wider tooling support. The drawback of course is that@__PURE__annotations need to be added at each call site, not at the declaration, and for non-call expressions such as template literals you need to wrap the expression in an IIFE (immediately-invoked function expression) to create a call expression to apply the@__PURE__annotation to.Publish builds for IBM AIX PowerPC 64-bit
This release publishes a binary executable to npm for IBM AIX PowerPC 64-bit, which means that in theory esbuild can now be installed in that environment with
npm install esbuild. This hasn't actually been tested yet. If you have access to such a system, it would be helpful to confirm whether or not doing this actually works.
0.19.9
10 Dec 2023Add support for transforming new CSS gradient syntax for older browsers
The specification called CSS Images Module Level 4 introduces new CSS gradient syntax for customizing how the browser interpolates colors in between color stops. You can now control the color space that the interpolation happens in as well as (for "polar" color spaces) control whether hue angle interpolation happens clockwise or counterclockwise. You can read more about this in Mozilla's blog post about new CSS gradient features.
With this release, esbuild will now automatically transform this syntax for older browsers in the
targetlist. For example, here's a gradient that should appear as a rainbow in a browser that supports this new syntax:/* Original code */ .rainbow-gradient { width: 100px; height: 100px; background: linear-gradient(in hsl longer hue, #7ff, #77f); } /* New output (with --target=chrome99) */ .rainbow-gradient { width: 100px; height: 100px; background: linear-gradient( #77ffff, #77ffaa 12.5%, #77ff80 18.75%, #84ff77 21.88%, #99ff77 25%, #eeff77 37.5%, #fffb77 40.62%, #ffe577 43.75%, #ffbb77 50%, #ff9077 56.25%, #ff7b77 59.38%, #ff7788 62.5%, #ff77dd 75%, #ff77f2 78.12%, #f777ff 81.25%, #cc77ff 87.5%, #7777ff); }You can now use this syntax in your CSS source code and esbuild will automatically convert it to an equivalent gradient for older browsers. In addition, esbuild will now also transform "double position" and "transition hint" syntax for older browsers as appropriate:
/* Original code */ .stripes { width: 100px; height: 100px; background: linear-gradient(#e65 33%, #ff2 33% 67%, #99e 67%); } .glow { width: 100px; height: 100px; background: radial-gradient(white 10%, 20%, black); } /* New output (with --target=chrome33) */ .stripes { width: 100px; height: 100px; background: linear-gradient( #e65 33%, #ff2 33%, #ff2 67%, #99e 67%); } .glow { width: 100px; height: 100px; background: radial-gradient( #ffffff 10%, #aaaaaa 12.81%, #959595 15.62%, #7b7b7b 21.25%, #5a5a5a 32.5%, #444444 43.75%, #323232 55%, #161616 77.5%, #000000); }You can see visual examples of these new syntax features by looking at esbuild's gradient transformation tests.
If necessary, esbuild will construct a new gradient that approximates the original gradient by recursively splitting the interval in between color stops until the approximation error is within a small threshold. That is why the above output CSS contains many more color stops than the input CSS.
Note that esbuild deliberately replaces the original gradient with the approximation instead of inserting the approximation before the original gradient as a fallback. The latest version of Firefox has multiple gradient rendering bugs (including incorrect interpolation of partially-transparent colors and interpolating non-sRGB colors using the incorrect color space). If esbuild didn't replace the original gradient, then Firefox would use the original gradient instead of the fallback the appearance would be incorrect in Firefox. In other words, the latest version of Firefox supports modern gradient syntax but interprets it incorrectly.
Add support for
color(),lab(),lch(),oklab(),oklch(), andhwb()in CSSCSS has recently added lots of new ways of specifying colors. You can read more about this in Chrome's blog post about CSS color spaces.
This release adds support for minifying colors that use the
color(),lab(),lch(),oklab(),oklch(), orhwb()syntax and/or transforming these colors for browsers that don't support it yet:/* Original code */ div { color: hwb(90deg 20% 40%); background: color(display-p3 1 0 0); } /* New output (with --target=chrome99) */ div { color: #669933; background: #ff0f0e; background: color(display-p3 1 0 0); }As you can see, colors outside of the sRGB color space such as
color(display-p3 1 0 0)are mapped back into the sRGB gamut and inserted as a fallback for browsers that don't support the new color syntax.Allow empty type parameter lists in certain cases
TypeScript allows interface declarations and type aliases to have empty type parameter lists. Previously esbuild didn't handle this edge case but with this release, esbuild will now parse this syntax:
interface Foo<> {} type Bar<> = {}This fix was contributed
0.19.8
26 Nov 2023Add a treemap chart to esbuild's bundle analyzer
The bundler analyzer on esbuild's website (esbuild.github.io/analyze/) now has a treemap chart type in addition to the two existing chart types (sunburst and flame). This should be more familiar for people coming from other similar tools, as well as make better use of large screens.
Allow decorators after the
exportkeywordPreviously esbuild's decorator parser followed the original behavior of TypeScript's experimental decorators feature, which only allowed decorators to come before the
exportkeyword. However, the upcoming JavaScript decorators feature also allows decorators to come after theexportkeyword. And with TypeScript 5.0, TypeScript now also allows experimental decorators to come after theexportkeyword too. So esbuild now allows this as well:// This old syntax has always been permitted: @decorator export class Foo {} @decorator export default class Foo {} // This new syntax is now permitted too: export @decorator class Foo {} export default @decorator class Foo {}In addition, esbuild's decorator parser has been rewritten to fix several subtle and likely unimportant edge cases with esbuild's parsing of exports and decorators in TypeScript (e.g. TypeScript apparently does automatic semicolon insertion after
interfaceandexport interfacebut not afterexport default interface).Pretty-print decorators using the same whitespace as the original
When printing code containing decorators, esbuild will now try to respect whether the original code contained newlines after the decorator or not. This can make generated code containing many decorators much more compact to read:
// Original code class Foo { @a @b @c abc @x @y @z xyz } // Old output class Foo { @a @b @c abc; @x @y @z xyz; } // New output class Foo { @a @b @c abc; @x @y @z xyz; }
0.19.7
21 Nov 2023Add support for bundling code that uses import attributes
JavaScript is gaining new syntax for associating a map of string key-value pairs with individual ESM imports. The proposal is still a work in progress and is still undergoing significant changes before being finalized. However, the first iteration has already been shipping in Chromium-based browsers for a while, and the second iteration has landed in V8 and is now shipping in node, so it makes sense for esbuild to support it. Here are the two major iterations of this proposal (so far):
You can already use esbuild to bundle code that uses import assertions (the first iteration). However, this feature is mostly useless for bundlers because import assertions are not allowed to affect module resolution. It's basically only useful as an annotation on external imports, which esbuild will then preserve in the output for use in a browser (which would otherwise refuse to load certain imports).
With this release, esbuild now supports bundling code that uses import attributes (the second iteration). This is much more useful for bundlers because they are allowed to affect module resolution, which means the key-value pairs can be provided to plugins. Here's an example, which uses esbuild's built-in support for the upcoming JSON module standard:
// On static imports import foo from './package.json' with { type: 'json' } console.log(foo) // On dynamic imports const bar = await import('./package.json', { with: { type: 'json' } }) console.log(bar)One important consequence of the change in semantics between import assertions and import attributes is that two imports with identical paths but different import attributes are now considered to be different modules. This is because the import attributes are provided to the loader, which might then use those attributes during loading. For example, you could imagine an image loader that produces an image of a different size depending on the import attributes.
Import attributes are now reported in the metafile and are now provided to on-load plugins as a map in the
withproperty. For example, here's an esbuild plugin that turns all imports with atypeimport attribute equal to'cheese'into a module that exports the cheese emoji:const cheesePlugin = { name: 'cheese', setup(build) { build.onLoad({ filter: /.*/ }, args => { if (args.with.type === 'cheese') return { contents: `export default "🧀"`, } }) } } require('esbuild').build({ bundle: true, write: false, stdin: { contents: ` import foo from 'data:text/javascript,' with { type: 'cheese' } console.log(foo) `, }, plugins: [cheesePlugin], }).then(result => { const code = new Function(result.outputFiles[0].text) code() })Warning: It's possible that the second iteration of this feature may change significantly again even though it's already shipping in real JavaScript VMs (since it has already happened once before). In that case, esbuild may end up adjusting its implementation to match the eventual standard behavior. So keep in mind that by using this, you are using an unstable upcoming JavaScript feature that may undergo breaking changes in the future.
Adjust TypeScript experimental decorator behavior (#3230, #3326, #3394)
With this release, esbuild will now allow TypeScript experimental decorators to access both static class properties and
#privateclass names. For example:const check = <T,>(a: T, b: T): PropertyDecorator => () => console.log(a === b) async function test() { class Foo { static #foo = 1 static bar = 1 + Foo.#foo @check(Foo.#foo, 1) a: any @check(Foo.bar, await Promise.resolve(2)) b: any } } test().then(() => console.log('pass'))This will now print
true true passwhen compiled by esbuild. Previously esbuild evaluated TypeScript decorators outside of the class body, so it didn't allow decorators to accessFooor#foo. Now esbuild does something different, although it's hard to concisely explain exactly what esbuild is doing now (see the background section below for more information).Note that TypeScript's experimental decorator support is currently buggy: TypeScript's compiler passes this test if only the first
@checkis present or if only the second@checkis present, but TypeScript's compiler fails this test if both checks are present together. I haven't changed esbuild to match TypeScript's behavior exactly here because I'm waiting for TypeScript to fix these bugs instead.Some background: TypeScript experimental decorators don't have consistent semantics regarding the context that the decorators are evaluated in. For example, TypeScript will let you use
awaitwithin a decorator, which implies that the decorator runs outside the class body (sinceawaitisn't supported inside a class body), but TypeScript will also let you use#privatenames, which implies that the decorator runs inside the class body (since#privatenames are only supported inside a class body). The value ofthisin a decorator is also buggy (the run-time value ofthischanges if any decorator in the class uses a#privatename but the type ofthisdoesn't change, leading to the type checker no longer matching reality). These inconsistent semantics make it hard for esbuild to implement this feature as decorator evaluation happens in some superposition of both inside and outside the class body that is particular to the internal implementation details of the TypeScript compiler.Forbid
--keep-nameswhen targeting old browsersThe
--keep-namessetting needs to be able to assign to thenameproperty on functions and classes. However, before ES6 this property was non-configurable, and attempting to assign to it would throw an error. So with this release, esbuild will no longer allow you to enable this setting while also targeting a really old browser.
0.19.6
19 Nov 2023Fix a constant folding bug with bigint equality
This release fixes a bug where esbuild incorrectly checked for bigint equality by checking the equality of the bigint literal text. This is correct if the bigint doesn't have a radix because bigint literals without a radix are always in canonical form (since leading zeros are not allowed). However, this is incorrect if the bigint has a radix (e.g.
0x123n) because the canonical form is not enforced when a radix is present.// Original code console.log(!!0n, !!1n, 123n === 123n) console.log(!!0x0n, !!0x1n, 123n === 0x7Bn) // Old output console.log(false, true, true); console.log(true, true, false); // New output console.log(false, true, true); console.log(!!0x0n, !!0x1n, 123n === 0x7Bn);
Add some improvements to the JavaScript minifier
This release adds more cases to the JavaScript minifier, including support for inlining
String.fromCharCodeandString.prototype.charCodeAtwhen possible:// Original code document.onkeydown = e => e.keyCode === 'A'.charCodeAt(0) && console.log(String.fromCharCode(55358, 56768)) // Old output (with --minify) document.onkeydown=o=>o.keyCode==="A".charCodeAt(0)&&console.log(String.fromCharCode(55358,56768)); // New output (with --minify) document.onkeydown=o=>o.keyCode===65&&console.log("🧀");In addition, immediately-invoked function expressions (IIFEs) that return a single expression are now inlined when minifying. This makes it possible to use IIFEs in combination with
@__PURE__annotations to annotate arbitrary expressions as side-effect free without the IIFE wrapper impacting code size. For example:// Original code const sideEffectFreeOffset = /* @__PURE__ */ (() => computeSomething())() use(sideEffectFreeOffset) // Old output (with --minify) const e=(()=>computeSomething())();use(e); // New output (with --minify) const e=computeSomething();use(e);
Automatically prefix the
mask-compositeCSS property for WebKitThe
mask-compositeproperty will now be prefixed as-webkit-mask-compositefor older WebKit-based browsers. In addition to prefixing the property name, handling older browsers also requires rewriting the values since WebKit uses non-standard names for the mask composite modes:/* Original code */ div { mask-composite: add, subtract, intersect, exclude; } /* New output (with --target=chrome100) */ div { -webkit-mask-composite: source-over, source-out, source-in, xor; mask-composite: add, subtract, intersect, exclude; }
Fix a constant folding bug with bigint equality
This release fixes a bug where esbuild incorrectly checked for bigint equality by checking the equality of the bigint literal text. This is correct if the bigint doesn't have a radix because bigint literals without a radix are always in canonical form (since leading zeros are not allowed). However, this is incorrect if the bigint has a radix (e.g.
0x123n) because the canonical form is not enforced when a radix is present.// Original code console.log(!!0n, !!1n, 123n === 123n) console.log(!!0x0n, !!0x1n, 123n === 0x7Bn) // Old output console.log(false, true, true); console.log(true, true, false); // New output console.log(false, true, true); console.log(!!0x0n, !!0x1n, 123n === 0x7Bn);
Add some improvements to the JavaScript minifier
This release adds more cases to the JavaScript minifier, including support for inlining
String.fromCharCodeandString.prototype.charCodeAtwhen possible:// Original code document.onkeydown = e => e.keyCode === 'A'.charCodeAt(0) && console.log(String.fromCharCode(55358, 56768)) // Old output (with --minify) document.onkeydown=o=>o.keyCode==="A".charCodeAt(0)&&console.log(String.fromCharCode(55358,56768)); // New output (with --minify) document.onkeydown=o=>o.keyCode===65&&console.log("🧀");In addition, immediately-invoked function expressions (IIFEs) that return a single expression are now inlined when minifying. This makes it possible to use IIFEs in combination with
@__PURE__annotations to annotate arbitrary expressions as side-effect free without the IIFE wrapper impacting code size. For example:// Original code const sideEffectFreeOffset = /* @__PURE__ */ (() => computeSomething())() use(sideEffectFreeOffset) // Old output (with --minify) const e=(()=>computeSomething())();use(e); // New output (with --minify) const e=computeSomething();use(e);
Automatically prefix the
mask-compositeCSS property for WebKitThe
mask-compositeproperty will now be prefixed as-webkit-mask-compositefor older WebKit-based browsers. In addition to prefixing the property name, handling older browsers also requires rewriting the values since WebKit uses non-standard names for the mask composite modes:/* Original code */ div { mask-composite: add, subtract, intersect, exclude; } /* New output (with --target=chrome100) */ div { -webkit-mask-composite: source-over, source-out, source-in, xor; mask-composite: add, subtract, intersect, exclude; }Avoid referencing
thisfrom JSX elements in derived class constructorsWhen you enable
--jsx=automaticand--jsx-dev, the JSX transform is supposed to insertthisas the last argument to thejsxDEVfunction. I'm not sure exactly why this is and I can't find any specification for it, but in any case this causes the generated code to crash when you use a JSX element in a derived class constructor before the call tosuper()asthisis not allowed to be accessed at that point. For example// Original code class ChildComponent extends ParentComponent { constructor() { super(<div />) } } // Problematic output (with --loader=jsx --jsx=automatic --jsx-dev) import { jsxDEV } from "react/jsx-dev-runtime"; class ChildComponent extends ParentComponent { constructor() { super(/* @__PURE__ */ jsxDEV("div", {}, void 0, false, { fileName: "<stdin>", lineNumber: 3, columnNumber: 15 }, this)); // The reference to "this" crashes here } }The TypeScript compiler doesn't handle this at all while the Babel compiler just omits
thisfor the entire constructor (even after the call tosuper()). There seems to be no specification so I can't be sure that this change doesn't break anything important. But given that Babel is pretty loose with this and TypeScript doesn't handle this at all, I'm guessing this value isn't too important. React's blog post seems to indicate that this value was intended to be used for a React-specific migration warning at some point, so it could even be that this value is irrelevant now. Anyway the crash in this case should now be fixed.Allow package subpath imports to map to node built-ins
You are now able to use a subpath import in your package to resolve to a node built-in module. For example, with a
package.jsonfile like this:{ "type": "module", "imports": { "#stream": { "node": "stream", "default": "./stub.js" } } }You can now import from node's
streammodule like this:import * as stream from '#stream'; console.log(Object.keys(stream));
This will import from node's
streammodule when the platform isnodeand from./stub.jsotherwise.No longer throw an error when a
Symbolis missingCertain JavaScript syntax features use special properties on the global
Symbolobject. For example, the asynchronous iteration syntax usesSymbol.asyncIterator. Previously esbuild's generated code for older browsers required this symbol to be polyfilled. However, starting with this release esbuild will useSymbol.for()to construct these symbols if they are missing instead of throwing an error about a missing polyfill. This means your code no longer needs to include a polyfill for missing symbols as long as your code also usesSymbol.for()for missing symbols.Parse upcoming changes to TypeScript syntax (#3490, #3491)
With this release, you can now use
fromas the name of a default type-only import in TypeScript code, as well asofas the name of anawait usingloop iteration variable:import type from from 'from' for (await using of of of) ;
This matches similar changes in the TypeScript compiler (#56376 and #55555) which will start allowing this syntax in an upcoming version of TypeScript. Please never actually write code like this.
The type-only import syntax change was contributed
0.19.5
17 Oct 2023Fix a regression in 0.19.0 regarding
pathsintsconfig.jsonThe fix in esbuild version 0.19.0 to process
tsconfig.jsonaliases before the--packages=externalsetting unintentionally broke an edge case in esbuild's handling of certaintsconfig.jsonaliases where there are multiple files with the same name in different directories. This release adjusts esbuild's behavior for this edge case so that it passes while still processing aliases before--packages=external. Please read the linked issue for more details.Fix a CSS
fontproperty minification bugThis release fixes a bug where esbuild's CSS minifier didn't insert a space between the font size and the font family in the
fontCSS shorthand property in the edge case where the original source code didn't already have a space and the leading string token was shortened to an identifier:/* Original code */ .foo { font: 16px"Menlo"; } /* Old output (with --minify) */ .foo{font:16pxMenlo} /* New output (with --minify) */ .foo{font:16px Menlo}Fix bundling CSS with asset names containing spaces
Assets referenced via CSS
url()tokens may cause esbuild to generate invalid output when bundling if the file name contains spaces (e.g.url(image 2.png)). With this release, esbuild will now quote all bundled asset references inurl()tokens to avoid this problem. This only affects assets loaded using thefileandcopyloaders.
Fix a regression in 0.19.0 regarding
pathsintsconfig.jsonThe fix in esbuild version 0.19.0 to process
tsconfig.jsonaliases before the--packages=externalsetting unintentionally broke an edge case in esbuild's handling of certaintsconfig.jsonaliases where there are multiple files with the same name in different directories. This release adjusts esbuild's behavior for this edge case so that it passes while still processing aliases before--packages=external. Please read the linked issue for more details.Fix a CSS
fontproperty minification bugThis release fixes a bug where esbuild's CSS minifier didn't insert a space between the font size and the font family in the
fontCSS shorthand property in the edge case where the original source code didn't already have a space and the leading string token was shortened to an identifier:/* Original code */ .foo { font: 16px"Menlo"; } /* Old output (with --minify) */ .foo{font:16pxMenlo} /* New output (with --minify) */ .foo{font:16px Menlo}Fix bundling CSS with asset names containing spaces
Assets referenced via CSS
url()tokens may cause esbuild to generate invalid output when bundling if the file name contains spaces (e.g.url(image 2.png)). With this release, esbuild will now quote all bundled asset references inurl()tokens to avoid this problem. This only affects assets loaded using thefileandcopyloaders.Fix invalid CSS
url()tokens in@importrulesIn the future, CSS
url()tokens may contain additional stuff after the URL. This is irrelevant today as no CSS specification does this. But esbuild previously had a bug where using these tokens in an@importrule resulted in malformed output. This bug has been fixed.Fix
browser+false+type: moduleinpackage.jsonThe
browserfield inpackage.jsonallows you to map a file tofalseto have it be treated as an empty file when bundling for the browser. However, ifpackage.jsoncontains"type": "module"then all.jsfiles will be considered ESM, not CommonJS. Importing a named import from an empty CommonJS file gives you undefined, but importing a named export from an empty ESM file is a build error. This release changes esbuild's interpretation of these files mapped tofalsein this situation from ESM to CommonJS to avoid generating build errors for named imports.Fix a bug in top-level await error reporting
Using
require()on a file that contains top-level await is not allowed becauserequire()must return synchronously and top-level await makes that impossible. You will get a build error if you try to bundle code that does this with esbuild. This release fixes a bug in esbuild's error reporting code for complex cases of this situation involving multiple levels of imports to get to the module containing the top-level await.Update to Unicode 15.1.0
The character tables that determine which characters form valid JavaScript identifiers have been updated from Unicode version 15.0.0 to the newly-released Unicode version 15.1.0. I'm not putting an example in the release notes because all of the new characters will likely just show up as little squares since fonts haven't been updated yet. But you can read unicode.org/versions/Unicode15.1.0/ for more information about the changes.
This upgrade was contributed
0.19.4
28 Sep 2023Fix printing of JavaScript decorators in tricky cases
This release fixes some bugs where esbuild's pretty-printing of JavaScript decorators could incorrectly produced code with a syntax error. The problem happened because esbuild sometimes substitutes identifiers for other expressions in the pretty-printer itself, but the decision about whether to wrap the expression or not didn't account for this. Here are some examples:
// Original code import { constant } from './constants.js' import { imported } from 'external' import { undef } from './empty.js' class Foo { @constant() @imported() @undef() foo } // Old output (with --bundle --format=cjs --packages=external --minify-syntax) var import_external = require("external"); var Foo = class { @123() @(0, import_external.imported)() @(void 0)() foo; }; // New output (with --bundle --format=cjs --packages=external --minify-syntax) var import_external = require("external"); var Foo = class { @(123()) @((0, import_external.imported)()) @((void 0)()) foo; };Allow pre-release versions to be passed to
targetPeople want to be able to pass version numbers for unreleased versions of node (which have extra stuff after the version numbers) to esbuild's
targetsetting and have esbuild do something reasonable with them. These version strings are of course not present in esbuild's internal feature compatibility table because an unreleased version has not been released yet (by definition). With this release, esbuild will now attempt to accept these version strings passed totargetand do something reasonable with them.
0.19.3
14 Sep 2023Fix
list-style-typewith thelocal-cssloaderThe
local-cssloader incorrectly treated all identifiers provided tolist-style-typeas a custom local identifier. That included identifiers such asnonewhich have special meaning in CSS, and which should not be treated as custom local identifiers. This release fixes this bug:/* Original code */ ul { list-style-type: none } /* Old output (with --loader=local-css) */ ul { list-style-type: stdin_none; } /* New output (with --loader=local-css) */ ul { list-style-type: none; }Note that this bug only affected code using the
local-cssloader. It did not affect code using thecssloader.Avoid inserting temporary variables before
use strictThis release fixes a bug where esbuild could incorrectly insert automatically-generated temporary variables before
use strictdirectives:// Original code function foo() { 'use strict' a.b?.c() } // Old output (with --target=es6) function foo() { var _a; "use strict"; (_a = a.b) == null ? void 0 : _a.c(); } // New output (with --target=es6) function foo() { "use strict"; var _a; (_a = a.b) == null ? void 0 : _a.c(); }Adjust TypeScript
enumoutput to better approximatetscTypeScript enum values can be either number literals or string literals. Numbers create a bidirectional mapping between the name and the value but strings only create a unidirectional mapping from the name to the value. When the enum value is neither a number literal nor a string literal, TypeScript and esbuild both default to treating it as a number:
// Original TypeScript code declare const foo: any enum Foo { NUMBER = 1, STRING = 'a', OTHER = foo, } // Compiled JavaScript code (from "tsc") var Foo; (function (Foo) { Foo[Foo["NUMBER"] = 1] = "NUMBER"; Foo["STRING"] = "a"; Foo[Foo["OTHER"] = foo] = "OTHER"; })(Foo || (Foo = {}));However, TypeScript does constant folding slightly differently than esbuild. For example, it may consider template literals to be string literals in some cases:
// Original TypeScript code declare const foo = 'foo' enum Foo { PRESENT = `${foo}`, MISSING = `${bar}`, } // Compiled JavaScript code (from "tsc") var Foo; (function (Foo) { Foo["PRESENT"] = "foo"; Foo[Foo["MISSING"] = `${bar}`] = "MISSING"; })(Foo || (Foo = {}));The template literal initializer for
PRESENTis treated as a string while the template literal initializer forMISSINGis treated as a number. Previously esbuild treated both of these cases as a number but starting with this release, esbuild will now treat both of these cases as a string. This doesn't exactly match the behavior oftscbut in the case where the behavior divergestscreports a compile error, so this seems like acceptible behavior for esbuild. Note that handling these cases completely correctly would require esbuild to parse type declarations (see thedeclarekeyword), which esbuild deliberately doesn't do.
Fix
list-style-typewith thelocal-cssloaderThe
local-cssloader incorrectly treated all identifiers provided tolist-style-typeas a custom local identifier. That included identifiers such asnonewhich have special meaning in CSS, and which should not be treated as custom local identifiers. This release fixes this bug:/* Original code */ ul { list-style-type: none } /* Old output (with --loader=local-css) */ ul { list-style-type: stdin_none; } /* New output (with --loader=local-css) */ ul { list-style-type: none; }Note that this bug only affected code using the
local-cssloader. It did not affect code using thecssloader.Avoid inserting temporary variables before
use strictThis release fixes a bug where esbuild could incorrectly insert automatically-generated temporary variables before
use strictdirectives:// Original code function foo() { 'use strict' a.b?.c() } // Old output (with --target=es6) function foo() { var _a; "use strict"; (_a = a.b) == null ? void 0 : _a.c(); } // New output (with --target=es6) function foo() { "use strict"; var _a; (_a = a.b) == null ? void 0 : _a.c(); }Adjust TypeScript
enumoutput to better approximatetscTypeScript enum values can be either number literals or string literals. Numbers create a bidirectional mapping between the name and the value but strings only create a unidirectional mapping from the name to the value. When the enum value is neither a number literal nor a string literal, TypeScript and esbuild both default to treating it as a number:
// Original TypeScript code declare const foo: any enum Foo { NUMBER = 1, STRING = 'a', OTHER = foo, } // Compiled JavaScript code (from "tsc") var Foo; (function (Foo) { Foo[Foo["NUMBER"] = 1] = "NUMBER"; Foo["STRING"] = "a"; Foo[Foo["OTHER"] = foo] = "OTHER"; })(Foo || (Foo = {}));However, TypeScript does constant folding slightly differently than esbuild. For example, it may consider template literals to be string literals in some cases:
// Original TypeScript code declare const foo = 'foo' enum Foo { PRESENT = `${foo}`, MISSING = `${bar}`, } // Compiled JavaScript code (from "tsc") var Foo; (function (Foo) { Foo["PRESENT"] = "foo"; Foo[Foo["MISSING"] = `${bar}`] = "MISSING"; })(Foo || (Foo = {}));The template literal initializer for
PRESENTis treated as a string while the template literal initializer forMISSINGis treated as a number. Previously esbuild treated both of these cases as a number but starting with this release, esbuild will now treat both of these cases as a string. This doesn't exactly match the behavior oftscbut in the case where the behavior divergestscreports a compile error, so this seems like acceptible behavior for esbuild. Note that handling these cases completely correctly would require esbuild to parse type declarations (see thedeclarekeyword), which esbuild deliberately doesn't do.Ignore case in CSS in more places
This release makes esbuild's CSS support more case-agnostic, which better matches how browsers work. For example:
/* Original code */ @KeyFrames Foo { From { OpaCity: 0 } To { OpaCity: 1 } } body { CoLoR: YeLLoW } /* Old output (with --minify) */ @KeyFrames Foo{From {OpaCity: 0} To {OpaCity: 1}}body{CoLoR:YeLLoW} /* New output (with --minify) */ @KeyFrames Foo{0%{OpaCity:0}To{OpaCity:1}}body{CoLoR:#ff0}Please never actually write code like this.
Improve the error message for
nullentries inexportsPackage authors can disable package export paths with the
exportsmap inpackage.json. With this release, esbuild now has a clearer error message that points to thenulltoken inpackage.jsonitself instead of to the surrounding context. Here is an example of the new error message:✘ [ERROR] Could not resolve "msw/browser" lib/msw-config.ts:2:28: 2 │ import { setupWorker } from 'msw/browser'; ╵ ~~~~~~~~~~~~~ The path "./browser" cannot be imported from package "msw" because it was explicitly disabled by the package author here: node_modules/msw/package.json:17:14: 17 │ "node": null, ╵ ~~~~ You can mark the path "msw/browser" as external to exclude it from the bundle, which will remove this error and leave the unresolved path in the bundle.Parse and print the
withkeyword inimportstatementsJavaScript was going to have a feature called "import assertions" that adds an
assertkeyword toimportstatements. It looked like this:import stuff from './stuff.json' assert { type: 'json' }The feature provided a way to assert that the imported file is of a certain type (but was not allowed to affect how the import is interpreted, even though that's how everyone expected it to behave). The feature was fully specified and then actually implemented and shipped in Chrome before the people behind the feature realized that they should allow it to affect how the import is interpreted after all. So import assertions are no longer going to be added to the language.
Instead, the current proposal is to add a feature called "import attributes" instead that adds a
withkeyword to import statements. It looks like this:import stuff from './stuff.json' with { type: 'json' }This feature provides a way to affect how the import is interpreted. With this release, esbuild now has preliminary support for parsing and printing this new
withkeyword. Thewithkeyword is not yet interpreted by esbuild, however, so bundling code with it will generate a build error. All this release does is allow you to use esbuild to process code containing it (such as removing types from TypeScript code). Note that this syntax is not yet a part of JavaScript and may be removed or altered in the future if the specification changes (which it already has once, as described above). If that happens, esbuild reserves the right to remove or alter its support for this syntax too.
A whole project to check? Paste its package.json in the dependency check: every deprecated, outdated or vulnerable dependency, with what to upgrade to. Free, no account.