Fix the alias feature to always prefer the longest match (#2963)

It's possible to configure conflicting aliases such as --alias:a=b and --alias:a/c=d, which is ambiguous for the import path a/c/x (since it could map to either b/c/x or d/x). Previously esbuild would pick the first matching alias, which would non-deterministically pick between one of the possible matches. This release fixes esbuild to always deterministically pick the longest possible match.

Minify calls to some global primitive constructors (#2962)

With this release, esbuild's minifier now replaces calls to Boolean/Number/String/BigInt with equivalent shorter code when relevant:

// Original code
console.log(
  Boolean(a ? (b | c) !== 0 : (c & d) !== 0),
  Number(e ? '1' : '2'),
  String(e ? '1' : '2'),
  BigInt(e ? 1n : 2n),
)

// Old output (with --minify)
console.log(Boolean(a?(b|c)!==0:(c&d)!==0),Number(e?"1":"2"),String(e?"1":"2"),BigInt(e?1n:2n));

// New output (with --minify)
console.log(!!(a?b|c:c&d),+(e?"1":"2"),e?"1":"2",e?1n:2n);

Adjust some feature compatibility tables for node (#2940)

This release makes the following adjustments to esbuild's internal feature compatibility tables for node, which tell esbuild which versions of node are known to support all aspects of that feature:

• class-private-brand-checks: node v16.9+ => node v16.4+ (a decrease)
• hashbang: node v12.0+ => node v12.5+ (an increase)
• optional-chain: node v16.9+ => node v16.1+ (a decrease)
• template-literal: node v4+ => node v10+ (an increase)

Each of these adjustments was identified by comparing against data from the node-compat-table package and was manually verified using old node executables downloaded from https://nodejs.org/download/release/.

Update esbuild's handling of CSS nesting to match the latest specification changes (#1945)

The syntax for the upcoming CSS nesting feature has recently changed. The @nest prefix that was previously required in some cases is now gone, and nested rules no longer have to start with & (as long as they don't start with an identifier or function token).

This release updates esbuild's pass-through handling of CSS nesting syntax to match the latest specification changes. So you can now use esbuild to bundle CSS containing nested rules and try them out in a browser that supports CSS nesting (which includes nightly builds of both Chrome and Safari).

However, I'm not implementing lowering of nested CSS to non-nested CSS for older browsers yet. While the syntax has been decided, the semantics are still in flux. In particular, there is still some debate about changing the fundamental way that CSS nesting works. For example, you might think that the following CSS is equivalent to a .outer .inner button { ... } rule:

.inner button {
  .outer & {
    color: red;
  }
}

But instead it's actually equivalent to a .outer :is(.inner button) { ... } rule which unintuitively also matches the following DOM structure:

<div class="inner">
  <div class="outer">
    <button></button>
  </div>
</div>

The :is() behavior is preferred by browser implementers because it's more memory-efficient, but the straightforward translation into a .outer .inner button { ... } rule is preferred by developers used to the existing CSS preprocessing ecosystem (e.g. SASS). It seems premature to commit esbuild to specific semantics for this syntax at this time given the ongoing debate.

Fix cross-file CSS rule deduplication involving url() tokens (#2936)

Previously cross-file CSS rule deduplication didn't handle url() tokens correctly. These tokens contain references to import paths which may be internal (i.e. in the bundle) or external (i.e. not in the bundle). When comparing two url() tokens for equality, the underlying import paths should be compared instead of their references. This release of esbuild fixes url() token comparisons. One side effect is that @font-face rules should now be deduplicated correctly across files:

/* Original code */
@import "data:text/css, \
  @import 'http://example.com/style.css'; \
  @font-face { src: url(http://example.com/font.ttf) }";
@import "data:text/css, \
  @font-face { src: url(http://example.com/font.ttf) }";

/* Old output (with --bundle --minify) */
@import"http://example.com/style.css";@font-face{src:url(http://example.com/font.ttf)}@font-face{src:url(http://example.com/font.ttf)}

/* New output (with --bundle --minify) */
@import"http://example.com/style.css";@font-face{src:url(http://example.com/font.ttf)}

Parse rest bindings in TypeScript types (#2937)

Previously esbuild was unable to parse the following valid TypeScript code:

let tuple: (...[e1, e2, ...es]: any) => any

This release includes support for parsing code like this.

Fix TypeScript code translation for certain computed declare class fields (#2914)

In TypeScript, the key of a computed declare class field should only be preserved if there are no decorators for that field. Previously esbuild always preserved the key, but esbuild will now remove the key to match the output of the TypeScript compiler:

// Original code
declare function dec(a: any, b: any): any
declare const removeMe: unique symbol
declare const keepMe: unique symbol
class X {
    declare [removeMe]: any
    @dec declare [keepMe]: any
}

// Old output
var _a;
class X {
}
removeMe, _a = keepMe;
__decorateClass([
  dec
], X.prototype, _a, 2);

// New output
var _a;
class X {
}
_a = keepMe;
__decorateClass([
  dec
], X.prototype, _a, 2);

Fix a crash with path resolution error generation (#2913)

In certain situations, a module containing an invalid import path could previously cause esbuild to crash when it attempts to generate a more helpful error message. This crash has been fixed.

Fix a CSS parser crash on invalid CSS (#2892)

Previously the following invalid CSS caused esbuild's parser to crash:

@media screen

The crash was caused by trying to construct a helpful error message assuming that there was an opening { token, which is not the case here. This release fixes the crash.

Inline TypeScript enums that are referenced before their declaration

Previously esbuild inlined enums within a TypeScript file from top to bottom, which meant that references to TypeScript enum members were only inlined within the same file if they came after the enum declaration. With this release, esbuild will now inline enums even when they are referenced before they are declared:

// Original input
export const foo = () => Foo.FOO
const enum Foo { FOO = 0 }

// Old output (with --tree-shaking=true)
export const foo = () => Foo.FOO;
var Foo = /* @__PURE__ */ ((Foo2) => {
  Foo2[Foo2["FOO"] = 0] = "FOO";
  return Foo2;
})(Foo || {});

// New output (with --tree-shaking=true)
export const foo = () => 0 /* FOO */;

This makes esbuild's TypeScript output smaller and faster when processing code that does this. I noticed this issue when I ran the TypeScript compiler's source code through esbuild's bundler. Now that the TypeScript compiler is going to be bundled with esbuild in the upcoming TypeScript 5.0 release, improvements like this will also improve the TypeScript compiler itself!

Fix esbuild installation on Arch Linux (#2785, #2812, #2865)

Someone made an unofficial esbuild package for Linux that adds the ESBUILD_BINARY_PATH=/usr/bin/esbuild environment variable to the user's default environment. This breaks all npm installations of esbuild for users with this unofficial Linux package installed, which has affected many people. Most (all?) people who encounter this problem haven't even installed this unofficial package themselves; instead it was installed for them as a dependency of another Linux package. The problematic change to add the ESBUILD_BINARY_PATH environment variable was reverted in the latest version of this unofficial package. However, old versions of this unofficial package are still there and will be around forever. With this release, ESBUILD_BINARY_PATH is now ignored by esbuild's install script when it's set to the value /usr/bin/esbuild. This should unbreak using npm to install esbuild in these problematic Linux environments.

Note: The ESBUILD_BINARY_PATH variable is an undocumented way to override the location of esbuild's binary when esbuild's npm package is installed, which is necessary to substitute your own locally-built esbuild binary when debugging esbuild's npm package. It's only meant for very custom situations and should absolutely not be forced on others by default, especially without their knowledge. I may remove the code in esbuild's installer that reads ESBUILD_BINARY_PATH in the future to prevent these kinds of issues. It will unfortunately make debugging esbuild harder. If ESBUILD_BINARY_PATH is ever removed, it will be done in a "breaking change" release.

Parse const type parameters from TypeScript 5.0

The TypeScript 5.0 beta announcement adds const type parameters to the language. You can now add the const modifier on a type parameter of a function, method, or class like this:

type HasNames = { names: readonly string[] };
const getNamesExactly = <const T extends HasNames>(arg: T): T["names"] => arg.names;
const names = getNamesExactly({ names: ["Alice", "Bob", "Eve"] });

The type of names in the above example is readonly ["Alice", "Bob", "Eve"]. Marking the type parameter as const behaves as if you had written as const at every use instead. The above code is equivalent to the following TypeScript, which was the only option before TypeScript 5.0:

type HasNames = { names: readonly string[] };
const getNamesExactly = <T extends HasNames>(arg: T): T["names"] => arg.names;
const names = getNamesExactly({ names: ["Alice", "Bob", "Eve"] } as const);

You can read the announcement for more information.

Make parsing generic async arrow functions more strict in .tsx files

Previously esbuild's TypeScript parser incorrectly accepted the following code as valid:

let fn = async <T> () => {};

The official TypeScript parser rejects this code because it thinks it's the identifier async followed by a JSX element starting with <T>. So with this release, esbuild will now reject this syntax in .tsx files too. You'll now have to add a comma after the type parameter to get generic arrow functions like this to parse in .tsx files:

let fn = async <T,> () => {};

Allow the in and out type parameter modifiers on class expressions

TypeScript 4.7 added the in and out modifiers on the type parameters of classes, interfaces, and type aliases. However, while TypeScript supported them on both class expressions and class statements, previously esbuild only supported them on class statements due to an oversight. This release now allows these modifiers on class expressions too:

declare let Foo: any;
Foo = class <in T> { };
Foo = class <out T> { };

Update enum constant folding for TypeScript 5.0

TypeScript 5.0 contains an updated definition of what it considers a constant expression:

An expression is considered a constant expression if it is

• a number or string literal,
• a unary +, -, or ~ applied to a numeric constant expression,
• a binary +, -, *, /, %, **, <<, >>, >>>, |, &, ^ applied to two numeric constant expressions,
• a binary + applied to two constant expressions whereof at least one is a string,
• a template expression where each substitution expression is a constant expression,
• a parenthesized constant expression,
• a dotted name (e.g. x.y.z) that references a const variable with a constant expression initializer and no type annotation,
• a dotted name that references an enum member with an enum literal type, or
• a dotted name indexed by a string literal (e.g. x.y["z"]) that references an enum member with an enum literal type.

This impacts esbuild's implementation of TypeScript's const enum feature. With this release, esbuild will now attempt to follow these new rules. For example, you can now initialize an enum member with a template literal expression that contains a numeric constant:

// Original input
const enum Example {
  COUNT = 100,
  ERROR = `Expected ${COUNT} items`,
}
console.log(
  Example.COUNT,
  Example.ERROR,
)

// Old output (with --tree-shaking=true)
var Example = /* @__PURE__ */ ((Example2) => {
  Example2[Example2["COUNT"] = 100] = "COUNT";
  Example2[Example2["ERROR"] = `Expected ${100 /* COUNT */} items`] = "ERROR";
  return Example2;
})(Example || {});
console.log(
  100 /* COUNT */,
  Example.ERROR
);

// New output (with --tree-shaking=true)
console.log(
  100 /* COUNT */,
  "Expected 100 items" /* ERROR */
);

These rules are not followed exactly due to esbuild's limitations. The rule about dotted references to const variables is not followed both because esbuild's enum processing is done in an isolated module setting and because doing so would potentially require esbuild to use a type system, which it doesn't have. For example:

// The TypeScript compiler inlines this but esbuild doesn't:
declare const x = 'foo'
const enum Foo { X = x }
console.log(Foo.X)

Also, the rule that requires converting numbers to a string currently only followed for 32-bit signed integers and non-finite numbers. This is done to avoid accidentally introducing a bug if esbuild's number-to-string operation doesn't exactly match the behavior of a real JavaScript VM. Currently esbuild's number-to-string constant folding is conservative for safety.

Forbid definite assignment assertion operators on class methods

In TypeScript, class methods can use the ? optional property operator but not the ! definite assignment assertion operator (while class fields can use both):

class Foo {
  // These are valid TypeScript
  a?
  b!
  x?() {}

  // This is invalid TypeScript
  y!() {}
}

Previously esbuild incorrectly allowed the definite assignment assertion operator with class methods. This will no longer be allowed starting with this release.

Fix incorrect CSS minification for certain rules (#2838)

Certain rules such as @media could previously be minified incorrectly. Due to a typo in the duplicate rule checker, two known @-rules that share the same hash code were incorrectly considered to be equal. This problem was made worse by the rule hashing code considering two unknown declarations (such as CSS variables) to have the same hash code, which also isn't optimal from a performance perspective. Both of these issues have been fixed:

/* Original input */
@media (prefers-color-scheme: dark) { body { --VAR-1: #000; } }
@media (prefers-color-scheme: dark) { body { --VAR-2: #000; } }

/* Old output (with --minify) */
@media (prefers-color-scheme: dark){body{--VAR-2: #000}}

/* New output (with --minify) */
@media (prefers-color-scheme: dark){body{--VAR-1: #000}}@media (prefers-color-scheme: dark){body{--VAR-2: #000}}